From ae19a941c2723e4369a8f56556f181da177edbfb Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 3 Sep 2025 18:59:43 +0000 Subject: [PATCH 1/9] simplicity-sys: split up bitcoin and elements build Don't actually build bitcoin yet; just refactor build.rs --- simplicity-sys/build.rs | 138 ++++++++++++++++++++++++++++------------ 1 file changed, 98 insertions(+), 40 deletions(-) diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs index 14470d74..065166ce 100644 --- a/simplicity-sys/build.rs +++ b/simplicity-sys/build.rs @@ -7,56 +7,105 @@ fn main() { // rerun if changes to the C code println!("cargo:rerun-if-changed=depend"); let simplicity_path = Path::new("depend/simplicity"); - let jet_files: Vec<_> = vec![ - "frame.c", - "jets.c", - "jets-secp256k1.c", - "rsort.c", - "sha256.c", - "elements/env.c", - "elements/ops.c", - "elements/elementsJets.c", - "elements/txEnv.c", - ] - .into_iter() - .map(|x| simplicity_path.join(x)) - .collect(); + let mut files = vec![]; + + // 1. Base files. + files.extend( + [ + "frame.c", + "jets.c", + "jets-secp256k1.c", + "rsort.c", + "sha256.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + // 2. Test files. + if cfg!(feature = "test-utils") { + files.extend( + [ + "bitstream.c", + "dag.c", + "deserialize.c", + "eval.c", + "type.c", + "typeInference.c", + "ctx8Pruned.c", + "ctx8Unpruned.c", + "hashBlock.c", + "schnorr0.c", + "schnorr6.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + } + + // Split into Bitcoin and Elements. + let mut elements_files = files.clone(); + let mut bitcoin_files = files; + + // 3B. Bitcoin base files. + bitcoin_files.extend( + [ + "bitcoin/env.c", + "bitcoin/ops.c", + "bitcoin/bitcoinJets.c", + "bitcoin/txEnv.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + + // 3E. Elements base files. + elements_files.extend( + [ + "elements/env.c", + "elements/ops.c", + "elements/elementsJets.c", + "elements/txEnv.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + + if cfg!(feature = "test-utils") { + // 4B. Bitcoin base files. + bitcoin_files.extend( + [ + "bitcoin/exec.c", + "bitcoin/primitive.c", + // "bitcoin/checkSigHashAllTx1.c", // no sighashall test + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + + // 4E. Elements base files. + elements_files.extend( + [ + "elements/exec.c", + "elements/primitive.c", + "elements/checkSigHashAllTx1.c", + ] + .into_iter() + .map(|x| simplicity_path.join(x)), + ); + } + + // General build let mut build = cc::Build::new(); build .std("c11") .flag_if_supported("-fno-inline-functions") .opt_level(2) - .files(jet_files) .file(Path::new("depend/wrapper.c")) .file(Path::new("depend/env.c")) .file(Path::new("depend/jets_wrapper.c")) .include(simplicity_path.join("include")); - if cfg!(feature = "test-utils") { - let test_files: Vec<_> = vec![ - "bitstream.c", - "dag.c", - "deserialize.c", - "eval.c", - "type.c", - "typeInference.c", - "elements/exec.c", - "elements/primitive.c", - "ctx8Pruned.c", - "ctx8Unpruned.c", - "hashBlock.c", - "schnorr0.c", - "schnorr6.c", - "elements/checkSigHashAllTx1.c", - ] - .into_iter() - .map(|x| simplicity_path.join(x)) - .collect(); - - build.files(test_files); - } - if cfg!(not(fuzzing)) { build.define("PRODUCTION", None); } @@ -66,5 +115,14 @@ fn main() { build.include("wasm-sysroot"); } - build.compile("ElementsSimplicity"); + let mut _bitcoin_build = build.clone(); + let mut elements_build = build; + + // Bitcoin build + // TODO + + // Elements build + elements_build + .files(elements_files) + .compile("ElementsSimplicity"); } From 8a2d8223ddf39b61bdd31003f05db7fa534c236c Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 3 Sep 2025 21:02:43 +0000 Subject: [PATCH 2/9] simplicity-sys: split env.c into bitcoin_env.c and elements_env.c For dumb "C polymorphism" reasons we have two structures in the C code named txEnv. We can call the corresponding Rust structures different things, but we need to access them from the C file env.c, which provides some C wrappers for FFI stuff. Since you can't have two different structs with the same name in one compilation unit, split it into two. --- simplicity-sys/build.rs | 3 +- simplicity-sys/depend/bitcoin_env.c | 31 +++++++++++++++++++ simplicity-sys/depend/elements_env.c | 33 +++++++++++++++++++++ simplicity-sys/src/c_jets/c_env/elements.rs | 6 ++-- 4 files changed, 69 insertions(+), 4 deletions(-) create mode 100644 simplicity-sys/depend/bitcoin_env.c create mode 100644 simplicity-sys/depend/elements_env.c diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs index 065166ce..e90a6cc5 100644 --- a/simplicity-sys/build.rs +++ b/simplicity-sys/build.rs @@ -58,6 +58,7 @@ fn main() { .into_iter() .map(|x| simplicity_path.join(x)), ); + bitcoin_files.push("depend/bitcoin_env.c".into()); // 3E. Elements base files. elements_files.extend( @@ -70,6 +71,7 @@ fn main() { .into_iter() .map(|x| simplicity_path.join(x)), ); + elements_files.push("depend/elements_env.c".into()); if cfg!(feature = "test-utils") { // 4B. Bitcoin base files. @@ -102,7 +104,6 @@ fn main() { .flag_if_supported("-fno-inline-functions") .opt_level(2) .file(Path::new("depend/wrapper.c")) - .file(Path::new("depend/env.c")) .file(Path::new("depend/jets_wrapper.c")) .include(simplicity_path.join("include")); diff --git a/simplicity-sys/depend/bitcoin_env.c b/simplicity-sys/depend/bitcoin_env.c new file mode 100644 index 00000000..c0eb6db9 --- /dev/null +++ b/simplicity-sys/depend/bitcoin_env.c @@ -0,0 +1,31 @@ +#include +#include +#include "simplicity/bitcoin/env.h" +#include "simplicity/bitcoin/txEnv.h" +#include "simplicity/bitcoin/primitive.h" + +typedef rawBitcoinBuffer rawBuffer; +typedef rawBitcoinBuffer rawBuffer; +typedef rawBitcoinOutput rawOutput; +typedef rawBitcoinInput rawInput; +typedef rawBitcoinTransaction rawTransaction; +typedef rawBitcoinTapEnv rawTapEnv; + +const size_t rustsimplicity_0_6_c_sizeof_rawBitcoinBuffer = sizeof(rawBitcoinBuffer); +const size_t rustsimplicity_0_6_c_sizeof_rawBitcoinOutput = sizeof(rawBitcoinOutput); +const size_t rustsimplicity_0_6_c_sizeof_rawBitcoinInput = sizeof(rawBitcoinInput); +const size_t rustsimplicity_0_6_c_sizeof_rawBitcoinTransaction = sizeof(rawBitcoinTransaction); +const size_t rustsimplicity_0_6_c_sizeof_rawBitcoinTapEnv = sizeof(rawBitcoinTapEnv); +const size_t rustsimplicity_0_6_c_sizeof_bitcoinTxEnv = sizeof(txEnv); + +const size_t rustsimplicity_0_6_c_alignof_rawBitcoinBuffer = alignof(rawBitcoinBuffer); +const size_t rustsimplicity_0_6_c_alignof_rawBitcoinOutput = alignof(rawBitcoinOutput); +const size_t rustsimplicity_0_6_c_alignof_rawBitcoinInput = alignof(rawBitcoinInput); +const size_t rustsimplicity_0_6_c_alignof_rawBitcoinTransaction = alignof(rawBitcoinTransaction); +const size_t rustsimplicity_0_6_c_alignof_rawBitcoinTapEnv = alignof(rawBitcoinTapEnv); +const size_t rustsimplicity_0_6_c_alignof_bitcoinTxEnv = alignof(txEnv); + +void rustsimplicity_0_6_c_bitcoin_set_txEnv(txEnv *result, const bitcoinTransaction *tx, const bitcoinTapEnv *taproot, unsigned int ix) +{ + *result = rustsimplicity_0_6_bitcoin_build_txEnv(tx, taproot, ix); +} diff --git a/simplicity-sys/depend/elements_env.c b/simplicity-sys/depend/elements_env.c new file mode 100644 index 00000000..20414b35 --- /dev/null +++ b/simplicity-sys/depend/elements_env.c @@ -0,0 +1,33 @@ +#include +#include +#include "simplicity/elements/env.h" +#include "simplicity/elements/txEnv.h" +#include "simplicity/elements/primitive.h" + +typedef rawElementsBuffer rawBuffer; +typedef rawElementsBuffer rawBuffer; +typedef rawElementsOutput rawOutput; +typedef rawElementsInput rawInput; +typedef rawElementsTransaction rawTransaction; +typedef rawElementsTapEnv rawTapEnv; + +const size_t rustsimplicity_0_6_c_sizeof_rawElementsBuffer = sizeof(rawElementsBuffer); +const size_t rustsimplicity_0_6_c_sizeof_rawElementsOutput = sizeof(rawElementsOutput); +const size_t rustsimplicity_0_6_c_sizeof_rawElementsInput = sizeof(rawElementsInput); +const size_t rustsimplicity_0_6_c_sizeof_rawElementsTransaction = sizeof(rawElementsTransaction); +const size_t rustsimplicity_0_6_c_sizeof_rawElementsTapEnv = sizeof(rawElementsTapEnv); +const size_t rustsimplicity_0_6_c_sizeof_elementsTxEnv = sizeof(txEnv); + +const size_t rustsimplicity_0_6_c_alignof_rawElementsBuffer = alignof(rawElementsBuffer); +const size_t rustsimplicity_0_6_c_alignof_rawElementsOutput = alignof(rawElementsOutput); +const size_t rustsimplicity_0_6_c_alignof_rawElementsInput = alignof(rawElementsInput); +const size_t rustsimplicity_0_6_c_alignof_rawElementsTransaction = alignof(rawElementsTransaction); +const size_t rustsimplicity_0_6_c_alignof_rawElementsTapEnv = alignof(rawElementsTapEnv); +const size_t rustsimplicity_0_6_c_alignof_elementsTxEnv = alignof(txEnv); + +void rustsimplicity_0_6_c_elements_set_txEnv(txEnv *result, const elementsTransaction *tx, const elementsTapEnv *taproot, const unsigned char *genesisHash, unsigned int ix) +{ + sha256_midstate genesis; + sha256_toMidstate(genesis.s, genesisHash); + *result = rustsimplicity_0_6_elements_build_txEnv(tx, taproot, &genesis, ix); +} diff --git a/simplicity-sys/src/c_jets/c_env/elements.rs b/simplicity-sys/src/c_jets/c_env/elements.rs index 6991f2fc..d8edb970 100644 --- a/simplicity-sys/src/c_jets/c_env/elements.rs +++ b/simplicity-sys/src/c_jets/c_env/elements.rs @@ -117,7 +117,7 @@ extern "C" { pub static c_sizeof_rawTransaction: c_size_t; #[link_name = "rustsimplicity_0_6_c_sizeof_rawElementsTapEnv"] pub static c_sizeof_rawTapEnv: c_size_t; - #[link_name = "rustsimplicity_0_6_c_sizeof_txEnv"] + #[link_name = "rustsimplicity_0_6_c_sizeof_elementsTxEnv"] pub static c_sizeof_txEnv: c_size_t; #[link_name = "rustsimplicity_0_6_c_alignof_rawElementsBuffer"] @@ -130,10 +130,10 @@ extern "C" { pub static c_alignof_rawTransaction: c_size_t; #[link_name = "rustsimplicity_0_6_c_alignof_rawElementsTapEnv"] pub static c_alignof_rawTapEnv: c_size_t; - #[link_name = "rustsimplicity_0_6_c_alignof_txEnv"] + #[link_name = "rustsimplicity_0_6_c_alignof_elementsTxEnv"] pub static c_alignof_txEnv: c_size_t; - #[link_name = "rustsimplicity_0_6_c_set_txEnv"] + #[link_name = "rustsimplicity_0_6_c_elements_set_txEnv"] pub fn c_set_txEnv( result: *mut CTxEnv, tx: *const CTransaction, From f2464cac237928ebb48015ec5926d9f786394f48 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 3 Sep 2025 19:56:00 +0000 Subject: [PATCH 3/9] simplicity-sys: define bitcoin transaction environment --- simplicity-sys/src/c_jets/c_env/bitcoin.rs | 176 +++++++++++++++++++++ simplicity-sys/src/c_jets/c_env/mod.rs | 1 + simplicity-sys/src/c_jets/mod.rs | 2 +- simplicity-sys/src/lib.rs | 1 + 4 files changed, 179 insertions(+), 1 deletion(-) create mode 100644 simplicity-sys/src/c_jets/c_env/bitcoin.rs diff --git a/simplicity-sys/src/c_jets/c_env/bitcoin.rs b/simplicity-sys/src/c_jets/c_env/bitcoin.rs new file mode 100644 index 00000000..44e69f9c --- /dev/null +++ b/simplicity-sys/src/c_jets/c_env/bitcoin.rs @@ -0,0 +1,176 @@ +// SPDX-License-Identifier: CC0-1.0 + +use hashes::{sha256, Hash}; + +use crate::ffi::sha256::CSha256Midstate; +use crate::ffi::{c_size_t, c_uchar, c_uint, c_uint_fast32_t}; + +#[derive(Debug)] +#[repr(C)] +pub struct CRawBuffer { + pub ptr: *const c_uchar, + pub len: u32, +} + +#[derive(Debug)] +#[repr(C)] +pub struct CRawOutput { + pub value: u64, + pub script_pubkey: CRawBuffer, +} + +#[repr(C)] +pub struct CRawInput<'raw> { + pub annex: *const CRawBuffer, + pub prev_txid: &'raw [c_uchar; 32], + pub txo: CRawOutput, + pub script_sig: CRawBuffer, + pub prev_txout_index: u32, + pub sequence: u32, +} + +#[derive(Debug)] +#[repr(C)] +pub struct CRawTransaction<'raw> { + pub txid: &'raw [c_uchar; 32], + pub inputs: *const CRawInput<'raw>, + pub outputs: *const CRawOutput, + pub n_inputs: u32, + pub n_outputs: u32, + pub version: u32, + pub locktime: u32, +} + +#[derive(Debug)] +#[repr(C)] +pub struct CRawTapEnv { + pub control_block: *const c_uchar, + pub script_cmr: *const c_uchar, + pub branch_len: u8, +} + +#[repr(C)] +pub struct CTransaction { + _data: (), +} + +#[derive(Debug)] +#[repr(C)] +pub struct CTxEnv { + tx: *const CTransaction, + taproot: *const CTapEnv, + sighash_all: CSha256Midstate, + ix: c_uint_fast32_t, +} + +#[repr(C)] +pub struct CTapEnv { + _data: (), +} + +/* +// Will uncomment in a later commit; need to update libsimplicity first so these +// symbols have something to link against. +extern "C" { + #[link_name = "rustsimplicity_0_6_c_sizeof_rawBitcoinBuffer"] + pub static c_sizeof_rawBuffer: c_size_t; + #[link_name = "rustsimplicity_0_6_c_sizeof_rawBitcoinOutput"] + pub static c_sizeof_rawOutput: c_size_t; + #[link_name = "rustsimplicity_0_6_c_sizeof_rawBitcoinInput"] + pub static c_sizeof_rawInput: c_size_t; + #[link_name = "rustsimplicity_0_6_c_sizeof_rawBitcoinTransaction"] + pub static c_sizeof_rawTransaction: c_size_t; + #[link_name = "rustsimplicity_0_6_c_sizeof_rawBitcoinTapEnv"] + pub static c_sizeof_rawTapEnv: c_size_t; + #[link_name = "rustsimplicity_0_6_c_sizeof_bitcoinTxEnv"] + pub static c_sizeof_txEnv: c_size_t; + + #[link_name = "rustsimplicity_0_6_c_alignof_rawBitcoinBuffer"] + pub static c_alignof_rawBuffer: c_size_t; + #[link_name = "rustsimplicity_0_6_c_alignof_rawBitcoinOutput"] + pub static c_alignof_rawOutput: c_size_t; + #[link_name = "rustsimplicity_0_6_c_alignof_rawBitcoinInput"] + pub static c_alignof_rawInput: c_size_t; + #[link_name = "rustsimplicity_0_6_c_alignof_rawBitcoinTransaction"] + pub static c_alignof_rawTransaction: c_size_t; + #[link_name = "rustsimplicity_0_6_c_alignof_rawBitcoinTapEnv"] + pub static c_alignof_rawTapEnv: c_size_t; + #[link_name = "rustsimplicity_0_6_c_alignof_bitcoinTxEnv"] + pub static c_alignof_txEnv: c_size_t; + + #[link_name = "rustsimplicity_0_6_c_bitcoin_set_txEnv"] + pub fn c_set_txEnv( + result: *mut CTxEnv, + tx: *const CTransaction, + taproot: *const CTapEnv, + ix: c_uint, + ); + #[link_name = "rustsimplicity_0_6_bitcoin_mallocTapEnv"] + pub fn simplicity_mallocTapEnv(rawEnv: *const CRawTapEnv) -> *mut CTapEnv; + #[link_name = "rustsimplicity_0_6_bitcoin_mallocTransaction"] + pub fn simplicity_mallocTransaction(rawTx: *const CRawTransaction) -> *mut CTransaction; +} +*/ +impl CTxEnv { + pub fn sighash_all(&self) -> sha256::Hash { + let midstate: sha256::Midstate = self.sighash_all.into(); + sha256::Hash::from_byte_array(midstate.to_byte_array()) + } +} + +// Pointer must be manually free after dropping +impl Drop for CTxEnv { + fn drop(&mut self) { + unsafe { + crate::alloc::rust_0_6_free(self.tx as *mut u8); + crate::alloc::rust_0_6_free(self.taproot as *mut u8); + } + } +} + +impl CRawBuffer { + pub fn new(buf: &[c_uchar]) -> Self { + Self { + ptr: buf.as_ptr(), + len: buf.len().try_into().expect("sane buffer lengths"), + } + } +} + +/* +// Will uncomment in a later commit; need to update libsimplicity first. +#[cfg(test)] +mod tests { + use core::mem::{align_of, size_of}; + + use crate::c_jets::frame_ffi::{c_alignof_frameItem, c_sizeof_frameItem, CFrameItem}; + + use super::*; + + #[test] + fn test_sizes() { + unsafe { + assert_eq!(size_of::(), c_sizeof_frameItem); + assert_eq!(size_of::(), c_sizeof_rawBuffer); + assert_eq!(size_of::(), c_sizeof_rawInput); + assert_eq!(size_of::(), c_sizeof_rawOutput); + assert_eq!(size_of::(), c_sizeof_rawTransaction); + assert_eq!(size_of::(), c_sizeof_rawTapEnv); + assert_eq!(size_of::(), c_sizeof_txEnv); + } + } + + #[test] + fn test_aligns() { + unsafe { + assert_eq!(align_of::(), c_alignof_frameItem); + assert_eq!(align_of::(), c_alignof_rawBuffer); + assert_eq!(align_of::(), c_alignof_rawInput); + assert_eq!(align_of::(), c_alignof_rawOutput); + assert_eq!(align_of::(), c_alignof_rawTransaction); + assert_eq!(align_of::(), c_alignof_rawTapEnv); + assert_eq!(align_of::(), c_alignof_txEnv); + } + } +} +*/ diff --git a/simplicity-sys/src/c_jets/c_env/mod.rs b/simplicity-sys/src/c_jets/c_env/mod.rs index fcca587c..6136d485 100644 --- a/simplicity-sys/src/c_jets/c_env/mod.rs +++ b/simplicity-sys/src/c_jets/c_env/mod.rs @@ -1,3 +1,4 @@ // SPDX-License-Identifier: CC0-1.0 +pub mod bitcoin; pub mod elements; diff --git a/simplicity-sys/src/c_jets/mod.rs b/simplicity-sys/src/c_jets/mod.rs index 2cc7d864..f91872b3 100644 --- a/simplicity-sys/src/c_jets/mod.rs +++ b/simplicity-sys/src/c_jets/mod.rs @@ -12,7 +12,7 @@ pub mod frame_ffi; #[rustfmt::skip] pub mod jets_ffi; #[rustfmt::skip] pub mod jets_wrapper; -pub use c_env::elements; +pub use c_env::{bitcoin, elements}; pub use c_frame::{byte_width, uword_width}; pub use frame_ffi::CFrameItem; diff --git a/simplicity-sys/src/lib.rs b/simplicity-sys/src/lib.rs index 8202a892..f5993a10 100644 --- a/simplicity-sys/src/lib.rs +++ b/simplicity-sys/src/lib.rs @@ -1,6 +1,7 @@ // SPDX-License-Identifier: CC0-1.0 pub mod c_jets; +pub use c_jets::bitcoin; pub use c_jets::elements; pub use c_jets::CFrameItem; From b0a25c202e86a64ce3b32fb120bc26c8cf359419 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Thu, 18 Dec 2025 16:32:23 +0000 Subject: [PATCH 4/9] jet: add CoreEnv::EMPTY constant When we update libsimplicity we will use a new type for the Core environment rather than directly using (). Then we will need to use CoreEnv::EMPTY as the value everywhere. To minimize the later diff, do this change now, where for now we just set CoreEnv::EMPTY equal to (). --- src/bit_machine/mod.rs | 2 +- src/human_encoding/mod.rs | 35 +++++++++++++++++++++++---------- src/human_encoding/parse/mod.rs | 4 ++-- src/jet/core/mod.rs | 12 +++++++++++ src/jet/mod.rs | 6 ++++-- src/node/commit.rs | 2 +- 6 files changed, 45 insertions(+), 16 deletions(-) create mode 100644 src/jet/core/mod.rs diff --git a/src/bit_machine/mod.rs b/src/bit_machine/mod.rs index 39c7b35e..68c88c22 100644 --- a/src/bit_machine/mod.rs +++ b/src/bit_machine/mod.rs @@ -697,7 +697,7 @@ mod tests { for _ in 0..100 { bomb = Node::pair(&bomb, &bomb).unwrap(); } - let _ = bomb.finalize_pruned(&()); + let _ = bomb.finalize_pruned(&crate::jet::CoreEnv::EMPTY); }); } } diff --git a/src/human_encoding/mod.rs b/src/human_encoding/mod.rs index 4db0b355..006f86cb 100644 --- a/src/human_encoding/mod.rs +++ b/src/human_encoding/mod.rs @@ -290,13 +290,18 @@ mod tests { (Arc::from("a"), Value::u8(0x00)), (Arc::from("b"), Value::u8(0x01)), ]); - assert_finalize_ok::(s, &a_less_than_b, &()); + assert_finalize_ok::(s, &a_less_than_b, &crate::jet::CoreEnv::EMPTY); let b_greater_equal_a = HashMap::from([ (Arc::from("a"), Value::u8(0x01)), (Arc::from("b"), Value::u8(0x01)), ]); - assert_finalize_err::(s, &b_greater_equal_a, &(), "Jet failed during execution"); + assert_finalize_err::( + s, + &b_greater_equal_a, + &crate::jet::CoreEnv::EMPTY, + "Jet failed during execution", + ); } #[test] @@ -311,7 +316,7 @@ mod tests { main := comp wits_are_equal jet_verify : 1 -> 1 ", &witness, - &(), + &crate::jet::CoreEnv::EMPTY, "Jet failed during execution", ); } @@ -326,16 +331,21 @@ mod tests { main := comp input comp process jet_verify : 1 -> 1 "; let wit2_is_pruned = HashMap::from([(Arc::from("wit1"), Value::u1(0))]); - assert_finalize_ok::(s, &wit2_is_pruned, &()); + assert_finalize_ok::(s, &wit2_is_pruned, &crate::jet::CoreEnv::EMPTY); let wit2_is_missing = HashMap::from([(Arc::from("wit1"), Value::u1(1))]); - assert_finalize_err::(s, &wit2_is_missing, &(), "Jet failed during execution"); + assert_finalize_err::( + s, + &wit2_is_missing, + &crate::jet::CoreEnv::EMPTY, + "Jet failed during execution", + ); let wit2_is_present = HashMap::from([ (Arc::from("wit1"), Value::u1(1)), (Arc::from("wit2"), Value::u64(u64::MAX)), ]); - assert_finalize_ok::(s, &wit2_is_present, &()); + assert_finalize_ok::(s, &wit2_is_present, &crate::jet::CoreEnv::EMPTY); } #[test] @@ -348,7 +358,7 @@ mod tests { hole := unit ", &empty, - &(), + &crate::jet::CoreEnv::EMPTY, ); } @@ -361,7 +371,7 @@ mod tests { main := comp wit1 comp disconnect iden ?dis2 unit ", &empty, - &(), + &crate::jet::CoreEnv::EMPTY, "disconnect node had one child (redeem time); must have two", ); } @@ -374,9 +384,14 @@ mod tests { main := comp wit2 jet_verify : 1 -> 1 "; let wit1_populated = HashMap::from([(Arc::from("wit1"), Value::u1(1))]); - assert_finalize_err::(s, &wit1_populated, &(), "Jet failed during execution"); + assert_finalize_err::( + s, + &wit1_populated, + &crate::jet::CoreEnv::EMPTY, + "Jet failed during execution", + ); let wit2_populated = HashMap::from([(Arc::from("wit2"), Value::u1(1))]); - assert_finalize_ok::(s, &wit2_populated, &()); + assert_finalize_ok::(s, &wit2_populated, &crate::jet::CoreEnv::EMPTY); } } diff --git a/src/human_encoding/parse/mod.rs b/src/human_encoding/parse/mod.rs index 90d5c121..ef087929 100644 --- a/src/human_encoding/parse/mod.rs +++ b/src/human_encoding/parse/mod.rs @@ -677,7 +677,7 @@ mod tests { "main := unit", "c40a10263f7436b4160acbef1c36fba4be4d95df181a968afeab5eac247adff7", &empty, - &(), + &crate::jet::CoreEnv::EMPTY, ); let witness = HashMap::from([ @@ -694,7 +694,7 @@ mod tests { ", "d7969920eff9a1ed0359aaa8545b239c69969e22c304c645a7b49bcc976a40a8", &witness, - &(), + &crate::jet::CoreEnv::EMPTY, ); } diff --git a/src/jet/core/mod.rs b/src/jet/core/mod.rs new file mode 100644 index 00000000..bea0c672 --- /dev/null +++ b/src/jet/core/mod.rs @@ -0,0 +1,12 @@ +// SPDX-License-Identifier: CC0-1.0 + +use core::convert::Infallible; +use core::marker::PhantomData; + +pub struct CoreEnv(PhantomData); + +impl CoreEnv { + // After update to rust-simplicity this will be a Self. For now it needs to be () + // for compatibility with the existing impl of Jet for Core. + pub const EMPTY: () = (); +} diff --git a/src/jet/mod.rs b/src/jet/mod.rs index 085b0d12..a6f2162d 100644 --- a/src/jet/mod.rs +++ b/src/jet/mod.rs @@ -14,11 +14,13 @@ #[cfg(feature = "bitcoin")] pub mod bitcoin; +mod core; #[cfg(feature = "elements")] pub mod elements; mod init; pub mod type_name; +pub use self::core::CoreEnv; #[cfg(feature = "bitcoin")] pub use init::bitcoin::Bitcoin; pub use init::core::Core; @@ -111,7 +113,7 @@ mod tests { ) .unwrap(); assert_eq!( - BitMachine::test_exec(two_words, &()).expect("executing"), + BitMachine::test_exec(two_words, &crate::jet::CoreEnv::EMPTY).expect("executing"), Value::product( Value::u1(0), // carry bit Value::u32(2 + 16), // result @@ -129,7 +131,7 @@ mod tests { ) .unwrap(); assert_eq!( - BitMachine::test_exec(two_words, &()).expect("executing"), + BitMachine::test_exec(two_words, &crate::jet::CoreEnv::EMPTY).expect("executing"), Value::product(Value::u32(2), Value::u16(16)), ); }); diff --git a/src/node/commit.rs b/src/node/commit.rs index 64a89836..5cd393c7 100644 --- a/src/node/commit.rs +++ b/src/node/commit.rs @@ -565,7 +565,7 @@ mod tests { // Execute the program to confirm that it worked let mut mac = BitMachine::for_program(&diff1_final).expect("program has reasonable bounds"); - mac.exec(&diff1_final, &()).unwrap(); + mac.exec(&diff1_final, &crate::jet::CoreEnv::EMPTY).unwrap(); } } From c7cf0c288df49eaf223a9d16eda0cb34870610ed Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Thu, 18 Dec 2025 16:49:05 +0000 Subject: [PATCH 5/9] jet: switch from Deref to Borrow for transaction environments This is the more correct trait. When we update the Jet trait we will be forced to pick one, and we will pick Borrow. --- src/jet/bitcoin/environment.rs | 26 +++++++++++--------------- src/jet/elements/environment.rs | 10 +++++----- src/jet/mod.rs | 6 +++--- src/policy/sighash.rs | 2 +- 4 files changed, 20 insertions(+), 24 deletions(-) diff --git a/src/jet/bitcoin/environment.rs b/src/jet/bitcoin/environment.rs index c530cec6..22c9f85a 100644 --- a/src/jet/bitcoin/environment.rs +++ b/src/jet/bitcoin/environment.rs @@ -1,26 +1,22 @@ // SPDX-License-Identifier: CC0-1.0 -use bitcoin::absolute; +use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin; /// Environment for Bitcoin Simplicity -pub struct BitcoinEnv { - pub tx: bitcoin::Transaction, +// In later commit, when we update Jet trait, will remove default type. +pub struct BitcoinEnv { + pub tx: T, } -impl BitcoinEnv { - pub fn new(tx: bitcoin::Transaction) -> Self { +impl BitcoinEnv +where + T: core::borrow::Borrow, +{ + pub fn new(tx: T) -> Self { BitcoinEnv { tx } } -} -impl Default for BitcoinEnv { - fn default() -> Self { - // FIXME: Review and check if the defaults make sense - BitcoinEnv::new(bitcoin::Transaction { - version: bitcoin::transaction::Version::TWO, - lock_time: absolute::LockTime::ZERO, - input: vec![], - output: vec![], - }) + pub fn c_tx_env(&self) -> &c_bitcoin::CTxEnv { + unimplemented!() } } diff --git a/src/jet/elements/environment.rs b/src/jet/elements/environment.rs index fc3a9433..dd7834df 100644 --- a/src/jet/elements/environment.rs +++ b/src/jet/elements/environment.rs @@ -4,7 +4,7 @@ use crate::merkle::cmr::Cmr; use elements::confidential; use elements::taproot::ControlBlock; use simplicity_sys::c_jets::c_env::elements as c_elements; -use std::ops::Deref; +use std::borrow::Borrow; use super::c_env; @@ -37,7 +37,7 @@ impl From for ElementsUtxo { /// The order of `utxos` must be same as of the order of inputs in the /// transaction. #[derive(Debug)] -pub struct ElementsEnv> { +pub struct ElementsEnv> { /// The CTxEnv struct c_tx_env: c_elements::CTxEnv, /// The elements transaction @@ -54,7 +54,7 @@ pub struct ElementsEnv> { impl ElementsEnv where - T: Deref, + T: Borrow, { pub fn new( tx: T, @@ -65,7 +65,7 @@ where annex: Option>, genesis_hash: elements::BlockHash, ) -> Self { - let c_tx = c_env::new_tx(&tx, &utxos); + let c_tx = c_env::new_tx(tx.borrow(), &utxos); let c_tap_env = c_env::new_tap_env(&control_block, script_cmr); let c_tx_env = c_env::new_tx_env(c_tx, c_tap_env, genesis_hash, ix); ElementsEnv { @@ -85,7 +85,7 @@ where /// Returns the transaction of this environment pub fn tx(&self) -> &elements::Transaction { - &self.tx + self.tx.borrow() } /// Returns the input index of this environment diff --git a/src/jet/mod.rs b/src/jet/mod.rs index a6f2162d..688d8ea3 100644 --- a/src/jet/mod.rs +++ b/src/jet/mod.rs @@ -93,7 +93,7 @@ pub trait Jet: #[cfg(test)] mod tests { - use crate::jet::Core; + use crate::jet::{Core, CoreEnv}; use crate::node::{ConstructNode, CoreConstructible, JetConstructible}; use crate::types; use crate::value::Word; @@ -113,7 +113,7 @@ mod tests { ) .unwrap(); assert_eq!( - BitMachine::test_exec(two_words, &crate::jet::CoreEnv::EMPTY).expect("executing"), + BitMachine::test_exec(two_words, &CoreEnv::EMPTY).expect("executing"), Value::product( Value::u1(0), // carry bit Value::u32(2 + 16), // result @@ -131,7 +131,7 @@ mod tests { ) .unwrap(); assert_eq!( - BitMachine::test_exec(two_words, &crate::jet::CoreEnv::EMPTY).expect("executing"), + BitMachine::test_exec(two_words, &CoreEnv::EMPTY).expect("executing"), Value::product(Value::u32(2), Value::u16(16)), ); }); diff --git a/src/policy/sighash.rs b/src/policy/sighash.rs index 2766c454..d65ca7aa 100644 --- a/src/policy/sighash.rs +++ b/src/policy/sighash.rs @@ -81,7 +81,7 @@ impl + Clone> SighashCache { .collect(); let simplicity_env = crate::jet::elements::ElementsEnv::new( - self.tx.clone(), + (*self.tx).borrow(), utxos, input_index as u32, script_cmr, From 17fd5a829793aa3ad3c1cdf0fda7f3bd3a02134b Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 3 Sep 2025 18:47:15 +0000 Subject: [PATCH 6/9] simplicity-sys: update libsimplicity to bitcoin branch Updates to https://github.com/BlockstreamResearch/simplicity/pull/324 This PR does a couple things simultaneously: * Runs vendor-simplicity.sh and update-jets.sh * Updates the `Jet` trait to have associated transaction and environment types, and for the environment to be paramterized by the transaction type. * Changes the Core environment from () to CoreEnv:: * Updates some fixed Core CMR/IHR vectors (this update to libsimplicity changes the benchmarks for the Core jets and thus changes these vectors) * Uncomments the commented-out symbols in simplicity-sys/src/c_jets/c_env/bitcoin.rs * Adds the "build bitcoin" lines to simplicity-sys/build.rs The update to the `Jet` trait is a bit noisy but ultimately mechanical: everywhere that we're generic over all J: Jet, we now also have to be generic over all T: Borrow, which leads to some extra line noise especially in unit tests where we have assert_* helper functions. The last four points are tiny diffs, thanks to the previous preparatory commits. The use of CoreEnv:: as the core environment type is kinda fun. It means that it is impossible to execute any code which attempts to access the transaction in the environment. (No such code exists, since it would be nonsensical, but now we have some assurance that it won't exist by accident in the future.) Unfortunately this mixes mechanical and non-mechanical things in one commit. But the mechanical changes are exclusively in simplicity-sys/depend/ and src/jet/init/ and the non-mechanical changes are exclusively outside of those files, so it should be possible to review this. --- simplicity-sys/build.rs | 6 +- simplicity-sys/depend/jets_wrapper.c | 61 + .../depend/simplicity-HEAD-revision.txt | 2 +- .../depend/simplicity/CMakeLists.txt | 36 + simplicity-sys/depend/simplicity/Makefile | 11 +- .../depend/simplicity/bitcoin/bitcoinJets.c | 592 +++ .../depend/simplicity/bitcoin/bitcoinJets.h | 70 + .../depend/simplicity/bitcoin/cmr.c | 22 + .../simplicity/bitcoin/decodeBitcoinJets.inc | 87 + .../depend/simplicity/bitcoin/env.c | 268 ++ .../depend/simplicity/bitcoin/exec.c | 136 + .../depend/simplicity/bitcoin/ops.c | 56 + .../depend/simplicity/bitcoin/ops.h | 23 + .../depend/simplicity/bitcoin/primitive.c | 107 + .../depend/simplicity/bitcoin/primitive.h | 41 + .../simplicity/bitcoin/primitiveEnumJet.inc | 429 +++ .../simplicity/bitcoin/primitiveEnumTy.inc | 130 + .../simplicity/bitcoin/primitiveInitTy.inc | 130 + .../simplicity/bitcoin/primitiveJetNode.inc | 3425 +++++++++++++++++ .../depend/simplicity/bitcoin/txEnv.c | 22 + .../depend/simplicity/bitcoin/txEnv.h | 109 + simplicity-sys/depend/simplicity/cmr.c | 41 + simplicity-sys/depend/simplicity/cmr.h | 24 + .../depend/simplicity/elements/cmr.c | 25 +- .../include/simplicity/bitcoin/cmr.h | 23 + .../include/simplicity/bitcoin/env.h | 98 + .../include/simplicity/bitcoin/exec.h | 41 + simplicity-sys/depend/simplicity/test.c | 40 +- simplicity-sys/src/c_jets/c_env/bitcoin.rs | 5 +- simplicity-sys/src/c_jets/jets_ffi.rs | 1936 ++++++++-- simplicity-sys/src/c_jets/jets_wrapper.rs | 1635 +++++--- src/bit_machine/mod.rs | 19 +- src/human_encoding/mod.rs | 29 +- src/human_encoding/parse/mod.rs | 15 +- src/jet/bitcoin/environment.rs | 3 +- src/jet/core/environment.rs | 1 + src/jet/core/mod.rs | 4 +- src/jet/init/bitcoin.rs | 962 ++++- src/jet/init/core.rs | 3051 ++++++++------- src/jet/init/elements.rs | 500 ++- src/jet/mod.rs | 10 +- src/merkle/amr.rs | 2 +- src/node/commit.rs | 4 +- src/node/construct.rs | 5 +- src/node/redeem.rs | 28 +- 45 files changed, 11660 insertions(+), 2604 deletions(-) create mode 100644 simplicity-sys/depend/simplicity/CMakeLists.txt create mode 100644 simplicity-sys/depend/simplicity/bitcoin/bitcoinJets.c create mode 100644 simplicity-sys/depend/simplicity/bitcoin/bitcoinJets.h create mode 100644 simplicity-sys/depend/simplicity/bitcoin/cmr.c create mode 100644 simplicity-sys/depend/simplicity/bitcoin/decodeBitcoinJets.inc create mode 100644 simplicity-sys/depend/simplicity/bitcoin/env.c create mode 100644 simplicity-sys/depend/simplicity/bitcoin/exec.c create mode 100644 simplicity-sys/depend/simplicity/bitcoin/ops.c create mode 100644 simplicity-sys/depend/simplicity/bitcoin/ops.h create mode 100644 simplicity-sys/depend/simplicity/bitcoin/primitive.c create mode 100644 simplicity-sys/depend/simplicity/bitcoin/primitive.h create mode 100644 simplicity-sys/depend/simplicity/bitcoin/primitiveEnumJet.inc create mode 100644 simplicity-sys/depend/simplicity/bitcoin/primitiveEnumTy.inc create mode 100644 simplicity-sys/depend/simplicity/bitcoin/primitiveInitTy.inc create mode 100644 simplicity-sys/depend/simplicity/bitcoin/primitiveJetNode.inc create mode 100644 simplicity-sys/depend/simplicity/bitcoin/txEnv.c create mode 100644 simplicity-sys/depend/simplicity/bitcoin/txEnv.h create mode 100644 simplicity-sys/depend/simplicity/cmr.c create mode 100644 simplicity-sys/depend/simplicity/cmr.h create mode 100644 simplicity-sys/depend/simplicity/include/simplicity/bitcoin/cmr.h create mode 100644 simplicity-sys/depend/simplicity/include/simplicity/bitcoin/env.h create mode 100644 simplicity-sys/depend/simplicity/include/simplicity/bitcoin/exec.h create mode 100644 src/jet/core/environment.rs diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs index e90a6cc5..2b82eb36 100644 --- a/simplicity-sys/build.rs +++ b/simplicity-sys/build.rs @@ -116,11 +116,13 @@ fn main() { build.include("wasm-sysroot"); } - let mut _bitcoin_build = build.clone(); + let mut bitcoin_build = build.clone(); let mut elements_build = build; // Bitcoin build - // TODO + bitcoin_build + .files(bitcoin_files) + .compile("BitcoinSimplicity"); // Elements build elements_build diff --git a/simplicity-sys/depend/jets_wrapper.c b/simplicity-sys/depend/jets_wrapper.c index 309219e1..07530c94 100644 --- a/simplicity-sys/depend/jets_wrapper.c +++ b/simplicity-sys/depend/jets_wrapper.c @@ -1,5 +1,6 @@ /* This file has been automatically generated. */ +#include "simplicity/bitcoin/bitcoinJets.h" #include "simplicity/elements/elementsJets.h" #include "simplicity/simplicity_assert.h" #include "wrapper.h" @@ -17,11 +18,15 @@ WRAP_(and_16) WRAP_(and_32) WRAP_(and_64) WRAP_(and_8) +WRAP_(bitcoin_annex_hash) WRAP_(annex_hash) WRAP_(asset_amount_hash) WRAP_(bip_0340_verify) +WRAP_(bitcoin_build_tapbranch) WRAP_(build_tapbranch) +WRAP_(bitcoin_build_tapleaf_simplicity) WRAP_(build_tapleaf_simplicity) +WRAP_(bitcoin_build_taptweak) WRAP_(build_taptweak) WRAP_(calculate_asset) WRAP_(calculate_confidential_token) @@ -32,9 +37,13 @@ WRAP_(ch_16) WRAP_(ch_32) WRAP_(ch_64) WRAP_(ch_8) +WRAP_(bitcoin_check_lock_distance) WRAP_(check_lock_distance) +WRAP_(bitcoin_check_lock_duration) WRAP_(check_lock_duration) +WRAP_(bitcoin_check_lock_height) WRAP_(check_lock_height) +WRAP_(bitcoin_check_lock_time) WRAP_(check_lock_time) WRAP_(check_sig_verify) WRAP_(complement_1) @@ -43,8 +52,10 @@ WRAP_(complement_32) WRAP_(complement_64) WRAP_(complement_8) WRAP_(current_amount) +WRAP_(bitcoin_current_annex_hash) WRAP_(current_annex_hash) WRAP_(current_asset) +WRAP_(bitcoin_current_index) WRAP_(current_index) WRAP_(current_issuance_asset_amount) WRAP_(current_issuance_asset_proof) @@ -52,12 +63,17 @@ WRAP_(current_issuance_token_amount) WRAP_(current_issuance_token_proof) WRAP_(current_new_issuance_contract) WRAP_(current_pegin) +WRAP_(bitcoin_current_prev_outpoint) WRAP_(current_prev_outpoint) WRAP_(current_reissuance_blinding) WRAP_(current_reissuance_entropy) +WRAP_(bitcoin_current_script_hash) WRAP_(current_script_hash) +WRAP_(bitcoin_current_script_sig_hash) WRAP_(current_script_sig_hash) +WRAP_(bitcoin_current_sequence) WRAP_(current_sequence) +WRAP_(bitcoin_current_value) WRAP_(decompress) WRAP_(decrement_16) WRAP_(decrement_32) @@ -92,6 +108,7 @@ WRAP_(fe_negate) WRAP_(fe_normalize) WRAP_(fe_square) WRAP_(fe_square_root) +WRAP_(bitcoin_fee) WRAP_(full_add_16) WRAP_(full_add_32) WRAP_(full_add_64) @@ -178,22 +195,39 @@ WRAP_(increment_64) WRAP_(increment_8) WRAP_(input_amount) WRAP_(input_amounts_hash) +WRAP_(bitcoin_input_annex_hash) WRAP_(input_annex_hash) +WRAP_(bitcoin_input_annexes_hash) WRAP_(input_annexes_hash) WRAP_(input_asset) +WRAP_(bitcoin_input_hash) WRAP_(input_hash) +WRAP_(bitcoin_input_outpoints_hash) WRAP_(input_outpoints_hash) WRAP_(input_pegin) +WRAP_(bitcoin_input_prev_outpoint) WRAP_(input_prev_outpoint) +WRAP_(bitcoin_input_script_hash) WRAP_(input_script_hash) +WRAP_(bitcoin_input_script_sig_hash) WRAP_(input_script_sig_hash) +WRAP_(bitcoin_input_script_sigs_hash) WRAP_(input_script_sigs_hash) +WRAP_(bitcoin_input_scripts_hash) WRAP_(input_scripts_hash) +WRAP_(bitcoin_input_sequence) WRAP_(input_sequence) +WRAP_(bitcoin_input_sequences_hash) WRAP_(input_sequences_hash) +WRAP_(bitcoin_input_utxo_hash) WRAP_(input_utxo_hash) +WRAP_(bitcoin_input_utxos_hash) WRAP_(input_utxos_hash) +WRAP_(bitcoin_input_value) +WRAP_(bitcoin_input_values_hash) +WRAP_(bitcoin_inputs_hash) WRAP_(inputs_hash) +WRAP_(bitcoin_internal_key) WRAP_(internal_key) WRAP_(is_one_16) WRAP_(is_one_32) @@ -284,6 +318,7 @@ WRAP_(leftmost_8_2) WRAP_(leftmost_8_4) WRAP_(linear_combination_1) WRAP_(linear_verify_1) +WRAP_(bitcoin_lock_time) WRAP_(lock_time) WRAP_(low_1) WRAP_(low_16) @@ -325,7 +360,9 @@ WRAP_(negate_64) WRAP_(negate_8) WRAP_(new_issuance_contract) WRAP_(nonce_hash) +WRAP_(bitcoin_num_inputs) WRAP_(num_inputs) +WRAP_(bitcoin_num_outputs) WRAP_(num_outputs) WRAP_(one_16) WRAP_(one_32) @@ -336,10 +373,12 @@ WRAP_(or_16) WRAP_(or_32) WRAP_(or_64) WRAP_(or_8) +WRAP_(bitcoin_outpoint_hash) WRAP_(outpoint_hash) WRAP_(output_amount) WRAP_(output_amounts_hash) WRAP_(output_asset) +WRAP_(bitcoin_output_hash) WRAP_(output_hash) WRAP_(output_is_fee) WRAP_(output_nonce) @@ -347,10 +386,15 @@ WRAP_(output_nonces_hash) WRAP_(output_null_datum) WRAP_(output_range_proof) WRAP_(output_range_proofs_hash) +WRAP_(bitcoin_output_script_hash) WRAP_(output_script_hash) +WRAP_(bitcoin_output_scripts_hash) WRAP_(output_scripts_hash) WRAP_(output_surjection_proof) WRAP_(output_surjection_proofs_hash) +WRAP_(bitcoin_output_value) +WRAP_(bitcoin_output_values_hash) +WRAP_(bitcoin_outputs_hash) WRAP_(outputs_hash) WRAP_(parse_lock) WRAP_(parse_sequence) @@ -422,6 +466,7 @@ WRAP_(scalar_negate) WRAP_(scalar_normalize) WRAP_(scalar_square) WRAP_(scale) +WRAP_(bitcoin_script_cmr) WRAP_(script_cmr) WRAP_(sha_256_block) WRAP_(sha_256_ctx_8_add_1) @@ -438,6 +483,7 @@ WRAP_(sha_256_ctx_8_add_buffer_511) WRAP_(sha_256_ctx_8_finalize) WRAP_(sha_256_ctx_8_init) WRAP_(sha_256_iv) +WRAP_(bitcoin_sig_all_hash) WRAP_(sig_all_hash) WRAP_(some_1) WRAP_(some_16) @@ -449,21 +495,36 @@ WRAP_(subtract_32) WRAP_(subtract_64) WRAP_(subtract_8) WRAP_(swu) +WRAP_(bitcoin_tap_env_hash) WRAP_(tap_env_hash) WRAP_(tapdata_init) +WRAP_(bitcoin_tapleaf_hash) WRAP_(tapleaf_hash) +WRAP_(bitcoin_tapleaf_version) WRAP_(tapleaf_version) +WRAP_(bitcoin_tappath) WRAP_(tappath) +WRAP_(bitcoin_tappath_hash) WRAP_(tappath_hash) WRAP_(total_fee) +WRAP_(bitcoin_total_input_value) +WRAP_(bitcoin_total_output_value) +WRAP_(bitcoin_transaction_id) WRAP_(transaction_id) +WRAP_(bitcoin_tx_hash) WRAP_(tx_hash) +WRAP_(bitcoin_tx_is_final) WRAP_(tx_is_final) +WRAP_(bitcoin_tx_lock_distance) WRAP_(tx_lock_distance) +WRAP_(bitcoin_tx_lock_duration) WRAP_(tx_lock_duration) +WRAP_(bitcoin_tx_lock_height) WRAP_(tx_lock_height) +WRAP_(bitcoin_tx_lock_time) WRAP_(tx_lock_time) WRAP_(verify) +WRAP_(bitcoin_version) WRAP_(version) WRAP_(xor_1) WRAP_(xor_16) diff --git a/simplicity-sys/depend/simplicity-HEAD-revision.txt b/simplicity-sys/depend/simplicity-HEAD-revision.txt index 2df19e5d..12547701 100644 --- a/simplicity-sys/depend/simplicity-HEAD-revision.txt +++ b/simplicity-sys/depend/simplicity-HEAD-revision.txt @@ -1,2 +1,2 @@ # This file has been automatically generated. -b7bd4171e74451c8e1b6948674285f0d4274e368 +fba36f60e2b71fda41175688dc5332e5fb60054a diff --git a/simplicity-sys/depend/simplicity/CMakeLists.txt b/simplicity-sys/depend/simplicity/CMakeLists.txt new file mode 100644 index 00000000..f1355bd0 --- /dev/null +++ b/simplicity-sys/depend/simplicity/CMakeLists.txt @@ -0,0 +1,36 @@ +cmake_minimum_required(VERSION 3.16) + +project(BitcoinSimplicity) + +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_EXTENSIONS OFF) + +add_library(BitcoinSimplicity STATIC + bitstream.c + dag.c + deserialize.c + eval.c + frame.c + jets-secp256k1.c + jets.c + rsort.c + sha256.c + type.c + typeInference.c + bitcoin/env.c + bitcoin/exec.c + bitcoin/bitcoinJets.c + bitcoin/ops.c + bitcoin/primitive.c + bitcoin/txEnv.c +) + +option(PRODUCTION "Enable production build" ON) +if (PRODUCTION) + target_compile_definitions(BitcoinSimplicity PRIVATE "PRODUCTION") +endif() + +target_include_directories(BitcoinSimplicity PUBLIC + $ + $ + ) diff --git a/simplicity-sys/depend/simplicity/Makefile b/simplicity-sys/depend/simplicity/Makefile index e9038369..e3d90ac5 100644 --- a/simplicity-sys/depend/simplicity/Makefile +++ b/simplicity-sys/depend/simplicity/Makefile @@ -1,4 +1,6 @@ -OBJS := bitstream.o dag.o deserialize.o eval.o frame.o jets.o jets-secp256k1.o rsort.o sha256.o type.o typeInference.o elements/env.o elements/exec.o elements/ops.o elements/elementsJets.o elements/primitive.o elements/cmr.o elements/txEnv.o +CORE_OBJS := bitstream.o cmr.o dag.o deserialize.o eval.o frame.o jets.o jets-secp256k1.o rsort.o sha256.o type.o typeInference.o +BITCOIN_OBJS := bitcoin/env.o bitcoin/exec.o bitcoin/ops.o bitcoin/bitcoinJets.o bitcoin/primitive.o bitcoin/cmr.o bitcoin/txEnv.o +ELEMENTS_OBJS := elements/env.o elements/exec.o elements/ops.o elements/elementsJets.o elements/primitive.o elements/cmr.o elements/txEnv.o TEST_OBJS := test.o ctx8Pruned.o ctx8Unpruned.o hashBlock.o regression4.o schnorr0.o schnorr6.o typeSkipTest.o elements/checkSigHashAllTx1.o # From https://fastcompression.blogspot.com/2019/01/compiler-warnings.html @@ -23,13 +25,16 @@ sha256.o: sha256.c %.o: %.c $(CC) -c $(CFLAGS) $(CWARN) $(CPPFLAGS) -o $@ $< -libElementsSimplicity.a: $(OBJS) +libBitcoinSimplicity.a: $(CORE_OBJS) $(BITCOIN_OBJS) + ar rcs $@ $^ + +libElementsSimplicity.a: $(CORE_OBJS) $(ELEMENTS_OBJS) ar rcs $@ $^ test: $(TEST_OBJS) libElementsSimplicity.a $(CC) $^ -o $@ $(LDFLAGS) -install: libElementsSimplicity.a +install: libBitcoinSimplicity.a libElementsSimplicity.a mkdir -p $(out)/lib cp $^ $(out)/lib/ cp -R include $(out)/include diff --git a/simplicity-sys/depend/simplicity/bitcoin/bitcoinJets.c b/simplicity-sys/depend/simplicity/bitcoin/bitcoinJets.c new file mode 100644 index 00000000..f9fffeab --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/bitcoinJets.c @@ -0,0 +1,592 @@ +#include "bitcoinJets.h" + +#include "ops.h" +#include "txEnv.h" +#include "../taptweak.h" +#include "../simplicity_assert.h" + +/* Read a 256-bit hash value from the 'src' frame, advancing the cursor 256 cells. + * + * Precondition: '*src' is a valid read frame for 256 more cells; + * NULL != h; + */ +static void readHash(sha256_midstate* h, frameItem *src) { + read32s(h->s, 8, src); +} + +/* Write a 256-bit hash value to the 'dst' frame, advancing the cursor 256 cells. + * + * Precondition: '*dst' is a valid write frame for 256 more cells; + * NULL != h; + */ +static void writeHash(frameItem* dst, const sha256_midstate* h) { + write32s(dst, h->s, 8); +} + +/* Write an outpoint value to the 'dst' frame, advancing the cursor 288 cells. + * + * Precondition: '*dst' is a valid write frame for 288 more cells; + * NULL != op; + */ +static void prevOutpoint(frameItem* dst, const outpoint* op) { + writeHash(dst, &op->txid); + rustsimplicity_0_6_write32(dst, op->ix); +} + +static uint_fast32_t lockHeight(const bitcoinTransaction* tx) { + return !tx->isFinal && tx->lockTime < 500000000U ? tx->lockTime : 0; +} + +static uint_fast32_t lockTime(const bitcoinTransaction* tx) { + return !tx->isFinal && 500000000U <= tx->lockTime ? tx->lockTime : 0; +} + +static uint_fast16_t lockDistance(const bitcoinTransaction* tx) { + return 2 <= tx->version ? tx->lockDistance : 0; +} + +static uint_fast16_t lockDuration(const bitcoinTransaction* tx) { + return 2 <= tx->version ? tx->lockDuration : 0; +} + +/* version : ONE |- TWO^32 */ +bool rustsimplicity_0_6_bitcoin_version(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write32(dst, env->tx->version); + return true; +} + +/* lock_time : ONE |- TWO^32 */ +bool rustsimplicity_0_6_bitcoin_lock_time(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write32(dst, env->tx->lockTime); + return true; +} + +/* input_prev_outpoint : TWO^32 |- S (TWO^256 * TWO^32) */ +bool rustsimplicity_0_6_bitcoin_input_prev_outpoint(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numInputs)) { + prevOutpoint(dst, &env->tx->input[i].prevOutpoint); + } else { + skipBits(dst, 288); + } + return true; +} + +/* input_value : TWO^32 |- S TWO^64 */ +bool rustsimplicity_0_6_bitcoin_input_value(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numInputs)) { + rustsimplicity_0_6_write64(dst, env->tx->input[i].txo.value); + } else { + skipBits(dst, 64); + } + return true; +} + +/* input_script_hash : TWO^32 |- S TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_script_hash(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numInputs)) { + writeHash(dst, &env->tx->input[i].txo.scriptPubKey); + } else { + skipBits(dst, 256); + } + return true; +} + +/* input_sequence : TWO^32 |- S TWO^32 */ +bool rustsimplicity_0_6_bitcoin_input_sequence(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numInputs)) { + rustsimplicity_0_6_write32(dst, env->tx->input[i].sequence); + } else { + skipBits(dst, 32); + } + return true; +} + +/* input_annex_hash : TWO^32 |- S (S (TWO^256)) */ +bool rustsimplicity_0_6_bitcoin_input_annex_hash(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numInputs)) { + if (writeBit(dst, env->tx->input[i].hasAnnex)) { + writeHash(dst, &env->tx->input[i].annexHash); + } else { + skipBits(dst, 256); + } + } else { + skipBits(dst, 257); + } + return true; +} + +/* input_script_sig_hash : TWO^32 |- (S (TWO^256) */ +bool rustsimplicity_0_6_bitcoin_input_script_sig_hash(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numInputs)) { + writeHash(dst, &env->tx->input[i].scriptSigHash); + } else { + skipBits(dst, 256); + } + return true; +} + +/* output_value : TWO^32 |- S (TWO^64) */ +bool rustsimplicity_0_6_bitcoin_output_value(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numOutputs)) { + rustsimplicity_0_6_write64(dst, env->tx->output[i].value); + } else { + skipBits(dst, 64); + } + return true; +} + +/* output_script_hash : TWO^32 |- S TWO^256 */ +bool rustsimplicity_0_6_bitcoin_output_script_hash(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numOutputs)) { + writeHash(dst, &env->tx->output[i].scriptPubKey); + } else { + skipBits(dst, 256); + } + return true; +} + +/* fee : ONE |- TWO^64 */ +bool rustsimplicity_0_6_bitcoin_fee(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write64(dst, env->tx->totalInputValue - env->tx->totalOutputValue); + return true; +} + +/* total_input_value : ONE |- TWO^64 */ +bool rustsimplicity_0_6_bitcoin_total_input_value(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write64(dst, env->tx->totalInputValue); + return true; +} + +/* total_output_value : ONE |- TWO^64 */ +bool rustsimplicity_0_6_bitcoin_total_output_value(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write64(dst, env->tx->totalOutputValue); + return true; +} + +/* script_cmr : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_script_cmr(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + write32s(dst, env->taproot->scriptCMR.s, 8); + return true; +} + +/* transaction_id : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_transaction_id(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + write32s(dst, env->tx->txid.s, 8); + return true; +} + +/* current_index : ONE |- TWO^32 */ +bool rustsimplicity_0_6_bitcoin_current_index(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write32(dst, env->ix); + return true; +} + +/* current_prev_outpoint : ONE |- TWO^256 * TWO^32 */ +bool rustsimplicity_0_6_bitcoin_current_prev_outpoint(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + if (env->tx->numInputs <= env->ix) return false; + prevOutpoint(dst, &env->tx->input[env->ix].prevOutpoint); + return true; +} + +/* current_value : ONE |- (TWO^64) */ +bool rustsimplicity_0_6_bitcoin_current_value(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + if (env->tx->numInputs <= env->ix) return false; + rustsimplicity_0_6_write64(dst, env->tx->input[env->ix].txo.value); + return true; +} + +/* current_script_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_current_script_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + if (env->tx->numInputs <= env->ix) return false; + writeHash(dst, &env->tx->input[env->ix].txo.scriptPubKey); + return true; +} + +/* current_sequence : ONE |- TWO^32 */ +bool rustsimplicity_0_6_bitcoin_current_sequence(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + if (env->tx->numInputs <= env->ix) return false; + rustsimplicity_0_6_write32(dst, env->tx->input[env->ix].sequence); + return true; +} + +/* current_script_sig_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_current_script_sig_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + if (env->tx->numInputs <= env->ix) return false; + writeHash(dst, &env->tx->input[env->ix].scriptSigHash); + return true; +} + +/* current_annex_hash : ONE |- S (TWO^256) */ +bool rustsimplicity_0_6_bitcoin_current_annex_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + if (env->tx->numInputs <= env->ix) return false; + if (writeBit(dst, env->tx->input[env->ix].hasAnnex)) { + writeHash(dst, &env->tx->input[env->ix].annexHash); + } else { + skipBits(dst, 256); + } + return true; +} + +/* tapleaf_version : ONE |- TWO^8 */ +bool rustsimplicity_0_6_bitcoin_tapleaf_version(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write8(dst, env->taproot->leafVersion); + return true; +} + +/* tappath : TWO^8 |- S (TWO^256) */ +bool rustsimplicity_0_6_bitcoin_tappath(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast8_t i = rustsimplicity_0_6_read8(&src); + if (writeBit(dst, i < env->taproot->pathLen)) { + writeHash(dst, &env->taproot->path[i]); + } else { + skipBits(dst, 256); + } + return true; +} + +/* internal_key : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_internal_key(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->taproot->internalKey); + return true; +} + +/* num_inputs : ONE |- TWO^32 */ +bool rustsimplicity_0_6_bitcoin_num_inputs(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write32(dst, env->tx->numInputs); + return true; +} + +/* num_outputs : ONE |- TWO^32 */ +bool rustsimplicity_0_6_bitcoin_num_outputs(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write32(dst, env->tx->numOutputs); + return true; +} + +/* tx_is_final : ONE |- TWO */ +bool rustsimplicity_0_6_bitcoin_tx_is_final(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeBit(dst, env->tx->isFinal); + return true; +} + +/* tx_lock_height : ONE |- TWO^32 */ +bool rustsimplicity_0_6_bitcoin_tx_lock_height(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write32(dst, lockHeight(env->tx)); + return true; +} + +/* tx_lock_time : ONE |- TWO^32 */ +bool rustsimplicity_0_6_bitcoin_tx_lock_time(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write32(dst, lockTime(env->tx)); + return true; +} + +/* tx_lock_distance : ONE |- TWO^16 */ +bool rustsimplicity_0_6_bitcoin_tx_lock_distance(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write16(dst, lockDistance(env->tx)); + return true; +} + +/* tx_lock_duration : ONE |- TWO^16 */ +bool rustsimplicity_0_6_bitcoin_tx_lock_duration(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + rustsimplicity_0_6_write16(dst, lockDuration(env->tx)); + return true; +} + +/* check_lock_height : TWO^32 |- ONE */ +bool rustsimplicity_0_6_bitcoin_check_lock_height(frameItem* dst, frameItem src, const txEnv* env) { + (void) dst; // dst is unused; + uint_fast32_t x = rustsimplicity_0_6_read32(&src); + return x <= lockHeight(env->tx); +} + +/* check_lock_time : TWO^32 |- ONE */ +bool rustsimplicity_0_6_bitcoin_check_lock_time(frameItem* dst, frameItem src, const txEnv* env) { + (void) dst; // dst is unused; + uint_fast32_t x = rustsimplicity_0_6_read32(&src); + return x <= lockTime(env->tx); +} + +/* check_lock_distance : TWO^16 |- ONE */ +bool rustsimplicity_0_6_bitcoin_check_lock_distance(frameItem* dst, frameItem src, const txEnv* env) { + (void) dst; // dst is unused; + uint_fast16_t x = rustsimplicity_0_6_read16(&src); + return x <= lockDistance(env->tx); +} + +/* check_lock_duration : TWO^16 |- ONE */ +bool rustsimplicity_0_6_bitcoin_check_lock_duration(frameItem* dst, frameItem src, const txEnv* env) { + (void) dst; // dst is unused; + uint_fast16_t x = rustsimplicity_0_6_read16(&src); + return x <= lockDuration(env->tx); +} + +/* build_tapleaf_simplicity : TWO^256 |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_build_tapleaf_simplicity(frameItem* dst, frameItem src, const txEnv* env) { + (void) env; // env is unused. + sha256_midstate cmr; + readHash(&cmr, &src); + sha256_midstate result = rustsimplicity_0_6_bitcoin_make_tapleaf(0xbe, &cmr); + writeHash(dst, &result); + return true; +} + +/* build_tapbranch : TWO^256 * TWO^256 |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_build_tapbranch(frameItem* dst, frameItem src, const txEnv* env) { + (void) env; // env is unused. + sha256_midstate a, b; + readHash(&a, &src); + readHash(&b, &src); + + sha256_midstate result = rustsimplicity_0_6_bitcoin_make_tapbranch(&a, &b); + writeHash(dst, &result); + return true; +} + +/* build_taptweak : PUBKEY * TWO^256 |- PUBKEY */ +bool rustsimplicity_0_6_bitcoin_build_taptweak(frameItem* dst, frameItem src, const txEnv* env) { + (void) env; // env is unused. + static unsigned char taptweak[] = "TapTweak"; + return rustsimplicity_0_6_generic_taptweak(dst, &src, taptweak, sizeof(taptweak)-1); +} + +/* outpoint_hash : CTX8 * TWO^256 * TWO^32 |- CTX8 */ +bool rustsimplicity_0_6_bitcoin_outpoint_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) env; // env is unused. + sha256_midstate midstate; + unsigned char buf[36]; + sha256_context ctx = {.output = midstate.s}; + + /* Read a SHA-256 context. */ + if (!rustsimplicity_0_6_read_sha256_context(&ctx, &src)) return false; + + /* Read an outpoint (hash and index). */ + read8s(buf, 36, &src); + sha256_uchars(&ctx, buf, 36); + + return rustsimplicity_0_6_write_sha256_context(dst, &ctx); +} + +/* annex_hash : CTX8 * S TWO^256 |- CTX8 */ +bool rustsimplicity_0_6_bitcoin_annex_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) env; // env is unused. + sha256_midstate midstate; + unsigned char buf[32]; + sha256_context ctx = {.output = midstate.s}; + + /* Read a SHA-256 context. */ + if (!rustsimplicity_0_6_read_sha256_context(&ctx, &src)) return false; + + /* Read an optional hash. (257 bits) */ + if (readBit(&src)) { + /* Read a hash. (256 bits) */ + read8s(buf, 32, &src); + sha256_uchar(&ctx, 0x01); + sha256_uchars(&ctx, buf, 32); + } else { + /* No hash. */ + sha256_uchar(&ctx, 0x00); + } + + return rustsimplicity_0_6_write_sha256_context(dst, &ctx); +} + +/* output_amounts_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_output_values_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->outputValuesHash); + return true; +} + +/* output_scripts_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_output_scripts_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->outputScriptsHash); + return true; +} + +/* outputs_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_outputs_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->outputsHash); + return true; +} + +/* output_hash : TWO^32 |- S TWO^256 */ +bool rustsimplicity_0_6_bitcoin_output_hash(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numOutputs)) { + const sigOutput* output = &env->tx->output[i]; + sha256_midstate midstate; + sha256_context ctx = sha256_init(midstate.s); + sha256_u64be(&ctx, output->value); + sha256_hash(&ctx, &output->scriptPubKey); + sha256_finalize(&ctx); + writeHash(dst, &midstate); + } else { + skipBits(dst, 256); + } + return true; +} + +/* input_outpoints_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_outpoints_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->inputOutpointsHash); + return true; +} + +/* input_values_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_values_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->inputValuesHash); + return true; +} + +/* input_scripts_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_scripts_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->inputScriptsHash); + return true; +} + +/* input_utxos_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_utxos_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->inputUTXOsHash); + return true; +} + +/* input_utxo_hash : TWO^32 |- S TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_utxo_hash(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numInputs)) { + const sigOutput* txo = &env->tx->input[i].txo; + sha256_midstate midstate; + sha256_context ctx = sha256_init(midstate.s); + sha256_u64be(&ctx, txo->value); + sha256_hash(&ctx, &txo->scriptPubKey); + sha256_finalize(&ctx); + writeHash(dst, &midstate); + } else { + skipBits(dst, 256); + } + return true; +} + +/* input_sequences_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_sequences_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->inputSequencesHash); + return true; +} + +/* input_annexes_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_annexes_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->inputAnnexesHash); + return true; +} + +/* input_script_sigs_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_script_sigs_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->inputScriptSigsHash); + return true; +} + +/* inputs_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_inputs_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->inputsHash); + return true; +} + +/* input_hash : TWO^32 |- S TWO^256 */ +bool rustsimplicity_0_6_bitcoin_input_hash(frameItem* dst, frameItem src, const txEnv* env) { + uint_fast32_t i = rustsimplicity_0_6_read32(&src); + if (writeBit(dst, i < env->tx->numInputs)) { + const sigInput* input = &env->tx->input[i]; + sha256_midstate midstate; + sha256_context ctx = sha256_init(midstate.s); + sha256_hash(&ctx, &input->prevOutpoint.txid); + sha256_u32be(&ctx, input->prevOutpoint.ix); + sha256_u32be(&ctx, input->sequence); + if (input->hasAnnex) { + sha256_uchar(&ctx, 1); + sha256_hash(&ctx, &input->annexHash); + } else { + sha256_uchar(&ctx, 0); + } + sha256_finalize(&ctx); + writeHash(dst, &midstate); + } else { + skipBits(dst, 256); + } + return true; +} + +/* tx_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_tx_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->tx->txHash); + return true; +} + +/* tapleaf_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_tapleaf_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->taproot->tapLeafHash); + return true; +} + +/* tappath_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_tappath_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->taproot->tappathHash); + return true; +} + +/* tap_env_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_tap_env_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->taproot->tapEnvHash); + return true; +} + +/* sig_all_hash : ONE |- TWO^256 */ +bool rustsimplicity_0_6_bitcoin_sig_all_hash(frameItem* dst, frameItem src, const txEnv* env) { + (void) src; // src is unused; + writeHash(dst, &env->sigAllHash); + return true; +} diff --git a/simplicity-sys/depend/simplicity/bitcoin/bitcoinJets.h b/simplicity-sys/depend/simplicity/bitcoin/bitcoinJets.h new file mode 100644 index 00000000..097541ef --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/bitcoinJets.h @@ -0,0 +1,70 @@ +/* This module defines primitives and jets that are specific to the Bitcoin application for Simplicity. + */ +#ifndef SIMPLICITY_BITCOIN_BITCOINJETS_H +#define SIMPLICITY_BITCOIN_BITCOINJETS_H + +#include "../jets.h" + +/* Jets for the Bitcoin application of Simplicity. */ +bool rustsimplicity_0_6_bitcoin_version(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_lock_time(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_prev_outpoint(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_value(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_script_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_sequence(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_annex_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_script_sig_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_output_value(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_output_script_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_fee(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_total_input_value(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_total_output_value(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_script_cmr(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_transaction_id(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_current_index(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_current_prev_outpoint(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_current_value(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_current_script_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_current_sequence(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_current_annex_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_current_script_sig_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tapleaf_version(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tappath(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_internal_key(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_num_inputs(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_num_outputs(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tx_is_final(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tx_lock_height(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tx_lock_time(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tx_lock_distance(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tx_lock_duration(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_check_lock_height(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_check_lock_time(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_check_lock_distance(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_check_lock_duration(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_build_tapleaf_simplicity(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_build_tapbranch(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_build_taptweak(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_outpoint_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_annex_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_output_values_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_output_scripts_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_outputs_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_output_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_outpoints_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_values_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_scripts_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_utxos_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_utxo_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_sequences_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_annexes_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_script_sigs_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_inputs_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_input_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tx_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tapleaf_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tappath_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_tap_env_hash(frameItem* dst, frameItem src, const txEnv* env); +bool rustsimplicity_0_6_bitcoin_sig_all_hash(frameItem* dst, frameItem src, const txEnv* env); + +#endif diff --git a/simplicity-sys/depend/simplicity/bitcoin/cmr.c b/simplicity-sys/depend/simplicity/bitcoin/cmr.c new file mode 100644 index 00000000..d589fe91 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/cmr.c @@ -0,0 +1,22 @@ +#include + +#include "../cmr.h" +#include "primitive.h" + +/* Deserialize a Simplicity 'program' and compute its CMR. + * + * Caution: no typechecking is performed, only a well-formedness check. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If the operation completes successfully then '*error' is set to 'SIMPLICITY_NO_ERROR', and the 'cmr' array is filled in with the program's computed CMR. + * + * Precondition: NULL != error; + * unsigned char cmr[32] + * unsigned char program[program_len] + */ +bool rustsimplicity_0_6_bitcoin_computeCmr( simplicity_err* error, unsigned char* cmr + , const unsigned char* program, size_t program_len) { + return rustsimplicity_0_6_computeCmr(error, cmr, rustsimplicity_0_6_bitcoin_decodeJet, program, program_len); +} diff --git a/simplicity-sys/depend/simplicity/bitcoin/decodeBitcoinJets.inc b/simplicity-sys/depend/simplicity/bitcoin/decodeBitcoinJets.inc new file mode 100644 index 00000000..2dab5e20 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/decodeBitcoinJets.inc @@ -0,0 +1,87 @@ +/* This file has been automatically generated. */ + +{ + int32_t code; + code = rustsimplicity_0_6_decodeUptoMaxInt(stream); + if (code < 0) return (simplicity_err)code; + switch (code) { + case 1: + code = rustsimplicity_0_6_decodeUptoMaxInt(stream); + if (code < 0) return (simplicity_err)code; + switch (code) { + case 1: *result = SIG_ALL_HASH; return SIMPLICITY_NO_ERROR; + case 2: *result = TX_HASH; return SIMPLICITY_NO_ERROR; + case 3: *result = TAP_ENV_HASH; return SIMPLICITY_NO_ERROR; + case 4: *result = OUTPUTS_HASH; return SIMPLICITY_NO_ERROR; + case 5: *result = INPUTS_HASH; return SIMPLICITY_NO_ERROR; + case 6: *result = INPUT_UTXOS_HASH; return SIMPLICITY_NO_ERROR; + case 7: *result = OUTPUT_HASH; return SIMPLICITY_NO_ERROR; + case 8: *result = OUTPUT_VALUES_HASH; return SIMPLICITY_NO_ERROR; + case 9: *result = OUTPUT_SCRIPTS_HASH; return SIMPLICITY_NO_ERROR; + case 10: *result = INPUT_HASH; return SIMPLICITY_NO_ERROR; + case 11: *result = INPUT_OUTPOINTS_HASH; return SIMPLICITY_NO_ERROR; + case 12: *result = INPUT_SEQUENCES_HASH; return SIMPLICITY_NO_ERROR; + case 13: *result = INPUT_ANNEXES_HASH; return SIMPLICITY_NO_ERROR; + case 14: *result = INPUT_SCRIPT_SIGS_HASH; return SIMPLICITY_NO_ERROR; + case 15: *result = INPUT_UTXO_HASH; return SIMPLICITY_NO_ERROR; + case 16: *result = INPUT_VALUES_HASH; return SIMPLICITY_NO_ERROR; + case 17: *result = INPUT_SCRIPTS_HASH; return SIMPLICITY_NO_ERROR; + case 18: *result = TAPLEAF_HASH; return SIMPLICITY_NO_ERROR; + case 19: *result = TAPPATH_HASH; return SIMPLICITY_NO_ERROR; + case 20: *result = OUTPOINT_HASH; return SIMPLICITY_NO_ERROR; + case 21: *result = ANNEX_HASH; return SIMPLICITY_NO_ERROR; + case 22: *result = BUILD_TAPLEAF_SIMPLICITY; return SIMPLICITY_NO_ERROR; + case 23: *result = BUILD_TAPBRANCH; return SIMPLICITY_NO_ERROR; + case 24: *result = BUILD_TAPTWEAK; return SIMPLICITY_NO_ERROR; + } + break; + case 2: + code = rustsimplicity_0_6_decodeUptoMaxInt(stream); + if (code < 0) return (simplicity_err)code; + switch (code) { + case 1: *result = CHECK_LOCK_HEIGHT; return SIMPLICITY_NO_ERROR; + case 2: *result = CHECK_LOCK_TIME; return SIMPLICITY_NO_ERROR; + case 3: *result = CHECK_LOCK_DISTANCE; return SIMPLICITY_NO_ERROR; + case 4: *result = CHECK_LOCK_DURATION; return SIMPLICITY_NO_ERROR; + case 5: *result = TX_LOCK_HEIGHT; return SIMPLICITY_NO_ERROR; + case 6: *result = TX_LOCK_TIME; return SIMPLICITY_NO_ERROR; + case 7: *result = TX_LOCK_DISTANCE; return SIMPLICITY_NO_ERROR; + case 8: *result = TX_LOCK_DURATION; return SIMPLICITY_NO_ERROR; + case 9: *result = TX_IS_FINAL; return SIMPLICITY_NO_ERROR; + } + break; + case 3: + code = rustsimplicity_0_6_decodeUptoMaxInt(stream); + if (code < 0) return (simplicity_err)code; + switch (code) { + case 1: *result = SCRIPT_CMR; return SIMPLICITY_NO_ERROR; + case 2: *result = INTERNAL_KEY; return SIMPLICITY_NO_ERROR; + case 3: *result = CURRENT_INDEX; return SIMPLICITY_NO_ERROR; + case 4: *result = NUM_INPUTS; return SIMPLICITY_NO_ERROR; + case 5: *result = NUM_OUTPUTS; return SIMPLICITY_NO_ERROR; + case 6: *result = LOCK_TIME; return SIMPLICITY_NO_ERROR; + case 7: *result = FEE; return SIMPLICITY_NO_ERROR; + case 8: *result = OUTPUT_VALUE; return SIMPLICITY_NO_ERROR; + case 9: *result = OUTPUT_SCRIPT_HASH; return SIMPLICITY_NO_ERROR; + case 10: *result = TOTAL_OUTPUT_VALUE; return SIMPLICITY_NO_ERROR; + case 11: *result = CURRENT_PREV_OUTPOINT; return SIMPLICITY_NO_ERROR; + case 12: *result = CURRENT_VALUE; return SIMPLICITY_NO_ERROR; + case 13: *result = CURRENT_SCRIPT_HASH; return SIMPLICITY_NO_ERROR; + case 14: *result = CURRENT_SEQUENCE; return SIMPLICITY_NO_ERROR; + case 15: *result = CURRENT_ANNEX_HASH; return SIMPLICITY_NO_ERROR; + case 16: *result = CURRENT_SCRIPT_SIG_HASH; return SIMPLICITY_NO_ERROR; + case 17: *result = INPUT_PREV_OUTPOINT; return SIMPLICITY_NO_ERROR; + case 18: *result = INPUT_VALUE; return SIMPLICITY_NO_ERROR; + case 19: *result = INPUT_SCRIPT_HASH; return SIMPLICITY_NO_ERROR; + case 20: *result = INPUT_SEQUENCE; return SIMPLICITY_NO_ERROR; + case 21: *result = INPUT_ANNEX_HASH; return SIMPLICITY_NO_ERROR; + case 22: *result = INPUT_SCRIPT_SIG_HASH; return SIMPLICITY_NO_ERROR; + case 23: *result = TOTAL_INPUT_VALUE; return SIMPLICITY_NO_ERROR; + case 24: *result = TAPLEAF_VERSION; return SIMPLICITY_NO_ERROR; + case 25: *result = TAPPATH; return SIMPLICITY_NO_ERROR; + case 26: *result = VERSION; return SIMPLICITY_NO_ERROR; + case 27: *result = TRANSACTION_ID; return SIMPLICITY_NO_ERROR; + } + break; + } +} \ No newline at end of file diff --git a/simplicity-sys/depend/simplicity/bitcoin/env.c b/simplicity-sys/depend/simplicity/bitcoin/env.c new file mode 100644 index 00000000..c80c1656 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/env.c @@ -0,0 +1,268 @@ +#include + +#include +#include +#include +#include "txEnv.h" +#include "ops.h" +#include "../sha256.h" +#include "../simplicity_assert.h" +#include "../simplicity_alloc.h" + +#define PADDING(alignType, allocated) ((alignof(alignType) - (allocated) % alignof(alignType)) % alignof(alignType)) + +/* Compute the SHA-256 hash of a scriptPubKey and write it into 'result'. + * + * Precondition: NULL != result; + * NULL != scriptPubKey; + */ +static void hashBuffer(sha256_midstate* result, const rawBitcoinBuffer* buffer) { + sha256_context ctx = sha256_init(result->s); + sha256_uchars(&ctx, buffer->buf, buffer->len); + sha256_finalize(&ctx); +} + +/* Initialize a 'sigOutput' from a 'rawOutput', copying or hashing the data as needed. + * + * Precondition: NULL != result; + * NULL != output; + */ +static void copyOutput(sigOutput* result, const rawBitcoinOutput* output) { + hashBuffer(&result->scriptPubKey, &output->scriptPubKey); + result->value = output->value; +} + +/* Initialize a 'sigInput' from a 'rawBitcoinInput', copying or hashing the data as needed. + * + * Precondition: NULL != result; + * NULL != input; + */ +static void copyInput(sigInput* result, const rawBitcoinInput* input) { + *result = (sigInput){ .prevOutpoint = { .ix = input->prevIx } + , .sequence = input->sequence + , .hasAnnex = !!input->annex + }; + + if (input->annex) hashBuffer(&result->annexHash, input->annex); + sha256_toMidstate(result->prevOutpoint.txid.s, input->prevTxid); + copyOutput(&result->txo, &input->txo); + hashBuffer(&result->scriptSigHash, &input->scriptSig); +} + +/* Allocate and initialize a 'bitcoinTransaction' from a 'rawBitcoinTransaction', copying or hashing the data as needed. + * Returns NULL if malloc fails (or if malloc cannot be called because we require an allocation larger than SIZE_MAX). + * + * Precondition: NULL != rawTx + */ +extern bitcoinTransaction* rustsimplicity_0_6_bitcoin_mallocTransaction(const rawBitcoinTransaction* rawTx) { + if (!rawTx) return NULL; + + size_t allocationSize = sizeof(bitcoinTransaction); + + const size_t pad1 = PADDING(sigInput, allocationSize); + if (SIZE_MAX - allocationSize < pad1) return NULL; + allocationSize += pad1; + + /* Multiply by (size_t)1 to disable type-limits warning. */ + if (SIZE_MAX / sizeof(sigInput) < (size_t)1 * rawTx->numInputs) return NULL; + if (SIZE_MAX - allocationSize < rawTx->numInputs * sizeof(sigInput)) return NULL; + allocationSize += rawTx->numInputs * sizeof(sigInput); + + const size_t pad2 = PADDING(sigOutput, allocationSize); + if (SIZE_MAX - allocationSize < pad2) return NULL; + allocationSize += pad2; + + /* Multiply by (size_t)1 to disable type-limits warning. */ + if (SIZE_MAX / sizeof(sigOutput) < (size_t)1 * rawTx->numOutputs) return NULL; + if (SIZE_MAX - allocationSize < rawTx->numOutputs * sizeof(sigOutput)) return NULL; + allocationSize += rawTx->numOutputs * sizeof(sigOutput); + + char *allocation = rustsimplicity_0_6_malloc(allocationSize); + if (!allocation) return NULL; + + /* Casting through void* to avoid warning about pointer alignment. + * Our padding is done carefully to ensure alignment. + */ + bitcoinTransaction* const tx = (bitcoinTransaction*)(void*)allocation; + allocation += sizeof(bitcoinTransaction) + pad1; + + sigInput* const input = (sigInput*)(void*)allocation; + allocation += rawTx->numInputs * sizeof(sigInput) + pad2; + + sigOutput* const output = (sigOutput*)(void*)allocation; + + *tx = (bitcoinTransaction){ .input = input + , .output = output + , .numInputs = rawTx->numInputs + , .numOutputs = rawTx->numOutputs + , .version = rawTx->version + , .lockTime = rawTx->lockTime + , .isFinal = true + }; + + sha256_toMidstate(tx->txid.s, rawTx->txid); + { + sha256_context ctx_inputOutpointsHash = sha256_init(tx->inputOutpointsHash.s); + sha256_context ctx_inputValuesHash = sha256_init(tx->inputValuesHash.s); + sha256_context ctx_inputScriptsHash = sha256_init(tx->inputScriptsHash.s); + sha256_context ctx_inputUTXOsHash = sha256_init(tx->inputUTXOsHash.s); + sha256_context ctx_inputSequencesHash = sha256_init(tx->inputSequencesHash.s); + sha256_context ctx_inputAnnexesHash = sha256_init(tx->inputAnnexesHash.s); + sha256_context ctx_inputScriptSigsHash = sha256_init(tx->inputScriptSigsHash.s); + sha256_context ctx_inputsHash = sha256_init(tx->inputsHash.s); + for (uint_fast32_t i = 0; i < tx->numInputs; ++i) { + copyInput(&input[i], &rawTx->input[i]); + tx->totalInputValue += input[i].txo.value; + if (input[i].sequence < 0xffffffff) { tx->isFinal = false; } + if (input[i].sequence < 0x80000000) { + const uint_fast16_t maskedSequence = input[i].sequence & 0xffff; + if (input[i].sequence & ((uint_fast32_t)1 << 22)) { + if (tx->lockDuration < maskedSequence) tx->lockDuration = maskedSequence; + } else { + if (tx->lockDistance < maskedSequence) tx->lockDistance = maskedSequence; + } + } + sha256_hash(&ctx_inputOutpointsHash, &input[i].prevOutpoint.txid); + sha256_u32be(&ctx_inputOutpointsHash, input[i].prevOutpoint.ix); + sha256_u64be(&ctx_inputValuesHash, input[i].txo.value); + sha256_hash(&ctx_inputScriptsHash, &input[i].txo.scriptPubKey); + sha256_u32be(&ctx_inputSequencesHash, input[i].sequence); + if (input[i].hasAnnex) { + sha256_uchar(&ctx_inputAnnexesHash, 1); + sha256_hash(&ctx_inputAnnexesHash, &input[i].annexHash); + } else { + sha256_uchar(&ctx_inputAnnexesHash, 0); + } + sha256_hash(&ctx_inputScriptSigsHash, &input[i].scriptSigHash); + } + sha256_finalize(&ctx_inputOutpointsHash); + sha256_finalize(&ctx_inputValuesHash); + sha256_finalize(&ctx_inputScriptsHash); + sha256_finalize(&ctx_inputSequencesHash); + sha256_finalize(&ctx_inputAnnexesHash); + sha256_finalize(&ctx_inputScriptSigsHash); + + sha256_hash(&ctx_inputUTXOsHash, &tx->inputValuesHash); + sha256_hash(&ctx_inputUTXOsHash, &tx->inputScriptsHash); + sha256_finalize(&ctx_inputUTXOsHash); + + sha256_hash(&ctx_inputsHash, &tx->inputOutpointsHash); + sha256_hash(&ctx_inputsHash, &tx->inputSequencesHash); + sha256_hash(&ctx_inputsHash, &tx->inputAnnexesHash); + sha256_finalize(&ctx_inputsHash); + } + + { + sha256_context ctx_outputValuesHash = sha256_init(tx->outputValuesHash.s); + sha256_context ctx_outputScriptsHash = sha256_init(tx->outputScriptsHash.s); + sha256_context ctx_outputsHash = sha256_init(tx->outputsHash.s); + + for (uint_fast32_t i = 0; i < tx->numOutputs; ++i) { + copyOutput(&output[i], &rawTx->output[i]); + tx->totalOutputValue += output[i].value; + sha256_u64be(&ctx_outputValuesHash, output[i].value); + sha256_hash(&ctx_outputScriptsHash, &output[i].scriptPubKey); + } + + sha256_finalize(&ctx_outputValuesHash); + sha256_finalize(&ctx_outputScriptsHash); + + sha256_hash(&ctx_outputsHash, &tx->outputValuesHash); + sha256_hash(&ctx_outputsHash, &tx->outputScriptsHash); + sha256_finalize(&ctx_outputsHash); + } + { + sha256_context ctx_txHash = sha256_init(tx->txHash.s); + sha256_u32be(&ctx_txHash, tx->version); + sha256_u32be(&ctx_txHash, tx->lockTime); + sha256_hash(&ctx_txHash, &tx->inputsHash); + sha256_hash(&ctx_txHash, &tx->outputsHash); + sha256_hash(&ctx_txHash, &tx->inputUTXOsHash); + sha256_finalize(&ctx_txHash); + } + + return tx; +} + +/* Free a pointer to 'bitcoinTransaction'. + */ +extern void rustsimplicity_0_6_bitcoin_freeTransaction(bitcoinTransaction* tx) { + rustsimplicity_0_6_free(tx); +} + +/* Allocate and initialize a 'bitcoinTapEnv' from a 'rawBitcoinTapEnv', copying or hashing the data as needed. + * Returns NULL if malloc fails (or if malloc cannot be called because we require an allocation larger than SIZE_MAX). + * + * Precondition: *rawEnv is well-formed (i.e. rawEnv->pathLen <= 128.) + */ +extern bitcoinTapEnv* rustsimplicity_0_6_bitcoin_mallocTapEnv(const rawBitcoinTapEnv* rawEnv) { + if (!rawEnv) return NULL; + if (128 < rawEnv->pathLen) return NULL; + + size_t allocationSize = sizeof(bitcoinTapEnv); + + const size_t numMidstate = rawEnv->pathLen; + const size_t pad1 = PADDING(sha256_midstate, allocationSize); + + if (numMidstate) { + if (SIZE_MAX - allocationSize < pad1) return NULL; + allocationSize += pad1; + + if (SIZE_MAX / sizeof(sha256_midstate) < numMidstate) return NULL; + if (SIZE_MAX - allocationSize < numMidstate * sizeof(sha256_midstate)) return NULL; + allocationSize += numMidstate * sizeof(sha256_midstate); + } + + char *allocation = rustsimplicity_0_6_malloc(allocationSize); + if (!allocation) return NULL; + + /* Casting through void* to avoid warning about pointer alignment. + * Our padding is done carefully to ensure alignment. + */ + bitcoinTapEnv* const env = (bitcoinTapEnv*)(void*)allocation; + sha256_midstate* path = NULL; + sha256_midstate internalKey; + + sha256_toMidstate(internalKey.s, &rawEnv->controlBlock[1]); + + if (numMidstate) { + allocation += sizeof(bitcoinTapEnv) + pad1; + + if (rawEnv->pathLen) { + path = (sha256_midstate*)(void*)allocation; + } + } + + *env = (bitcoinTapEnv){ .leafVersion = rawEnv->controlBlock[0] & 0xfe + , .internalKey = internalKey + , .path = path + , .pathLen = rawEnv->pathLen + }; + sha256_toMidstate(env->scriptCMR.s, rawEnv->scriptCMR); + + { + sha256_context ctx = sha256_init(env->tappathHash.s); + for (int i = 0; i < env->pathLen; ++i) { + sha256_toMidstate(path[i].s, &rawEnv->controlBlock[33+32*i]); + sha256_hash(&ctx, &path[i]); + } + sha256_finalize(&ctx); + } + + env->tapLeafHash = rustsimplicity_0_6_bitcoin_make_tapleaf(env->leafVersion, &env->scriptCMR); + + { + sha256_context ctx = sha256_init(env->tapEnvHash.s); + sha256_hash(&ctx, &env->tapLeafHash); + sha256_hash(&ctx, &env->tappathHash); + sha256_hash(&ctx, &env->internalKey); + sha256_finalize(&ctx); + } + return env; +} + +/* Free a pointer to 'bitcoinTapEnv'. + */ +extern void rustsimplicity_0_6_bitcoin_freeTapEnv(bitcoinTapEnv* env) { + rustsimplicity_0_6_free(env); +} diff --git a/simplicity-sys/depend/simplicity/bitcoin/exec.c b/simplicity-sys/depend/simplicity/bitcoin/exec.c new file mode 100644 index 00000000..c079edb3 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/exec.c @@ -0,0 +1,136 @@ +#include + +#include +#include +#include "primitive.h" +#include "txEnv.h" +#include "../deserialize.h" +#include "../eval.h" +#include "../limitations.h" +#include "../simplicity_alloc.h" +#include "../simplicity_assert.h" +#include "../typeInference.h" + +/* Deserialize a Simplicity 'program' with its 'witness' data and execute it in the environment of the 'ix'th input of 'tx' with `taproot`. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * meaning we were unable to determine the result of the simplicity program. + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If deserialization, analysis, or execution fails, then '*error' is set to some simplicity_err. + * In particular, if the cost analysis exceeds the budget, or exceeds BUDGET_MAX, then '*error' is set to 'SIMPLICITY_ERR_EXEC_BUDGET'. + * On the other hand, if the cost analysis is less than or equal to minCost, then '*error' is set to 'SIMPLICITY_ERR_OVERWEIGHT'. + * + * Note that minCost and budget parameters are in WU, while the cost analysis will be performed in milliWU. + * Thus the minCost and budget specify a half open interval (minCost, budget] of acceptable cost values in milliWU. + * Setting minCost to 0 effectively disables the minCost check as every Simplicity program has a non-zero cost analysis. + * + * If 'amr != NULL' and the annotated Merkle root of the decoded expression doesn't match 'amr' then '*error' is set to 'SIMPLICITY_ERR_AMR'. + * + * Otherwise '*error' is set to 'SIMPLICITY_NO_ERROR'. + * + * If 'ihr != NULL' and '*error' is set to 'SIMPLICITY_NO_ERROR', then the identity hash of the root of the decoded expression is written to 'ihr'. + * Otherwise if 'ihr != NULL' and '*error' is not set to 'SIMPLCITY_NO_ERROR', then 'ihr' may or may not be written to. + * + * Precondition: NULL != error; + * NULL != ihr implies unsigned char ihr[32] + * NULL != tx; + * NULL != taproot; + * 0 <= minCost <= budget; + * NULL != amr implies unsigned char amr[32] + * unsigned char program[program_len] + * unsigned char witness[witness_len] + */ +extern bool rustsimplicity_0_6_bitcoin_execSimplicity( simplicity_err* error, unsigned char* ihr + , const bitcoinTransaction* tx, uint_fast32_t ix, const bitcoinTapEnv* taproot + , int64_t minCost, int64_t budget + , const unsigned char* amr + , const unsigned char* program, size_t program_len + , const unsigned char* witness, size_t witness_len) { + rustsimplicity_0_6_assert(NULL != error); + rustsimplicity_0_6_assert(NULL != tx); + rustsimplicity_0_6_assert(NULL != taproot); + rustsimplicity_0_6_assert(0 <= minCost); + rustsimplicity_0_6_assert(minCost <= budget); + rustsimplicity_0_6_assert(NULL != program || 0 == program_len); + rustsimplicity_0_6_assert(NULL != witness || 0 == witness_len); + + combinator_counters census; + dag_node* dag = NULL; + int_fast32_t dag_len; + sha256_midstate amr_hash; + + if (amr) sha256_toMidstate(amr_hash.s, amr); + + { + bitstream stream = initializeBitstream(program, program_len); + dag_len = rustsimplicity_0_6_decodeMallocDag(&dag, rustsimplicity_0_6_bitcoin_decodeJet, &census, &stream); + if (dag_len <= 0) { + rustsimplicity_0_6_assert(dag_len < 0); + *error = (simplicity_err)dag_len; + return IS_PERMANENT(*error); + } + rustsimplicity_0_6_assert(NULL != dag); + rustsimplicity_0_6_assert((uint_fast32_t)dag_len <= DAG_LEN_MAX); + *error = rustsimplicity_0_6_closeBitstream(&stream); + } + + if (IS_OK(*error)) { + if (0 != memcmp(taproot->scriptCMR.s, dag[dag_len-1].cmr.s, sizeof(uint32_t[8]))) { + *error = SIMPLICITY_ERR_CMR; + } + } + + if (IS_OK(*error)) { + type* type_dag = NULL; + *error = rustsimplicity_0_6_mallocTypeInference(&type_dag, rustsimplicity_0_6_bitcoin_mallocBoundVars, dag, (uint_fast32_t)dag_len, &census); + if (IS_OK(*error)) { + rustsimplicity_0_6_assert(NULL != type_dag); + if (0 != dag[dag_len-1].sourceType || 0 != dag[dag_len-1].targetType) { + *error = SIMPLICITY_ERR_TYPE_INFERENCE_NOT_PROGRAM; + } + } + if (IS_OK(*error)) { + bitstream witness_stream = initializeBitstream(witness, witness_len); + *error = rustsimplicity_0_6_fillWitnessData(dag, type_dag, (uint_fast32_t)dag_len, &witness_stream); + if (IS_OK(*error)) { + *error = rustsimplicity_0_6_closeBitstream(&witness_stream); + if (SIMPLICITY_ERR_BITSTREAM_TRAILING_BYTES == *error) *error = SIMPLICITY_ERR_WITNESS_TRAILING_BYTES; + if (SIMPLICITY_ERR_BITSTREAM_ILLEGAL_PADDING == *error) *error = SIMPLICITY_ERR_WITNESS_ILLEGAL_PADDING; + } + } + if (IS_OK(*error)) { + sha256_midstate ihr_buf; + *error = rustsimplicity_0_6_verifyNoDuplicateIdentityHashes(&ihr_buf, dag, type_dag, (uint_fast32_t)dag_len); + if (IS_OK(*error) && ihr) sha256_fromMidstate(ihr, ihr_buf.s); + } + if (IS_OK(*error) && amr) { + static_assert(DAG_LEN_MAX <= SIZE_MAX / sizeof(analyses), "analysis array too large."); + static_assert(1 <= DAG_LEN_MAX, "DAG_LEN_MAX is zero."); + static_assert(DAG_LEN_MAX - 1 <= UINT32_MAX, "analysis array index does nto fit in uint32_t."); + analyses *analysis = rustsimplicity_0_6_malloc((size_t)dag_len * sizeof(analyses)); + if (analysis) { + rustsimplicity_0_6_computeAnnotatedMerkleRoot(analysis, dag, type_dag, (uint_fast32_t)dag_len); + if (0 != memcmp(amr_hash.s, analysis[dag_len-1].annotatedMerkleRoot.s, sizeof(uint32_t[8]))) { + *error = SIMPLICITY_ERR_AMR; + } + } else { + /* malloc failed which counts as a transient error. */ + *error = SIMPLICITY_ERR_MALLOC; + } + rustsimplicity_0_6_free(analysis); + } + if (IS_OK(*error)) { + txEnv env = rustsimplicity_0_6_bitcoin_build_txEnv(tx, taproot, ix); + static_assert(BUDGET_MAX <= UBOUNDED_MAX, "BUDGET_MAX doesn't fit in ubounded."); + *error = evalTCOProgram( dag, type_dag, (size_t)dag_len + , minCost <= BUDGET_MAX ? (ubounded)minCost : BUDGET_MAX + , &(ubounded){budget <= BUDGET_MAX ? (ubounded)budget : BUDGET_MAX} + , &env); + } + rustsimplicity_0_6_free(type_dag); + } + + rustsimplicity_0_6_free(dag); + return IS_PERMANENT(*error); +} diff --git a/simplicity-sys/depend/simplicity/bitcoin/ops.c b/simplicity-sys/depend/simplicity/bitcoin/ops.c new file mode 100644 index 00000000..fc2be3e3 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/ops.c @@ -0,0 +1,56 @@ +#include "ops.h" + +/* Compute Bitcoins's tapleaf hash from a tapleaf version and a 256-bit script value. + * A reimplementation of ComputeTapleafHash from Bitcoin's 'interpreter.cpp'. + * Only 256-bit script values are supported as that is the size used for Simplicity CMRs. + * + * Precondition: NULL != cmr; + */ +sha256_midstate rustsimplicity_0_6_bitcoin_make_tapleaf(unsigned char version, const sha256_midstate* cmr) { + sha256_midstate result; + sha256_midstate tapleafTag; + { + static unsigned char tagName[] = "TapLeaf"; + sha256_context ctx = sha256_init(tapleafTag.s); + sha256_uchars(&ctx, tagName, sizeof(tagName) - 1); + sha256_finalize(&ctx); + } + sha256_context ctx = sha256_init(result.s); + sha256_hash(&ctx, &tapleafTag); + sha256_hash(&ctx, &tapleafTag); + sha256_uchar(&ctx, version); + sha256_uchar(&ctx, 32); + sha256_hash(&ctx, cmr); + sha256_finalize(&ctx); + + return result; +} + +/* Compute Bitcoins's tapbrach hash from two branches. + * + * Precondition: NULL != a; + * NULL != b; + */ +sha256_midstate rustsimplicity_0_6_bitcoin_make_tapbranch(const sha256_midstate* a, const sha256_midstate* b) { + sha256_midstate result; + sha256_midstate tapbranchTag; + { + static unsigned char tagName[] = "TapBranch"; + sha256_context ctx = sha256_init(tapbranchTag.s); + sha256_uchars(&ctx, tagName, sizeof(tagName) - 1); + sha256_finalize(&ctx); + } + sha256_context ctx = sha256_init(result.s); + sha256_hash(&ctx, &tapbranchTag); + sha256_hash(&ctx, &tapbranchTag); + if (sha256_cmp_be(a, b) < 0) { + sha256_hash(&ctx, a); + sha256_hash(&ctx, b); + } else { + sha256_hash(&ctx, b); + sha256_hash(&ctx, a); + } + sha256_finalize(&ctx); + + return result; +} diff --git a/simplicity-sys/depend/simplicity/bitcoin/ops.h b/simplicity-sys/depend/simplicity/bitcoin/ops.h new file mode 100644 index 00000000..c8776ce6 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/ops.h @@ -0,0 +1,23 @@ +/* This module defines operations used in the construction the environment ('txEnv') and some jets. + */ +#ifndef SIMPLICITY_BITCOIN_OPS_H +#define SIMPLICITY_BITCOIN_OPS_H + +#include "../sha256.h" + +/* Compute Bitcoin's tapleaf hash from a tapleaf version and a 256-bit script value. + * A reimplementation of ComputeTapleafHash from Bitcoin's 'interpreter.cpp'. + * Only 256-bit script values are supported as that is the size used for Simplicity CMRs. + * + * Precondition: NULL != cmr; + */ +sha256_midstate rustsimplicity_0_6_bitcoin_make_tapleaf(unsigned char version, const sha256_midstate* cmr); + +/* Compute an Bitcoin's tapbrach hash from two branches. + * + * Precondition: NULL != a; + * NULL != b; + */ +sha256_midstate rustsimplicity_0_6_bitcoin_make_tapbranch(const sha256_midstate* a, const sha256_midstate* b); + +#endif diff --git a/simplicity-sys/depend/simplicity/bitcoin/primitive.c b/simplicity-sys/depend/simplicity/bitcoin/primitive.c new file mode 100644 index 00000000..ed2e0b60 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/primitive.c @@ -0,0 +1,107 @@ +/* This module implements the 'primitive.h' interface for the Bitcoin application of Simplicity. + */ +#include "primitive.h" + +#include "bitcoinJets.h" +#include "../limitations.h" +#include "../simplicity_alloc.h" +#include "../simplicity_assert.h" + +/* An enumeration of all the types we need to construct to specify the input and output types of all jets created by 'decodeJet'. */ +enum TypeNamesForJets { +#include "primitiveEnumTy.inc" + NumberOfTypeNames +}; + +/* Allocate a fresh set of unification variables bound to at least all the types necessary + * for all the jets that can be created by 'decodeJet', and also the type 'TWO^256', + * and also allocate space for 'extra_var_len' many unification variables. + * Return the number of non-trivial bindings created. + * + * However, if malloc fails, then return 0. + * + * Precondition: NULL != bound_var; + * NULL != word256_ix; + * NULL != extra_var_start; + * extra_var_len <= 6*DAG_LEN_MAX; + * + * Postcondition: Either '*bound_var == NULL' and the function returns 0 + * or 'unification_var (*bound_var)[*extra_var_start + extra_var_len]' is an array of unification variables + * such that for any 'jet : A |- B' there is some 'i < *extra_var_start' and 'j < *extra_var_start' such that + * '(*bound_var)[i]' is bound to 'A' and '(*bound_var)[j]' is bound to 'B' + * and, '*word256_ix < *extra_var_start' and '(*bound_var)[*word256_ix]' is bound the type 'TWO^256' + */ +size_t rustsimplicity_0_6_bitcoin_mallocBoundVars(unification_var** bound_var, size_t* word256_ix, size_t* extra_var_start, size_t extra_var_len) { + static_assert(1 <= NumberOfTypeNames, "Missing TypeNamesForJets."); + static_assert(NumberOfTypeNames <= NUMBER_OF_TYPENAMES_MAX, "Too many TypeNamesForJets."); + static_assert(DAG_LEN_MAX <= (SIZE_MAX - NumberOfTypeNames) / 6, "NumberOfTypeNames + 6*DAG_LEN_MAX doesn't fit in size_t"); + static_assert(NumberOfTypeNames + 6*DAG_LEN_MAX <= SIZE_MAX/sizeof(unification_var) , "bound_var array too large"); + static_assert(NumberOfTypeNames + 6*DAG_LEN_MAX - 1 <= UINT32_MAX, "bound_var array index doesn't fit in uint32_t"); + rustsimplicity_0_6_assert(extra_var_len <= 6*DAG_LEN_MAX); + *bound_var = rustsimplicity_0_6_malloc((NumberOfTypeNames + extra_var_len) * sizeof(unification_var)); + if (!(*bound_var)) return 0; +#include "primitiveInitTy.inc" + *word256_ix = ty_w256; + *extra_var_start = NumberOfTypeNames; + + /* 'ty_u' is a trivial binding, so we made 'NumberOfTypeNames - 1' non-trivial bindings. */ + return NumberOfTypeNames - 1; +}; + +/* An enumeration of the names of Bitcoin specific jets and primitives. */ +typedef enum jetName +{ +#include "primitiveEnumJet.inc" + NUMBER_OF_JET_NAMES +} jetName; + +/* Decode an Bitcoin specific jet name from 'stream' into 'result'. + * All jets begin with a bit prefix of '1' which needs to have already been consumed from the 'stream'. + * Returns 'SIMPLICITY_ERR_DATA_OUT_OF_RANGE' if the stream's prefix doesn't match any valid code for a jet. + * Returns 'SIMPLICITY_ERR_BITSTRING_EOF' if not enough bits are available in the 'stream'. + * In the above error cases, 'result' may be modified. + * Returns 'SIMPLICITY_NO_ERROR' if successful. + * + * Precondition: NULL != result + * NULL != stream + */ +static simplicity_err decodePrimitive(jetName* result, bitstream* stream) { + int32_t bit = read1Bit(stream); + if (bit < 0) return (simplicity_err)bit; + if (!bit) { + /* Core jets */ +#include "../decodeCoreJets.inc" + return SIMPLICITY_ERR_DATA_OUT_OF_RANGE; + } else { + /* Bitcoin jets */ +#include "decodeBitcoinJets.inc" + return SIMPLICITY_ERR_DATA_OUT_OF_RANGE; + } +} + +/* Return a copy of the Simplicity node corresponding to the given Bitcoin specific jet 'name'. */ +static dag_node jetNode(jetName name) { + static const dag_node jet_node[] = { + #include "primitiveJetNode.inc" + }; + + return jet_node[name]; +} + +/* Decode a Bitcoin specific jet from 'stream' into 'node'. + * All jets begin with a bit prefix of '1' which needs to have already been consumed from the 'stream'. + * Returns 'SIMPLICITY_ERR_DATA_OUT_OF_RANGE' if the stream's prefix doesn't match any valid code for a jet. + * Returns 'SIMPLICITY_ERR_BITSTRING_EOF' if not enough bits are available in the 'stream'. + * In the above error cases, 'dag' may be modified. + * Returns 'SIMPLICITY_NO_ERR' if successful. + * + * Precondition: NULL != node + * NULL != stream + */ +simplicity_err rustsimplicity_0_6_bitcoin_decodeJet(dag_node* node, bitstream* stream) { + jetName name; + simplicity_err error = decodePrimitive(&name, stream); + if (!IS_OK(error)) return error; + *node = jetNode(name); + return SIMPLICITY_NO_ERROR; +} diff --git a/simplicity-sys/depend/simplicity/bitcoin/primitive.h b/simplicity-sys/depend/simplicity/bitcoin/primitive.h new file mode 100644 index 00000000..6dc505ba --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/primitive.h @@ -0,0 +1,41 @@ +/* Implements the primitive.h interface for the Bitcoin Simplicity application. + */ +#ifndef SIMPLICITY_BITCOIN_PRIMITIVE_H +#define SIMPLICITY_BITCOIN_PRIMITIVE_H + +#include "../bitstream.h" +#include "../typeInference.h" + +/* Allocate a fresh set of unification variables bound to at least all the types necessary + * for all the jets that can be created by 'decodeJet', and also the type 'TWO^256', + * and also allocate space for 'extra_var_len' many unification variables. + * Return the number of non-trivial bindings created. + * + * However, if malloc fails, then return 0. + * + * Precondition: NULL != bound_var; + * NULL != word256_ix; + * NULL != extra_var_start; + * extra_var_len <= 6*DAG_LEN_MAX; + * + * Postcondition: Either '*bound_var == NULL' and the function returns 0 + * or 'unification_var (*bound_var)[*extra_var_start + extra_var_len]' is an array of unification variables + * such that for any 'jet : A |- B' there is some 'i < *extra_var_start' and 'j < *extra_var_start' such that + * '(*bound_var)[i]' is bound to 'A' and '(*bound_var)[j]' is bound to 'B' + * and, '*word256_ix < *extra_var_start' and '(*bound_var)[*word256_ix]' is bound the type 'TWO^256' + */ +size_t rustsimplicity_0_6_bitcoin_mallocBoundVars(unification_var** bound_var, size_t* word256_ix, size_t* extra_var_start, size_t extra_var_len); + +/* Decode a Bitcoin specific jet from 'stream' into 'node'. + * All jets begin with a bit prefix of '1' which needs to have already been consumed from the 'stream'. + * Returns 'SIMPLICITY_ERR_DATA_OUT_OF_RANGE' if the stream's prefix doesn't match any valid code for a jet. + * Returns 'SIMPLICITY_ERR_BITSTRING_EOF' if not enough bits are available in the 'stream'. + * In the above error cases, 'dag' may be modified. + * Returns 'SIMPLICITY_NO_ERROR' if successful. + * + * Precondition: NULL != node + * NULL != stream + */ +simplicity_err rustsimplicity_0_6_bitcoin_decodeJet(dag_node* node, bitstream* stream); + +#endif diff --git a/simplicity-sys/depend/simplicity/bitcoin/primitiveEnumJet.inc b/simplicity-sys/depend/simplicity/bitcoin/primitiveEnumJet.inc new file mode 100644 index 00000000..b39f0d84 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/primitiveEnumJet.inc @@ -0,0 +1,429 @@ +/* This file has been automatically generated. */ +ADD_16, +ADD_32, +ADD_64, +ADD_8, +ALL_16, +ALL_32, +ALL_64, +ALL_8, +AND_1, +AND_16, +AND_32, +AND_64, +AND_8, +ANNEX_HASH, +BIP_0340_VERIFY, +BUILD_TAPBRANCH, +BUILD_TAPLEAF_SIMPLICITY, +BUILD_TAPTWEAK, +CH_1, +CH_16, +CH_32, +CH_64, +CH_8, +CHECK_LOCK_DISTANCE, +CHECK_LOCK_DURATION, +CHECK_LOCK_HEIGHT, +CHECK_LOCK_TIME, +CHECK_SIG_VERIFY, +COMPLEMENT_1, +COMPLEMENT_16, +COMPLEMENT_32, +COMPLEMENT_64, +COMPLEMENT_8, +CURRENT_ANNEX_HASH, +CURRENT_INDEX, +CURRENT_PREV_OUTPOINT, +CURRENT_SCRIPT_HASH, +CURRENT_SCRIPT_SIG_HASH, +CURRENT_SEQUENCE, +CURRENT_VALUE, +DECOMPRESS, +DECREMENT_16, +DECREMENT_32, +DECREMENT_64, +DECREMENT_8, +DIV_MOD_128_64, +DIV_MOD_16, +DIV_MOD_32, +DIV_MOD_64, +DIV_MOD_8, +DIVIDE_16, +DIVIDE_32, +DIVIDE_64, +DIVIDE_8, +DIVIDES_16, +DIVIDES_32, +DIVIDES_64, +DIVIDES_8, +EQ_1, +EQ_16, +EQ_256, +EQ_32, +EQ_64, +EQ_8, +FE_ADD, +FE_INVERT, +FE_IS_ODD, +FE_IS_ZERO, +FE_MULTIPLY, +FE_MULTIPLY_BETA, +FE_NEGATE, +FE_NORMALIZE, +FE_SQUARE, +FE_SQUARE_ROOT, +FEE, +FULL_ADD_16, +FULL_ADD_32, +FULL_ADD_64, +FULL_ADD_8, +FULL_DECREMENT_16, +FULL_DECREMENT_32, +FULL_DECREMENT_64, +FULL_DECREMENT_8, +FULL_INCREMENT_16, +FULL_INCREMENT_32, +FULL_INCREMENT_64, +FULL_INCREMENT_8, +FULL_LEFT_SHIFT_16_1, +FULL_LEFT_SHIFT_16_2, +FULL_LEFT_SHIFT_16_4, +FULL_LEFT_SHIFT_16_8, +FULL_LEFT_SHIFT_32_1, +FULL_LEFT_SHIFT_32_16, +FULL_LEFT_SHIFT_32_2, +FULL_LEFT_SHIFT_32_4, +FULL_LEFT_SHIFT_32_8, +FULL_LEFT_SHIFT_64_1, +FULL_LEFT_SHIFT_64_16, +FULL_LEFT_SHIFT_64_2, +FULL_LEFT_SHIFT_64_32, +FULL_LEFT_SHIFT_64_4, +FULL_LEFT_SHIFT_64_8, +FULL_LEFT_SHIFT_8_1, +FULL_LEFT_SHIFT_8_2, +FULL_LEFT_SHIFT_8_4, +FULL_MULTIPLY_16, +FULL_MULTIPLY_32, +FULL_MULTIPLY_64, +FULL_MULTIPLY_8, +FULL_RIGHT_SHIFT_16_1, +FULL_RIGHT_SHIFT_16_2, +FULL_RIGHT_SHIFT_16_4, +FULL_RIGHT_SHIFT_16_8, +FULL_RIGHT_SHIFT_32_1, +FULL_RIGHT_SHIFT_32_16, +FULL_RIGHT_SHIFT_32_2, +FULL_RIGHT_SHIFT_32_4, +FULL_RIGHT_SHIFT_32_8, +FULL_RIGHT_SHIFT_64_1, +FULL_RIGHT_SHIFT_64_16, +FULL_RIGHT_SHIFT_64_2, +FULL_RIGHT_SHIFT_64_32, +FULL_RIGHT_SHIFT_64_4, +FULL_RIGHT_SHIFT_64_8, +FULL_RIGHT_SHIFT_8_1, +FULL_RIGHT_SHIFT_8_2, +FULL_RIGHT_SHIFT_8_4, +FULL_SUBTRACT_16, +FULL_SUBTRACT_32, +FULL_SUBTRACT_64, +FULL_SUBTRACT_8, +GE_IS_ON_CURVE, +GE_NEGATE, +GEJ_ADD, +GEJ_DOUBLE, +GEJ_EQUIV, +GEJ_GE_ADD, +GEJ_GE_ADD_EX, +GEJ_GE_EQUIV, +GEJ_INFINITY, +GEJ_IS_INFINITY, +GEJ_IS_ON_CURVE, +GEJ_NEGATE, +GEJ_NORMALIZE, +GEJ_RESCALE, +GEJ_X_EQUIV, +GEJ_Y_IS_ODD, +GENERATE, +HASH_TO_CURVE, +HIGH_1, +HIGH_16, +HIGH_32, +HIGH_64, +HIGH_8, +INCREMENT_16, +INCREMENT_32, +INCREMENT_64, +INCREMENT_8, +INPUT_ANNEX_HASH, +INPUT_ANNEXES_HASH, +INPUT_HASH, +INPUT_OUTPOINTS_HASH, +INPUT_PREV_OUTPOINT, +INPUT_SCRIPT_HASH, +INPUT_SCRIPT_SIG_HASH, +INPUT_SCRIPT_SIGS_HASH, +INPUT_SCRIPTS_HASH, +INPUT_SEQUENCE, +INPUT_SEQUENCES_HASH, +INPUT_UTXO_HASH, +INPUT_UTXOS_HASH, +INPUT_VALUE, +INPUT_VALUES_HASH, +INPUTS_HASH, +INTERNAL_KEY, +IS_ONE_16, +IS_ONE_32, +IS_ONE_64, +IS_ONE_8, +IS_ZERO_16, +IS_ZERO_32, +IS_ZERO_64, +IS_ZERO_8, +LE_16, +LE_32, +LE_64, +LE_8, +LEFT_EXTEND_16_32, +LEFT_EXTEND_16_64, +LEFT_EXTEND_1_16, +LEFT_EXTEND_1_32, +LEFT_EXTEND_1_64, +LEFT_EXTEND_1_8, +LEFT_EXTEND_32_64, +LEFT_EXTEND_8_16, +LEFT_EXTEND_8_32, +LEFT_EXTEND_8_64, +LEFT_PAD_HIGH_16_32, +LEFT_PAD_HIGH_16_64, +LEFT_PAD_HIGH_1_16, +LEFT_PAD_HIGH_1_32, +LEFT_PAD_HIGH_1_64, +LEFT_PAD_HIGH_1_8, +LEFT_PAD_HIGH_32_64, +LEFT_PAD_HIGH_8_16, +LEFT_PAD_HIGH_8_32, +LEFT_PAD_HIGH_8_64, +LEFT_PAD_LOW_16_32, +LEFT_PAD_LOW_16_64, +LEFT_PAD_LOW_1_16, +LEFT_PAD_LOW_1_32, +LEFT_PAD_LOW_1_64, +LEFT_PAD_LOW_1_8, +LEFT_PAD_LOW_32_64, +LEFT_PAD_LOW_8_16, +LEFT_PAD_LOW_8_32, +LEFT_PAD_LOW_8_64, +LEFT_ROTATE_16, +LEFT_ROTATE_32, +LEFT_ROTATE_64, +LEFT_ROTATE_8, +LEFT_SHIFT_16, +LEFT_SHIFT_32, +LEFT_SHIFT_64, +LEFT_SHIFT_8, +LEFT_SHIFT_WITH_16, +LEFT_SHIFT_WITH_32, +LEFT_SHIFT_WITH_64, +LEFT_SHIFT_WITH_8, +LEFTMOST_16_1, +LEFTMOST_16_2, +LEFTMOST_16_4, +LEFTMOST_16_8, +LEFTMOST_32_1, +LEFTMOST_32_16, +LEFTMOST_32_2, +LEFTMOST_32_4, +LEFTMOST_32_8, +LEFTMOST_64_1, +LEFTMOST_64_16, +LEFTMOST_64_2, +LEFTMOST_64_32, +LEFTMOST_64_4, +LEFTMOST_64_8, +LEFTMOST_8_1, +LEFTMOST_8_2, +LEFTMOST_8_4, +LINEAR_COMBINATION_1, +LINEAR_VERIFY_1, +LOCK_TIME, +LOW_1, +LOW_16, +LOW_32, +LOW_64, +LOW_8, +LT_16, +LT_32, +LT_64, +LT_8, +MAJ_1, +MAJ_16, +MAJ_32, +MAJ_64, +MAJ_8, +MAX_16, +MAX_32, +MAX_64, +MAX_8, +MEDIAN_16, +MEDIAN_32, +MEDIAN_64, +MEDIAN_8, +MIN_16, +MIN_32, +MIN_64, +MIN_8, +MODULO_16, +MODULO_32, +MODULO_64, +MODULO_8, +MULTIPLY_16, +MULTIPLY_32, +MULTIPLY_64, +MULTIPLY_8, +NEGATE_16, +NEGATE_32, +NEGATE_64, +NEGATE_8, +NUM_INPUTS, +NUM_OUTPUTS, +ONE_16, +ONE_32, +ONE_64, +ONE_8, +OR_1, +OR_16, +OR_32, +OR_64, +OR_8, +OUTPOINT_HASH, +OUTPUT_HASH, +OUTPUT_SCRIPT_HASH, +OUTPUT_SCRIPTS_HASH, +OUTPUT_VALUE, +OUTPUT_VALUES_HASH, +OUTPUTS_HASH, +PARSE_LOCK, +PARSE_SEQUENCE, +POINT_VERIFY_1, +RIGHT_EXTEND_16_32, +RIGHT_EXTEND_16_64, +RIGHT_EXTEND_32_64, +RIGHT_EXTEND_8_16, +RIGHT_EXTEND_8_32, +RIGHT_EXTEND_8_64, +RIGHT_PAD_HIGH_16_32, +RIGHT_PAD_HIGH_16_64, +RIGHT_PAD_HIGH_1_16, +RIGHT_PAD_HIGH_1_32, +RIGHT_PAD_HIGH_1_64, +RIGHT_PAD_HIGH_1_8, +RIGHT_PAD_HIGH_32_64, +RIGHT_PAD_HIGH_8_16, +RIGHT_PAD_HIGH_8_32, +RIGHT_PAD_HIGH_8_64, +RIGHT_PAD_LOW_16_32, +RIGHT_PAD_LOW_16_64, +RIGHT_PAD_LOW_1_16, +RIGHT_PAD_LOW_1_32, +RIGHT_PAD_LOW_1_64, +RIGHT_PAD_LOW_1_8, +RIGHT_PAD_LOW_32_64, +RIGHT_PAD_LOW_8_16, +RIGHT_PAD_LOW_8_32, +RIGHT_PAD_LOW_8_64, +RIGHT_ROTATE_16, +RIGHT_ROTATE_32, +RIGHT_ROTATE_64, +RIGHT_ROTATE_8, +RIGHT_SHIFT_16, +RIGHT_SHIFT_32, +RIGHT_SHIFT_64, +RIGHT_SHIFT_8, +RIGHT_SHIFT_WITH_16, +RIGHT_SHIFT_WITH_32, +RIGHT_SHIFT_WITH_64, +RIGHT_SHIFT_WITH_8, +RIGHTMOST_16_1, +RIGHTMOST_16_2, +RIGHTMOST_16_4, +RIGHTMOST_16_8, +RIGHTMOST_32_1, +RIGHTMOST_32_16, +RIGHTMOST_32_2, +RIGHTMOST_32_4, +RIGHTMOST_32_8, +RIGHTMOST_64_1, +RIGHTMOST_64_16, +RIGHTMOST_64_2, +RIGHTMOST_64_32, +RIGHTMOST_64_4, +RIGHTMOST_64_8, +RIGHTMOST_8_1, +RIGHTMOST_8_2, +RIGHTMOST_8_4, +SCALAR_ADD, +SCALAR_INVERT, +SCALAR_IS_ZERO, +SCALAR_MULTIPLY, +SCALAR_MULTIPLY_LAMBDA, +SCALAR_NEGATE, +SCALAR_NORMALIZE, +SCALAR_SQUARE, +SCALE, +SCRIPT_CMR, +SHA_256_BLOCK, +SHA_256_CTX_8_ADD_1, +SHA_256_CTX_8_ADD_128, +SHA_256_CTX_8_ADD_16, +SHA_256_CTX_8_ADD_2, +SHA_256_CTX_8_ADD_256, +SHA_256_CTX_8_ADD_32, +SHA_256_CTX_8_ADD_4, +SHA_256_CTX_8_ADD_512, +SHA_256_CTX_8_ADD_64, +SHA_256_CTX_8_ADD_8, +SHA_256_CTX_8_ADD_BUFFER_511, +SHA_256_CTX_8_FINALIZE, +SHA_256_CTX_8_INIT, +SHA_256_IV, +SIG_ALL_HASH, +SOME_1, +SOME_16, +SOME_32, +SOME_64, +SOME_8, +SUBTRACT_16, +SUBTRACT_32, +SUBTRACT_64, +SUBTRACT_8, +SWU, +TAP_ENV_HASH, +TAPDATA_INIT, +TAPLEAF_HASH, +TAPLEAF_VERSION, +TAPPATH, +TAPPATH_HASH, +TOTAL_INPUT_VALUE, +TOTAL_OUTPUT_VALUE, +TRANSACTION_ID, +TX_HASH, +TX_IS_FINAL, +TX_LOCK_DISTANCE, +TX_LOCK_DURATION, +TX_LOCK_HEIGHT, +TX_LOCK_TIME, +VERIFY, +VERSION, +XOR_1, +XOR_16, +XOR_32, +XOR_64, +XOR_8, +XOR_XOR_1, +XOR_XOR_16, +XOR_XOR_32, +XOR_XOR_64, +XOR_XOR_8, diff --git a/simplicity-sys/depend/simplicity/bitcoin/primitiveEnumTy.inc b/simplicity-sys/depend/simplicity/bitcoin/primitiveEnumTy.inc new file mode 100644 index 00000000..21ce08cb --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/primitiveEnumTy.inc @@ -0,0 +1,130 @@ +/* This file has been automatically generated. */ +ty_u = 0, +ty_b = 1, +ty_w2 = 2, +ty_w4 = 3, +ty_w8 = 4, +ty_w16 = 5, +ty_w32 = 6, +ty_w64 = 7, +ty_w128 = 8, +ty_w256 = 9, +ty_w512 = 10, +ty_w1Ki = 11, +ty_w2Ki = 12, +ty_w4Ki = 13, +ty_w8Ki = 14, +ty_w16Ki = 15, +ty_w32Ki = 16, +ty_w64Ki = 17, +ty_w128Ki = 18, +ty_w256Ki = 19, +ty_w512Ki = 20, +ty_w1Mi = 21, +ty_w2Mi = 22, +ty_w4Mi = 23, +ty_w8Mi = 24, +ty_w16Mi = 25, +ty_w32Mi = 26, +ty_w64Mi = 27, +ty_w128Mi = 28, +ty_w256Mi = 29, +ty_w512Mi = 30, +ty_w1Gi = 31, +ty_w2Gi = 32, +ty_mw8, +ty_mw16, +ty_mw32, +ty_mw64, +ty_mw128, +ty_mw256, +ty_mw512, +ty_mw1Ki, +ty_mw2Ki, +ty_mmw256, +ty_msw16w16, +ty_mpw256w32, +ty_sw16w16, +ty_sw32w32, +ty_pbw2, +ty_pbw8, +ty_pbw16, +ty_pbw32, +ty_pbw64, +ty_pbw128, +ty_pbw256, +ty_pbpw4w8, +ty_pbpw4w16, +ty_pbpw8w32, +ty_pbpw8w64, +ty_pw2w8, +ty_pw2w16, +ty_pw2w32, +ty_pw2w64, +ty_pw4w8, +ty_pw4w16, +ty_pw4w32, +ty_pw4w64, +ty_pw8b, +ty_pw8w2, +ty_pw8w4, +ty_pw8w16, +ty_pw8w32, +ty_pw8w64, +ty_pw16b, +ty_pw16w2, +ty_pw16w4, +ty_pw16w8, +ty_pw16w32, +ty_pw16w64, +ty_pw32b, +ty_pw32w2, +ty_pw32w4, +ty_pw32w8, +ty_pw32w16, +ty_pw32w64, +ty_pw64b, +ty_pw64w2, +ty_pw64w4, +ty_pw64w8, +ty_pw64w16, +ty_pw64w32, +ty_pw64w128, +ty_pw64w256, +ty_pw128w64, +ty_pw256w32, +ty_pw256w512, +ty_pw256pbw256, +ty_pw256pw512w256, +ty_pw512w256, +ty_pmw16mw8, +ty_pmw32pmw16mw8, +ty_pmw64pmw32pmw16mw8, +ty_pmw128pmw64pmw32pmw16mw8, +ty_pmw256pmw128pmw64pmw32pmw16mw8, +ty_pmw512pmw256pmw128pmw64pmw32pmw16mw8, +ty_pmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8, +ty_pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8, +ty_ppw256w512w256, +ty_ppw256w512w512, +ty_ppw256pbw256w256, +ty_ppw256pw512w256w256, +ty_ppw512w256w256, +ty_ppw512w256w512, +ty_ppw512w256pw512w256, +ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256, +ty_pppw256w512w256w512, +ty_pppw256pbw256w256pbw256, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w8, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w16, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w32, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w64, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w128, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w256, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w512, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w1Ki, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w2Ki, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w4Ki, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256mw256, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pw256w32, +ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8, diff --git a/simplicity-sys/depend/simplicity/bitcoin/primitiveInitTy.inc b/simplicity-sys/depend/simplicity/bitcoin/primitiveInitTy.inc new file mode 100644 index 00000000..b2ae9eb9 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/primitiveInitTy.inc @@ -0,0 +1,130 @@ +/* This file has been automatically generated. */ +(*bound_var)[ty_u] = (unification_var){ .isBound = true, .bound = { .kind = ONE }}; +(*bound_var)[ty_b] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_u] } }}; +(*bound_var)[ty_w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_b] } }}; +(*bound_var)[ty_w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w2] } }}; +(*bound_var)[ty_w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w4] } }}; +(*bound_var)[ty_w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w8] } }}; +(*bound_var)[ty_w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_w128] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w128], &(*bound_var)[ty_w128] } }}; +(*bound_var)[ty_w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_w1Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w512], &(*bound_var)[ty_w512] } }}; +(*bound_var)[ty_w2Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w1Ki], &(*bound_var)[ty_w1Ki] } }}; +(*bound_var)[ty_w4Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2Ki], &(*bound_var)[ty_w2Ki] } }}; +(*bound_var)[ty_w8Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4Ki], &(*bound_var)[ty_w4Ki] } }}; +(*bound_var)[ty_w16Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8Ki], &(*bound_var)[ty_w8Ki] } }}; +(*bound_var)[ty_w32Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16Ki], &(*bound_var)[ty_w16Ki] } }}; +(*bound_var)[ty_w64Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32Ki], &(*bound_var)[ty_w32Ki] } }}; +(*bound_var)[ty_w128Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64Ki], &(*bound_var)[ty_w64Ki] } }}; +(*bound_var)[ty_w256Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w128Ki], &(*bound_var)[ty_w128Ki] } }}; +(*bound_var)[ty_w512Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256Ki], &(*bound_var)[ty_w256Ki] } }}; +(*bound_var)[ty_w1Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w512Ki], &(*bound_var)[ty_w512Ki] } }}; +(*bound_var)[ty_w2Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w1Mi], &(*bound_var)[ty_w1Mi] } }}; +(*bound_var)[ty_w4Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2Mi], &(*bound_var)[ty_w2Mi] } }}; +(*bound_var)[ty_w8Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4Mi], &(*bound_var)[ty_w4Mi] } }}; +(*bound_var)[ty_w16Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8Mi], &(*bound_var)[ty_w8Mi] } }}; +(*bound_var)[ty_w32Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16Mi], &(*bound_var)[ty_w16Mi] } }}; +(*bound_var)[ty_w64Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32Mi], &(*bound_var)[ty_w32Mi] } }}; +(*bound_var)[ty_w128Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64Mi], &(*bound_var)[ty_w64Mi] } }}; +(*bound_var)[ty_w256Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w128Mi], &(*bound_var)[ty_w128Mi] } }}; +(*bound_var)[ty_w512Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256Mi], &(*bound_var)[ty_w256Mi] } }}; +(*bound_var)[ty_w1Gi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w512Mi], &(*bound_var)[ty_w512Mi] } }}; +(*bound_var)[ty_w2Gi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w1Gi], &(*bound_var)[ty_w1Gi] } }}; +(*bound_var)[ty_mw8] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w8] } }}; +(*bound_var)[ty_mw16] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_mw32] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_mw64] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_mw128] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w128] } }}; +(*bound_var)[ty_mw256] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_mw512] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w512] } }}; +(*bound_var)[ty_mw1Ki] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w1Ki] } }}; +(*bound_var)[ty_mw2Ki] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w2Ki] } }}; +(*bound_var)[ty_mmw256] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_mw256] } }}; +(*bound_var)[ty_msw16w16] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_sw16w16] } }}; +(*bound_var)[ty_mpw256w32] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_pw256w32] } }}; +(*bound_var)[ty_sw16w16] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_sw32w32] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_pbw2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w2] } }}; +(*bound_var)[ty_pbw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w8] } }}; +(*bound_var)[ty_pbw16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_pbw32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_pbw64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_pbw128] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w128] } }}; +(*bound_var)[ty_pbw256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_pbpw4w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_pw4w8] } }}; +(*bound_var)[ty_pbpw4w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_pw4w16] } }}; +(*bound_var)[ty_pbpw8w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_pw8w32] } }}; +(*bound_var)[ty_pbpw8w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_pw8w64] } }}; +(*bound_var)[ty_pw2w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w8] } }}; +(*bound_var)[ty_pw2w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_pw2w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_pw2w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_pw4w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w8] } }}; +(*bound_var)[ty_pw4w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_pw4w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_pw4w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_pw8b] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_b] } }}; +(*bound_var)[ty_pw8w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w2] } }}; +(*bound_var)[ty_pw8w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w4] } }}; +(*bound_var)[ty_pw8w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_pw8w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_pw8w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_pw16b] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_b] } }}; +(*bound_var)[ty_pw16w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w2] } }}; +(*bound_var)[ty_pw16w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w4] } }}; +(*bound_var)[ty_pw16w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w8] } }}; +(*bound_var)[ty_pw16w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_pw16w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_pw32b] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_b] } }}; +(*bound_var)[ty_pw32w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w2] } }}; +(*bound_var)[ty_pw32w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w4] } }}; +(*bound_var)[ty_pw32w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w8] } }}; +(*bound_var)[ty_pw32w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_pw32w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_pw64b] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_b] } }}; +(*bound_var)[ty_pw64w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w2] } }}; +(*bound_var)[ty_pw64w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w4] } }}; +(*bound_var)[ty_pw64w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w8] } }}; +(*bound_var)[ty_pw64w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_pw64w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_pw64w128] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w128] } }}; +(*bound_var)[ty_pw64w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_pw128w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w128], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_pw256w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_pw256w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_w512] } }}; +(*bound_var)[ty_pw256pbw256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_pbw256] } }}; +(*bound_var)[ty_pw256pw512w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_pw512w256] } }}; +(*bound_var)[ty_pw512w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w512], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw16], &(*bound_var)[ty_mw8] } }}; +(*bound_var)[ty_pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw32], &(*bound_var)[ty_pmw16mw8] } }}; +(*bound_var)[ty_pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw64], &(*bound_var)[ty_pmw32pmw16mw8] } }}; +(*bound_var)[ty_pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw128], &(*bound_var)[ty_pmw64pmw32pmw16mw8] } }}; +(*bound_var)[ty_pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw256], &(*bound_var)[ty_pmw128pmw64pmw32pmw16mw8] } }}; +(*bound_var)[ty_pmw512pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw512], &(*bound_var)[ty_pmw256pmw128pmw64pmw32pmw16mw8] } }}; +(*bound_var)[ty_pmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw1Ki], &(*bound_var)[ty_pmw512pmw256pmw128pmw64pmw32pmw16mw8] } }}; +(*bound_var)[ty_pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw2Ki], &(*bound_var)[ty_pmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] } }}; +(*bound_var)[ty_ppw256w512w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw256w512], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_ppw256w512w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw256w512], &(*bound_var)[ty_w512] } }}; +(*bound_var)[ty_ppw256pbw256w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw256pbw256], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_ppw256pw512w256w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw256pw512w256], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_ppw512w256w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw512w256], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_ppw512w256w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw512w256], &(*bound_var)[ty_w512] } }}; +(*bound_var)[ty_ppw512w256pw512w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw512w256], &(*bound_var)[ty_pw512w256] } }}; +(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pmw256pmw128pmw64pmw32pmw16mw8], &(*bound_var)[ty_pw64w256] } }}; +(*bound_var)[ty_pppw256w512w256w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppw256w512w256], &(*bound_var)[ty_w512] } }}; +(*bound_var)[ty_pppw256pbw256w256pbw256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppw256pbw256w256], &(*bound_var)[ty_pbw256] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w8] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w16] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w32] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w64] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w128] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w128] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w256] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w512] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w1Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w1Ki] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w2Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w2Ki] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w4Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w4Ki] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256mw256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_mw256] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pw256w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_pw256w32] } }}; +(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] } }}; diff --git a/simplicity-sys/depend/simplicity/bitcoin/primitiveJetNode.inc b/simplicity-sys/depend/simplicity/bitcoin/primitiveJetNode.inc new file mode 100644 index 00000000..9e94adcf --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/primitiveJetNode.inc @@ -0,0 +1,3425 @@ +/* This file has been automatically generated. */ +[ADD_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_add_16 +, .cmr = {{0x49425a86u, 0xe20a676du, 0x8b87e3c1u, 0xa9b8ea6eu, 0xc75d859cu, 0x12c51bcbu, 0x7fa9f969u, 0x12c349cfu}} +, .sourceIx = ty_w32 +, .targetIx = ty_pbw16 +, .cost = 80 /* milli weight units */ +} +,[ADD_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_add_32 +, .cmr = {{0x4668cd55u, 0xe8d15919u, 0x53327014u, 0xec64c8e7u, 0xd52b86b5u, 0x3e11c014u, 0x57eaf2c3u, 0xd3cebf9fu}} +, .sourceIx = ty_w64 +, .targetIx = ty_pbw32 +, .cost = 92 /* milli weight units */ +} +,[ADD_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_add_64 +, .cmr = {{0xbe2b7519u, 0x303a67eeu, 0xa6b48295u, 0x0eda8343u, 0x5e1de855u, 0x9c394a23u, 0x6222ff5bu, 0xf089d346u}} +, .sourceIx = ty_w128 +, .targetIx = ty_pbw64 +, .cost = 105 /* milli weight units */ +} +,[ADD_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_add_8 +, .cmr = {{0xdfa179adu, 0xf4550b28u, 0x4873bf30u, 0x123e0d4eu, 0x54069b08u, 0x5834ce56u, 0x5815ef7eu, 0x45784acbu}} +, .sourceIx = ty_w16 +, .targetIx = ty_pbw8 +, .cost = 97 /* milli weight units */ +} +,[ALL_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_all_16 +, .cmr = {{0x24f482a5u, 0x13d33362u, 0x015d28dfu, 0x4bb6c3eeu, 0x08ab8afbu, 0xbd25571fu, 0x0ea89d8cu, 0xaba31404u}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 60 /* milli weight units */ +} +,[ALL_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_all_32 +, .cmr = {{0xa716522du, 0x0f3787c8u, 0xb4d50764u, 0x7f1f807bu, 0x67f320d6u, 0xeb67b84bu, 0x609cec1du, 0x2f12218au}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 62 /* milli weight units */ +} +,[ALL_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_all_64 +, .cmr = {{0x7aeefe2eu, 0xce24bab3u, 0x7c6e5430u, 0xeed419fcu, 0xd5f03791u, 0x2d1770cbu, 0x7d6520dcu, 0xe525291au}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 63 /* milli weight units */ +} +,[ALL_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_all_8 +, .cmr = {{0x4637f40eu, 0x5f4726b0u, 0x0570765au, 0xc794e29eu, 0xd1bb2655u, 0xffc412b2u, 0xdc41258eu, 0x41aac624u}} +, .sourceIx = ty_w8 +, .targetIx = ty_b +, .cost = 50 /* milli weight units */ +} +,[AND_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_and_1 +, .cmr = {{0x10684d0du, 0xd72cb0a8u, 0x26a86383u, 0x4e011f50u, 0xfa0d558bu, 0xa77d6b9fu, 0x49a1ac22u, 0x902a6ad0u}} +, .sourceIx = ty_w2 +, .targetIx = ty_b +, .cost = 77 /* milli weight units */ +} +,[AND_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_and_16 +, .cmr = {{0x373c730fu, 0xad3e8847u, 0x991aa417u, 0xd9f080eeu, 0x1cb88a7fu, 0x7206f3fau, 0x840b1950u, 0x7761fb23u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 83 /* milli weight units */ +} +,[AND_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_and_32 +, .cmr = {{0x13b02c4cu, 0x60ae6ea4u, 0x91161649u, 0xacf9a47au, 0x7025af84u, 0x7d5f581eu, 0x6f1cccfbu, 0x21d3001du}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 77 /* milli weight units */ +} +,[AND_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_and_64 +, .cmr = {{0x92185535u, 0xd4505407u, 0xdea3c8a6u, 0x0826ede6u, 0x4a8fbb3du, 0xb486d56fu, 0x642d217cu, 0x29cbd795u}} +, .sourceIx = ty_w128 +, .targetIx = ty_w64 +, .cost = 78 /* milli weight units */ +} +,[AND_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_and_8 +, .cmr = {{0x269a1b44u, 0x6266f8f4u, 0xa4a38fa7u, 0xe7e39182u, 0xf1521436u, 0x142badedu, 0xf3aa63fbu, 0x2f172d2fu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w8 +, .cost = 98 /* milli weight units */ +} +,[ANNEX_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_annex_hash +, .cmr = {{0x51fa1913u, 0xa6297348u, 0x4a700af3u, 0xff932694u, 0xd3890ae0u, 0xad87a455u, 0xdaf4906fu, 0x224a48d5u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256mw256 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 1491 /* milli weight units */ +} +,[BIP_0340_VERIFY] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bip_0340_verify +, .cmr = {{0x491565feu, 0x23a7bdc1u, 0x842be749u, 0x509337f9u, 0x6890d5b3u, 0x58b36520u, 0x90da5566u, 0x54e29549u}} +, .sourceIx = ty_w1Ki +, .targetIx = ty_u +, .cost = 49421 /* milli weight units */ +} +,[BUILD_TAPBRANCH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_build_tapbranch +, .cmr = {{0xef8e9291u, 0x9b2608eau, 0x6b5bcdd3u, 0x9c5178e5u, 0x46249553u, 0x914b0f8du, 0x33735d28u, 0x86e1a5e8u}} +, .sourceIx = ty_w512 +, .targetIx = ty_w256 +, .cost = 2554 /* milli weight units */ +} +,[BUILD_TAPLEAF_SIMPLICITY] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_build_tapleaf_simplicity +, .cmr = {{0x22411909u, 0x984147deu, 0x8f5a0428u, 0x358b4716u, 0xdb087664u, 0xa7285608u, 0x52b0e616u, 0xebc62d30u}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 1927 /* milli weight units */ +} +,[BUILD_TAPTWEAK] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_build_taptweak +, .cmr = {{0xf192db17u, 0x06608defu, 0x165dbddau, 0x72a38c88u, 0x82cb36c6u, 0xda47070du, 0x8a5f5896u, 0xfbda8434u}} +, .sourceIx = ty_w512 +, .targetIx = ty_w256 +, .cost = 77780 /* milli weight units */ +} +,[CH_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_ch_1 +, .cmr = {{0x73b2a981u, 0xd721986fu, 0x8cded697u, 0xe06305d4u, 0x5854102du, 0xff20c0e5u, 0xb98ae176u, 0x232ff25bu}} +, .sourceIx = ty_pbw2 +, .targetIx = ty_b +, .cost = 50 /* milli weight units */ +} +,[CH_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_ch_16 +, .cmr = {{0x78de465eu, 0x61d9a50fu, 0x78252ff4u, 0xab23c9e6u, 0x3ae68c76u, 0x9d366612u, 0x71207dc6u, 0x93f469b4u}} +, .sourceIx = ty_pw16w32 +, .targetIx = ty_w16 +, .cost = 83 /* milli weight units */ +} +,[CH_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_ch_32 +, .cmr = {{0xed93bef1u, 0xf66e3a75u, 0xe6120602u, 0xecee6740u, 0x653e7bd4u, 0x6e07eb77u, 0x144ef1bbu, 0x2c9de53du}} +, .sourceIx = ty_pw32w64 +, .targetIx = ty_w32 +, .cost = 69 /* milli weight units */ +} +,[CH_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_ch_64 +, .cmr = {{0xced0079bu, 0x0bd1cc00u, 0x209a7cbcu, 0x23f13dfdu, 0x202808f0u, 0xf5257d8au, 0x50ac543eu, 0x64ee3a05u}} +, .sourceIx = ty_pw64w128 +, .targetIx = ty_w64 +, .cost = 78 /* milli weight units */ +} +,[CH_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_ch_8 +, .cmr = {{0xc707ca72u, 0x3e24f6b2u, 0x5bf394a9u, 0x9a4d75e8u, 0x1379b467u, 0x8438ac78u, 0x9dee188eu, 0xdcce75fau}} +, .sourceIx = ty_pw8w16 +, .targetIx = ty_w8 +, .cost = 86 /* milli weight units */ +} +,[CHECK_LOCK_DISTANCE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_check_lock_distance +, .cmr = {{0xdbaa6fedu, 0xb73b2e31u, 0xa80ccbd1u, 0x4daaa5b8u, 0xce212cdeu, 0x0cbfd96du, 0x5db9715fu, 0xd19f8899u}} +, .sourceIx = ty_w16 +, .targetIx = ty_u +, .cost = 84 /* milli weight units */ +} +,[CHECK_LOCK_DURATION] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_check_lock_duration +, .cmr = {{0xdde93f33u, 0xf9b9d1d3u, 0xa3f2b3e8u, 0xb90f6d8bu, 0xeffccb45u, 0x81210eeau, 0xf06bd32fu, 0x6319df6eu}} +, .sourceIx = ty_w16 +, .targetIx = ty_u +, .cost = 78 /* milli weight units */ +} +,[CHECK_LOCK_HEIGHT] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_check_lock_height +, .cmr = {{0xb90f151fu, 0x45b4eb37u, 0x210621f9u, 0x700a36c8u, 0xc504bee0u, 0x67771163u, 0xa8b83a77u, 0x18e6686au}} +, .sourceIx = ty_w32 +, .targetIx = ty_u +, .cost = 108 /* milli weight units */ +} +,[CHECK_LOCK_TIME] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_check_lock_time +, .cmr = {{0xa451ebb2u, 0x25d6b133u, 0xa5e63539u, 0x7800d487u, 0xb3968b0du, 0xe55c96ebu, 0x82f290ecu, 0xff9c2590u}} +, .sourceIx = ty_w32 +, .targetIx = ty_u +, .cost = 123 /* milli weight units */ +} +,[CHECK_SIG_VERIFY] = +{ .tag = JET +, .jet = rustsimplicity_0_6_check_sig_verify +, .cmr = {{0xb5801554u, 0x6d285266u, 0x5dd21bf1u, 0x12662670u, 0x20fa5e27u, 0x5001dd46u, 0x18fa4156u, 0x25952e68u}} +, .sourceIx = ty_ppw256w512w512 +, .targetIx = ty_u +, .cost = 50000 /* milli weight units */ +} +,[COMPLEMENT_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_complement_1 +, .cmr = {{0x1bcfae13u, 0xd5d237a0u, 0xbb9b1d75u, 0x32047462u, 0xb27690deu, 0x5cac0e20u, 0x19298964u, 0x57934060u}} +, .sourceIx = ty_b +, .targetIx = ty_b +, .cost = 51 /* milli weight units */ +} +,[COMPLEMENT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_complement_16 +, .cmr = {{0x81ad4d2cu, 0x3d16bf34u, 0x0af3886du, 0x355cc5bdu, 0x1d5967e1u, 0x6ace924fu, 0x19ecf7d4u, 0x86d6c7e9u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w16 +, .cost = 86 /* milli weight units */ +} +,[COMPLEMENT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_complement_32 +, .cmr = {{0x13742c18u, 0x04a96e6cu, 0x039528bfu, 0xd03b8cf2u, 0xb462526bu, 0xb181a3d8u, 0xb432f99au, 0xc4f5a7efu}} +, .sourceIx = ty_w32 +, .targetIx = ty_w32 +, .cost = 58 /* milli weight units */ +} +,[COMPLEMENT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_complement_64 +, .cmr = {{0x65b7bd09u, 0x3639c56du, 0xa285cefau, 0x2d046464u, 0x5e14dd13u, 0x642f3495u, 0x7d4737bdu, 0x52fac588u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w64 +, .cost = 64 /* milli weight units */ +} +,[COMPLEMENT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_complement_8 +, .cmr = {{0x954b70dcu, 0xec539e6bu, 0x67dffec5u, 0x3cf24a66u, 0x9939608bu, 0x223f5f8bu, 0x6d129daau, 0x48ca1cf0u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w8 +, .cost = 62 /* milli weight units */ +} +,[CURRENT_ANNEX_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_current_annex_hash +, .cmr = {{0xced9022eu, 0xdc69241fu, 0xe70749a7u, 0xf5d489c3u, 0x135ee8c9u, 0x6fe64c44u, 0x64401f98u, 0x51d7a17du}} +, .sourceIx = ty_u +, .targetIx = ty_mw256 +, .cost = 74 /* milli weight units */ +} +,[CURRENT_INDEX] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_current_index +, .cmr = {{0x0e8c964cu, 0x2f2b3490u, 0x362f3bbcu, 0x7483dea3u, 0x7fda810bu, 0x69314ff6u, 0x64fea0e3u, 0x2708ec8fu}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 66 /* milli weight units */ +} +,[CURRENT_PREV_OUTPOINT] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_current_prev_outpoint +, .cmr = {{0x6443391bu, 0x34408684u, 0x6d5a17a6u, 0x2e3e0628u, 0x2ad6962cu, 0x4dfced2fu, 0x6a83d0dfu, 0xbf6a5c54u}} +, .sourceIx = ty_u +, .targetIx = ty_pw256w32 +, .cost = 130 /* milli weight units */ +} +,[CURRENT_SCRIPT_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_current_script_hash +, .cmr = {{0x23498dd6u, 0x645ed138u, 0xb344937cu, 0xf654aaffu, 0xa627f85au, 0x47caa689u, 0x54f13f4cu, 0x6a4dc772u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 127 /* milli weight units */ +} +,[CURRENT_SCRIPT_SIG_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_current_script_sig_hash +, .cmr = {{0x34a3c55du, 0x147374d8u, 0xf3a1761bu, 0xbab28696u, 0x8455404cu, 0x2ca03f69u, 0x393f6339u, 0xd0f58b59u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 126 /* milli weight units */ +} +,[CURRENT_SEQUENCE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_current_sequence +, .cmr = {{0xc49f76acu, 0x79f8f15cu, 0x409ba815u, 0xc16edcb8u, 0xd11e9a07u, 0x565c8e09u, 0xb63e7fdfu, 0x3103009fu}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 66 /* milli weight units */ +} +,[CURRENT_VALUE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_current_value +, .cmr = {{0x91b96e82u, 0x9e3b4972u, 0xb0cb091au, 0x0a904ba4u, 0x11338abfu, 0xc08da786u, 0xd5a84f04u, 0x9b5ba3b8u}} +, .sourceIx = ty_u +, .targetIx = ty_w64 +, .cost = 85 /* milli weight units */ +} +,[DECOMPRESS] = +{ .tag = JET +, .jet = rustsimplicity_0_6_decompress +, .cmr = {{0x890056dfu, 0x828a766eu, 0xe9f65607u, 0x221e8946u, 0xfa77c256u, 0xbb96e231u, 0xe194d300u, 0x8cf356f6u}} +, .sourceIx = ty_pbw256 +, .targetIx = ty_mw512 +, .cost = 10495 /* milli weight units */ +} +,[DECREMENT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_decrement_16 +, .cmr = {{0x35fda38bu, 0x672c3831u, 0xd8ca11a4u, 0xf3a95962u, 0x22529eb1u, 0xc15f8c70u, 0x5013977du, 0x7dfb5d8bu}} +, .sourceIx = ty_w16 +, .targetIx = ty_pbw16 +, .cost = 58 /* milli weight units */ +} +,[DECREMENT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_decrement_32 +, .cmr = {{0x3b2b1939u, 0x552284f6u, 0x14694ba1u, 0x8dce70ceu, 0xe476ff42u, 0xdcd089e1u, 0xa3c0a42bu, 0xebd108f6u}} +, .sourceIx = ty_w32 +, .targetIx = ty_pbw32 +, .cost = 57 /* milli weight units */ +} +,[DECREMENT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_decrement_64 +, .cmr = {{0x7ef7bdd3u, 0x5db685aeu, 0x99055337u, 0x35a2c7a7u, 0xccbc1708u, 0xae636f93u, 0x1b5ce026u, 0xe5a17fedu}} +, .sourceIx = ty_w64 +, .targetIx = ty_pbw64 +, .cost = 79 /* milli weight units */ +} +,[DECREMENT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_decrement_8 +, .cmr = {{0xe364f2e5u, 0xc08ae011u, 0x8ebe993eu, 0x8b3c958cu, 0x2bcc6062u, 0xa33baab9u, 0x28c04b3eu, 0xc932f51bu}} +, .sourceIx = ty_w8 +, .targetIx = ty_pbw8 +, .cost = 77 /* milli weight units */ +} +,[DIV_MOD_128_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_div_mod_128_64 +, .cmr = {{0x9a9443a2u, 0xb541e29fu, 0x272ffd56u, 0x7d1bf742u, 0xd68ccbe9u, 0x538a8729u, 0x1b0ca638u, 0x1563ac2cu}} +, .sourceIx = ty_pw128w64 +, .targetIx = ty_w128 +, .cost = 169 /* milli weight units */ +} +,[DIV_MOD_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_div_mod_16 +, .cmr = {{0x39bcb5c0u, 0x1dc1805cu, 0x4919895cu, 0xb59e8f3bu, 0x41446717u, 0xf7ff48fdu, 0xc937dd03u, 0x8024a08au}} +, .sourceIx = ty_w32 +, .targetIx = ty_w32 +, .cost = 92 /* milli weight units */ +} +,[DIV_MOD_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_div_mod_32 +, .cmr = {{0xfb1202f4u, 0xe8663a87u, 0xf568992au, 0x185024c7u, 0x0b4f079fu, 0xbe953001u, 0x0f6db284u, 0x218af6cdu}} +, .sourceIx = ty_w64 +, .targetIx = ty_w64 +, .cost = 90 /* milli weight units */ +} +,[DIV_MOD_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_div_mod_64 +, .cmr = {{0x6764df5eu, 0x2aa03032u, 0x6ee544c6u, 0xe53ff38eu, 0xf0b28517u, 0x915eec65u, 0xc72ea57au, 0x129828ebu}} +, .sourceIx = ty_w128 +, .targetIx = ty_w128 +, .cost = 82 /* milli weight units */ +} +,[DIV_MOD_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_div_mod_8 +, .cmr = {{0xd300244eu, 0x480dd974u, 0x1213e4cbu, 0x0eba836du, 0x3059e778u, 0xb8122f78u, 0x90032673u, 0x739c6a2cu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w16 +, .cost = 91 /* milli weight units */ +} +,[DIVIDE_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_divide_16 +, .cmr = {{0x52abfef1u, 0x79754c90u, 0xf9a4260fu, 0x323a8ca4u, 0x95159290u, 0x2b8ecbd6u, 0x4ba42656u, 0xfac05968u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 85 /* milli weight units */ +} +,[DIVIDE_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_divide_32 +, .cmr = {{0x4a8ae535u, 0x44e147edu, 0x02250423u, 0x7934cc25u, 0x4479bcf9u, 0x3de1e197u, 0x4ddab3bbu, 0x516e606cu}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 82 /* milli weight units */ +} +,[DIVIDE_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_divide_64 +, .cmr = {{0xd7025d05u, 0xadfae66bu, 0x4710d0ffu, 0x1e87e828u, 0x15573e9cu, 0xb631b4c7u, 0xd13d2f1bu, 0xe4dd26d2u}} +, .sourceIx = ty_w128 +, .targetIx = ty_w64 +, .cost = 81 /* milli weight units */ +} +,[DIVIDE_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_divide_8 +, .cmr = {{0x40cd1dacu, 0xea24669bu, 0x6a589b61u, 0x475474afu, 0x31d14f8du, 0x46877084u, 0x52d3df37u, 0x30253126u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w8 +, .cost = 85 /* milli weight units */ +} +,[DIVIDES_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_divides_16 +, .cmr = {{0x10bb1818u, 0x0eab5badu, 0xdc165d03u, 0x37c4ada0u, 0x88e157b1u, 0xaa678334u, 0x2a4520a3u, 0x24dd9d2bu}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 84 /* milli weight units */ +} +,[DIVIDES_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_divides_32 +, .cmr = {{0xf5e8e78cu, 0x82769a48u, 0xc9103e44u, 0xddb47f84u, 0x1d7693b0u, 0x419e5e7du, 0xa4e68b78u, 0xb237a572u}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 80 /* milli weight units */ +} +,[DIVIDES_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_divides_64 +, .cmr = {{0x9ebd55fau, 0xe418885eu, 0xea04c3cdu, 0xfff531b7u, 0xd714d059u, 0x4fa7da87u, 0xeb6555d3u, 0x6b953db2u}} +, .sourceIx = ty_w128 +, .targetIx = ty_b +, .cost = 67 /* milli weight units */ +} +,[DIVIDES_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_divides_8 +, .cmr = {{0xa236bc3eu, 0x5cf4d256u, 0x408ba38cu, 0x1eaee736u, 0x9a9c402fu, 0x74bcd1c8u, 0x02f9094fu, 0xbf36803du}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 73 /* milli weight units */ +} +,[EQ_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_eq_1 +, .cmr = {{0x6549f986u, 0x203a6497u, 0x356e432bu, 0x2aa160d6u, 0xee870b11u, 0x190865bdu, 0x36a47cb0u, 0x470433a5u}} +, .sourceIx = ty_w2 +, .targetIx = ty_b +, .cost = 63 /* milli weight units */ +} +,[EQ_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_eq_16 +, .cmr = {{0x0c5402b0u, 0xadc8fc65u, 0x701bb75bu, 0x3254c835u, 0xf8fec130u, 0x81cd35e1u, 0x328f2bd7u, 0xdbd23fa6u}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 68 /* milli weight units */ +} +,[EQ_256] = +{ .tag = JET +, .jet = rustsimplicity_0_6_eq_256 +, .cmr = {{0x260e1d13u, 0x6dd744fcu, 0xb0507a2du, 0x277027a7u, 0x724354ebu, 0x176b2fbfu, 0x31c6c7d7u, 0xfb3ecd6fu}} +, .sourceIx = ty_w512 +, .targetIx = ty_b +, .cost = 188 /* milli weight units */ +} +,[EQ_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_eq_32 +, .cmr = {{0xf5d6edc8u, 0xb6164e12u, 0x5bbbef08u, 0xc9e08a1eu, 0x6fd492f5u, 0xbdca6fdcu, 0x8b5f5a6fu, 0x05c5ab96u}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 74 /* milli weight units */ +} +,[EQ_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_eq_64 +, .cmr = {{0x1f93acb8u, 0x092fa06du, 0xeaf3c387u, 0xf54a18ffu, 0xeaa69a47u, 0xa6f5caf4u, 0xae497e5cu, 0xc2b36c43u}} +, .sourceIx = ty_w128 +, .targetIx = ty_b +, .cost = 82 /* milli weight units */ +} +,[EQ_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_eq_8 +, .cmr = {{0xd752fa7fu, 0x51473014u, 0xebb69e1eu, 0x1d2c86d5u, 0x1148b6bau, 0xa02137a4u, 0x8f62d57eu, 0xaf8df1cdu}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 76 /* milli weight units */ +} +,[FE_ADD] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_add +, .cmr = {{0xa6c90e02u, 0xfde4ee6eu, 0xef666737u, 0x492e14afu, 0xc8762504u, 0x974af5d5u, 0x472bb943u, 0x3ad2d294u}} +, .sourceIx = ty_w512 +, .targetIx = ty_w256 +, .cost = 777 /* milli weight units */ +} +,[FE_INVERT] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_invert +, .cmr = {{0x7c4abaceu, 0x33c72b3bu, 0xe1fd0ee3u, 0x9fc6cb3eu, 0xe5c8f11eu, 0xf21998c0u, 0x602b5215u, 0xaa2a75c2u}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 3237 /* milli weight units */ +} +,[FE_IS_ODD] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_is_odd +, .cmr = {{0x30f5171fu, 0x58f1089du, 0x5dcfb6e6u, 0x683f5adeu, 0x984c0799u, 0x763ca738u, 0x3f75df1cu, 0xa0813efeu}} +, .sourceIx = ty_w256 +, .targetIx = ty_b +, .cost = 313 /* milli weight units */ +} +,[FE_IS_ZERO] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_is_zero +, .cmr = {{0xb0b74d86u, 0x51ff557cu, 0xa96044ddu, 0x97281338u, 0xa8f7d3acu, 0xb3847d03u, 0xacbf3d32u, 0xd96fae55u}} +, .sourceIx = ty_w256 +, .targetIx = ty_b +, .cost = 277 /* milli weight units */ +} +,[FE_MULTIPLY] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_multiply +, .cmr = {{0x506b9319u, 0xc17a14a9u, 0x469d4627u, 0x61a3303au, 0xb47ddb3au, 0x3079fba3u, 0x4073aa55u, 0x4216a388u}} +, .sourceIx = ty_w512 +, .targetIx = ty_w256 +, .cost = 813 /* milli weight units */ +} +,[FE_MULTIPLY_BETA] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_multiply_beta +, .cmr = {{0x6e180eeau, 0xbe8422b7u, 0x9968e711u, 0xdd00a4b6u, 0x578bb275u, 0xbef47fe5u, 0xff968f14u, 0x72d76f2au}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 607 /* milli weight units */ +} +,[FE_NEGATE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_negate +, .cmr = {{0xd437ea00u, 0x339880b3u, 0x83d85fb2u, 0xaeaf201bu, 0xbe8ffc83u, 0x705062f9u, 0xc968590du, 0x5db337f6u}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 541 /* milli weight units */ +} +,[FE_NORMALIZE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_normalize +, .cmr = {{0xec0c3dd9u, 0xc5286364u, 0x78bec0e1u, 0x60e50ad9u, 0xbf452c5bu, 0x6f84e940u, 0xe16584ebu, 0x085ace38u}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 656 /* milli weight units */ +} +,[FE_SQUARE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_square +, .cmr = {{0xb904772du, 0x74a185b8u, 0x28eb1547u, 0x28d249c5u, 0x084711e9u, 0xa1832b89u, 0xcaf2af59u, 0xf960e118u}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 570 /* milli weight units */ +} +,[FE_SQUARE_ROOT] = +{ .tag = JET +, .jet = rustsimplicity_0_6_fe_square_root +, .cmr = {{0x16fb9aceu, 0xbe8b5b87u, 0xf2ea7db6u, 0xaa3a2af8u, 0x8ca2b58fu, 0x02cdc87eu, 0x7ce6be0cu, 0x1ffce014u}} +, .sourceIx = ty_w256 +, .targetIx = ty_mw256 +, .cost = 10162 /* milli weight units */ +} +,[FEE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_fee +, .cmr = {{0xfb9ca939u, 0x81673d1du, 0x23aed24du, 0x612c1f5du, 0xc7cd49f8u, 0x6d348e67u, 0xa15bc4a7u, 0x130ae185u}} +, .sourceIx = ty_u +, .targetIx = ty_w64 +, .cost = 65 /* milli weight units */ +} +,[FULL_ADD_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_add_16 +, .cmr = {{0xc503b078u, 0xdde399c6u, 0x3ac4a232u, 0xbd2a329bu, 0x04308c75u, 0xeaec53a2u, 0xf889b8dfu, 0x0d033472u}} +, .sourceIx = ty_pbw32 +, .targetIx = ty_pbw16 +, .cost = 106 /* milli weight units */ +} +,[FULL_ADD_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_add_32 +, .cmr = {{0xa7afd040u, 0xfcb0b2f2u, 0x7190781au, 0xe53a6ccau, 0x00e9fe59u, 0x531115c2u, 0x58ccb69du, 0x3be5a213u}} +, .sourceIx = ty_pbw64 +, .targetIx = ty_pbw32 +, .cost = 96 /* milli weight units */ +} +,[FULL_ADD_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_add_64 +, .cmr = {{0x80a3ef6cu, 0xdb84ae7cu, 0x8dbcf3a1u, 0x842484c0u, 0x98df6f19u, 0x427a5a4au, 0xdfe76cd5u, 0xff2836cau}} +, .sourceIx = ty_pbw128 +, .targetIx = ty_pbw64 +, .cost = 93 /* milli weight units */ +} +,[FULL_ADD_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_add_8 +, .cmr = {{0x4b9076b8u, 0xc1ad56c9u, 0xdb6bb3bau, 0xf5938954u, 0x46ce61c7u, 0x4f797eb8u, 0xb230d205u, 0x421c9617u}} +, .sourceIx = ty_pbw16 +, .targetIx = ty_pbw8 +, .cost = 131 /* milli weight units */ +} +,[FULL_DECREMENT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_decrement_16 +, .cmr = {{0xfba3c978u, 0x6ea307f6u, 0xd85434fdu, 0xa2562482u, 0x43a00bacu, 0x9a5353b6u, 0x1ed39c60u, 0x55b693b0u}} +, .sourceIx = ty_pbw16 +, .targetIx = ty_pbw16 +, .cost = 60 /* milli weight units */ +} +,[FULL_DECREMENT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_decrement_32 +, .cmr = {{0x623d21d0u, 0x467922c0u, 0x01c56568u, 0x61d0ddb8u, 0x60c0c9a8u, 0x6bd4cfdcu, 0x37a14c14u, 0x06e3446eu}} +, .sourceIx = ty_pbw32 +, .targetIx = ty_pbw32 +, .cost = 71 /* milli weight units */ +} +,[FULL_DECREMENT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_decrement_64 +, .cmr = {{0x148b3ee1u, 0xf749ea0bu, 0xfba763beu, 0xe999a296u, 0x77456eaeu, 0x9ef53ad8u, 0x78f8b614u, 0x94f08f00u}} +, .sourceIx = ty_pbw64 +, .targetIx = ty_pbw64 +, .cost = 71 /* milli weight units */ +} +,[FULL_DECREMENT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_decrement_8 +, .cmr = {{0xb41afe97u, 0x4eaa1182u, 0xac461052u, 0x1e282781u, 0x318ce295u, 0xa3f23f0bu, 0x876ae269u, 0x673fb1dfu}} +, .sourceIx = ty_pbw8 +, .targetIx = ty_pbw8 +, .cost = 68 /* milli weight units */ +} +,[FULL_INCREMENT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_increment_16 +, .cmr = {{0xa68eccdbu, 0x9ead2926u, 0xc3e45b4bu, 0xae431cc4u, 0x66d58b8fu, 0xacc95a1bu, 0x4844b912u, 0xdf5676dfu}} +, .sourceIx = ty_pbw16 +, .targetIx = ty_pbw16 +, .cost = 70 /* milli weight units */ +} +,[FULL_INCREMENT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_increment_32 +, .cmr = {{0xd0eb0e94u, 0xa5c25713u, 0xeb944cadu, 0x4d701c6au, 0x968809bcu, 0x1af903fdu, 0xb11e6fadu, 0x0bb31b10u}} +, .sourceIx = ty_pbw32 +, .targetIx = ty_pbw32 +, .cost = 57 /* milli weight units */ +} +,[FULL_INCREMENT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_increment_64 +, .cmr = {{0xc003d2e9u, 0xb0a510c2u, 0xdd783e7du, 0x64eb87b3u, 0x3855d329u, 0x90dfc286u, 0x266e478du, 0xa4e74791u}} +, .sourceIx = ty_pbw64 +, .targetIx = ty_pbw64 +, .cost = 68 /* milli weight units */ +} +,[FULL_INCREMENT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_increment_8 +, .cmr = {{0x0bea2429u, 0x18f2dd17u, 0x64777811u, 0xe4442863u, 0x935225b0u, 0xf8b239c2u, 0x3752f9d8u, 0x5392a139u}} +, .sourceIx = ty_pbw8 +, .targetIx = ty_pbw8 +, .cost = 73 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_16_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_16_1 +, .cmr = {{0xb366a816u, 0x922fc455u, 0x010fe88au, 0x5f6a5cf2u, 0xcea917e1u, 0x2bd140aeu, 0x6d43b641u, 0xe57f42b3u}} +, .sourceIx = ty_pw16b +, .targetIx = ty_pbw16 +, .cost = 76 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_16_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_16_2 +, .cmr = {{0x27960d0du, 0xf2fbbc38u, 0x993d86fbu, 0x8f0cd2c3u, 0x434edb11u, 0x048213c1u, 0x411893cau, 0x9933b2eeu}} +, .sourceIx = ty_pw16w2 +, .targetIx = ty_pw2w16 +, .cost = 59 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_16_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_16_4 +, .cmr = {{0x655137beu, 0xc5c0368fu, 0x29bc992cu, 0x88421a15u, 0x98564039u, 0x7b617fc4u, 0x8d33210fu, 0xc0053ad1u}} +, .sourceIx = ty_pw16w4 +, .targetIx = ty_pw4w16 +, .cost = 68 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_16_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_16_8 +, .cmr = {{0x168f576au, 0xa56ea47eu, 0x070646e7u, 0x8896beb2u, 0x498b1ae6u, 0xb1ff9c78u, 0x6270e955u, 0x65841929u}} +, .sourceIx = ty_pw16w8 +, .targetIx = ty_pw8w16 +, .cost = 68 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_32_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_32_1 +, .cmr = {{0xd7cd5224u, 0x49118e81u, 0x00a7662fu, 0x4df039f8u, 0xcaebf433u, 0xeb039edcu, 0x42e88237u, 0x92ccea8au}} +, .sourceIx = ty_pw32b +, .targetIx = ty_pbw32 +, .cost = 58 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_32_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_32_16 +, .cmr = {{0x8bd80d4du, 0x2f8b2246u, 0xc12315c4u, 0x2841b4e4u, 0x0a71ae76u, 0x966a0895u, 0x4d666b86u, 0x32867437u}} +, .sourceIx = ty_pw32w16 +, .targetIx = ty_pw16w32 +, .cost = 52 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_32_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_32_2 +, .cmr = {{0x13063d62u, 0x93832931u, 0x1fb7dabbu, 0x15c3fe58u, 0xc2887683u, 0x0097ecc6u, 0xbfdd480bu, 0xe1988146u}} +, .sourceIx = ty_pw32w2 +, .targetIx = ty_pw2w32 +, .cost = 73 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_32_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_32_4 +, .cmr = {{0x25a1b5ddu, 0xe5db284eu, 0x8a882126u, 0x7c265301u, 0x14bbe671u, 0xcfafb44au, 0x60d75027u, 0x67db782eu}} +, .sourceIx = ty_pw32w4 +, .targetIx = ty_pw4w32 +, .cost = 59 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_32_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_32_8 +, .cmr = {{0xce5470afu, 0xbfadbfbau, 0x68f9b2d5u, 0xb0645a44u, 0x08be6f85u, 0xa69c7f09u, 0xd0964553u, 0x68048764u}} +, .sourceIx = ty_pw32w8 +, .targetIx = ty_pw8w32 +, .cost = 60 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_64_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_64_1 +, .cmr = {{0x051f3605u, 0x86c379acu, 0x2ce399cbu, 0xeb687e77u, 0x53b15d73u, 0x03dd316cu, 0xbd123012u, 0x087cc66fu}} +, .sourceIx = ty_pw64b +, .targetIx = ty_pbw64 +, .cost = 74 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_64_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_64_16 +, .cmr = {{0xb248be4du, 0xfcb88c5du, 0x89b1ca61u, 0x86a041e9u, 0x02b4c8a6u, 0x2bb16e09u, 0xfe15616eu, 0x0e3abd6du}} +, .sourceIx = ty_pw64w16 +, .targetIx = ty_pw16w64 +, .cost = 69 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_64_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_64_2 +, .cmr = {{0x34bb5162u, 0x6b1d6b89u, 0x7abc155du, 0x034fe066u, 0x3a0ec0fdu, 0x8f640e5fu, 0xe1bf3cb7u, 0x670a2925u}} +, .sourceIx = ty_pw64w2 +, .targetIx = ty_pw2w64 +, .cost = 70 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_64_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_64_32 +, .cmr = {{0x9dac8cd7u, 0xfd8b4888u, 0x9e55c5aau, 0x12fe97b7u, 0x29febc04u, 0x1a9fff44u, 0xc4d9b6f1u, 0xe07eb442u}} +, .sourceIx = ty_pw64w32 +, .targetIx = ty_pw32w64 +, .cost = 73 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_64_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_64_4 +, .cmr = {{0x94b73dadu, 0xc3eeeb2eu, 0xe4a4d444u, 0xdd0f72acu, 0x306201f2u, 0xffcf714bu, 0x8ebe7982u, 0x744c0c7eu}} +, .sourceIx = ty_pw64w4 +, .targetIx = ty_pw4w64 +, .cost = 66 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_64_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_64_8 +, .cmr = {{0x0ef71475u, 0x7ecf11cau, 0x3c73ce25u, 0xef24ee72u, 0x95dd4171u, 0xcc16287fu, 0xe6971bd6u, 0x7b478b46u}} +, .sourceIx = ty_pw64w8 +, .targetIx = ty_pw8w64 +, .cost = 68 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_8_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_8_1 +, .cmr = {{0x9bfa48b7u, 0xad510091u, 0xba608544u, 0x62d859efu, 0xd1a2aa18u, 0x731b5f0cu, 0x9e2ba4d8u, 0x9d3aa843u}} +, .sourceIx = ty_pw8b +, .targetIx = ty_pbw8 +, .cost = 60 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_8_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_8_2 +, .cmr = {{0x797c2087u, 0x01b2a4e1u, 0x049e83d6u, 0x95f554b9u, 0x84f5db28u, 0x21525558u, 0x7c373421u, 0x51b7241du}} +, .sourceIx = ty_pw8w2 +, .targetIx = ty_pw2w8 +, .cost = 64 /* milli weight units */ +} +,[FULL_LEFT_SHIFT_8_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_left_shift_8_4 +, .cmr = {{0x37bdac91u, 0x538f2219u, 0xcb89df0eu, 0xf9f197cdu, 0x68031f27u, 0x67e894f0u, 0x01c26fffu, 0x5eeb58cdu}} +, .sourceIx = ty_pw8w4 +, .targetIx = ty_pw4w8 +, .cost = 72 /* milli weight units */ +} +,[FULL_MULTIPLY_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_multiply_16 +, .cmr = {{0x09baff92u, 0x1e9f14d1u, 0x208d1dd8u, 0x264cf1f3u, 0xb854c9afu, 0x21f778b2u, 0xb55a8a42u, 0x6dfe8928u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 99 /* milli weight units */ +} +,[FULL_MULTIPLY_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_multiply_32 +, .cmr = {{0x10c4b8c4u, 0xc0acd973u, 0x90f85cb3u, 0xf5ffe36au, 0x292037c1u, 0x90eebab3u, 0xe98934feu, 0x93b2ed90u}} +, .sourceIx = ty_w128 +, .targetIx = ty_w64 +, .cost = 87 /* milli weight units */ +} +,[FULL_MULTIPLY_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_multiply_64 +, .cmr = {{0x2db19dbau, 0x90ef867bu, 0x5a3e914bu, 0x89fda2dau, 0x637ca80cu, 0x4267e198u, 0x1837ee3cu, 0x6fe3daf5u}} +, .sourceIx = ty_w256 +, .targetIx = ty_w128 +, .cost = 103 /* milli weight units */ +} +,[FULL_MULTIPLY_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_multiply_8 +, .cmr = {{0x7f46ee72u, 0x84f39e73u, 0x4275a250u, 0x9a0b737eu, 0xd939115fu, 0x0219a574u, 0xd469cd30u, 0xb819efe3u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 95 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_16_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_16_1 +, .cmr = {{0x7ebe0c66u, 0xc3c7dc16u, 0xa5469e91u, 0x79098417u, 0xac5f20a3u, 0x9cc41ac3u, 0x82fb1dbdu, 0x98e8e30fu}} +, .sourceIx = ty_pbw16 +, .targetIx = ty_pw16b +, .cost = 55 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_16_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_16_2 +, .cmr = {{0x8db0c216u, 0x19c62d63u, 0xd4c27bfcu, 0xf647d709u, 0xce37bed0u, 0x5718e93eu, 0x4515e29eu, 0xf3730cf4u}} +, .sourceIx = ty_pw2w16 +, .targetIx = ty_pw16w2 +, .cost = 60 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_16_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_16_4 +, .cmr = {{0x5c74b132u, 0x06317917u, 0xe070e5fcu, 0x1c82f4c5u, 0xc2fbe9f3u, 0x1b812946u, 0xba230d8cu, 0x94d40616u}} +, .sourceIx = ty_pw4w16 +, .targetIx = ty_pw16w4 +, .cost = 64 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_16_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_16_8 +, .cmr = {{0x1105818au, 0xc948d7bbu, 0x634707e6u, 0x9dbf1f67u, 0x9058a13du, 0x35fac2a6u, 0x4df97262u, 0xf242b63bu}} +, .sourceIx = ty_pw8w16 +, .targetIx = ty_pw16w8 +, .cost = 55 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_32_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_32_1 +, .cmr = {{0x9b42c8f3u, 0x3bc5750eu, 0x2a83aadbu, 0xf29cc7fcu, 0xb950fe5au, 0x40aa0ec5u, 0x2452e533u, 0xf825a115u}} +, .sourceIx = ty_pbw32 +, .targetIx = ty_pw32b +, .cost = 49 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_32_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_32_16 +, .cmr = {{0x0ae5659cu, 0x2fa75794u, 0x78ebd57cu, 0x4c98aee7u, 0x77015645u, 0xb2843181u, 0x64fcbd30u, 0x65fc873cu}} +, .sourceIx = ty_pw16w32 +, .targetIx = ty_pw32w16 +, .cost = 48 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_32_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_32_2 +, .cmr = {{0x57fb1c03u, 0xc2eb17f6u, 0x23478734u, 0xfd6937f9u, 0xe3ef027cu, 0x1560038fu, 0xa6066905u, 0x1789e368u}} +, .sourceIx = ty_pw2w32 +, .targetIx = ty_pw32w2 +, .cost = 66 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_32_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_32_4 +, .cmr = {{0x8582cdfau, 0x74ef466bu, 0x8127b197u, 0x88134593u, 0x998e4969u, 0x00b38f0fu, 0x3d375818u, 0xd673451eu}} +, .sourceIx = ty_pw4w32 +, .targetIx = ty_pw32w4 +, .cost = 49 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_32_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_32_8 +, .cmr = {{0xd905932eu, 0xbfca2a38u, 0x619d807eu, 0x28ff2e0du, 0x3be08a26u, 0x0676d257u, 0xefa040c3u, 0x05aadc33u}} +, .sourceIx = ty_pw8w32 +, .targetIx = ty_pw32w8 +, .cost = 66 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_64_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_64_1 +, .cmr = {{0x3c15209bu, 0x99d2845eu, 0x225e14e1u, 0xe9e5e6a4u, 0x878bc8ceu, 0xa3f9f36bu, 0x8b535ac6u, 0x83e29d00u}} +, .sourceIx = ty_pbw64 +, .targetIx = ty_pw64b +, .cost = 60 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_64_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_64_16 +, .cmr = {{0x0285257bu, 0x090d8da1u, 0x28ef64a8u, 0x0c8d16fdu, 0xc3bf5ce5u, 0x0fcd56feu, 0xc5f90255u, 0xd9c8df47u}} +, .sourceIx = ty_pw16w64 +, .targetIx = ty_pw64w16 +, .cost = 73 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_64_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_64_2 +, .cmr = {{0x7ec2dd65u, 0xc9e013e3u, 0xe4ce90fbu, 0xeb3fb1c7u, 0x8ccc5d2au, 0x7d26d8afu, 0x77f99de8u, 0x4cf72973u}} +, .sourceIx = ty_pw2w64 +, .targetIx = ty_pw64w2 +, .cost = 76 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_64_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_64_32 +, .cmr = {{0x356f7dd4u, 0x6ba33f84u, 0xb06672fdu, 0xe9a2972eu, 0x80f3ea96u, 0x5ae8bc0bu, 0xff67aa2fu, 0x69f10b56u}} +, .sourceIx = ty_pw32w64 +, .targetIx = ty_pw64w32 +, .cost = 73 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_64_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_64_4 +, .cmr = {{0x05464a33u, 0x35afbb09u, 0xd046828au, 0x922c4da0u, 0xeceeb109u, 0x77e46801u, 0xc93cdd66u, 0x8f22ee63u}} +, .sourceIx = ty_pw4w64 +, .targetIx = ty_pw64w4 +, .cost = 56 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_64_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_64_8 +, .cmr = {{0x70172e1au, 0x6948bf40u, 0x120e68fbu, 0x8b4b23bcu, 0x355a1200u, 0x2ccc1db6u, 0x47c89b12u, 0xd10ec506u}} +, .sourceIx = ty_pw8w64 +, .targetIx = ty_pw64w8 +, .cost = 68 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_8_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_8_1 +, .cmr = {{0x5669dbfcu, 0xc633ec0bu, 0xdf59e22fu, 0x03ed4b64u, 0x192095f5u, 0xdf20ffc1u, 0x2dd90d7cu, 0xda11374fu}} +, .sourceIx = ty_pbw8 +, .targetIx = ty_pw8b +, .cost = 59 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_8_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_8_2 +, .cmr = {{0x1f944361u, 0x09df52b3u, 0x45fa3a89u, 0xac2a49edu, 0xc9d285f2u, 0x1f45ed11u, 0xd775f7f7u, 0xf39d3e8fu}} +, .sourceIx = ty_pw2w8 +, .targetIx = ty_pw8w2 +, .cost = 49 /* milli weight units */ +} +,[FULL_RIGHT_SHIFT_8_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_right_shift_8_4 +, .cmr = {{0x714698a2u, 0x7684b5bau, 0xa6b6480eu, 0xe3b257cbu, 0xb7cdab74u, 0x72f371a6u, 0x270618c0u, 0xab12908bu}} +, .sourceIx = ty_pw4w8 +, .targetIx = ty_pw8w4 +, .cost = 51 /* milli weight units */ +} +,[FULL_SUBTRACT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_subtract_16 +, .cmr = {{0x40096152u, 0xb54e7425u, 0x4555a65du, 0xccc629dfu, 0x57b979c8u, 0x47005450u, 0x36fe190au, 0x6af3d38au}} +, .sourceIx = ty_pbw32 +, .targetIx = ty_pbw16 +, .cost = 99 /* milli weight units */ +} +,[FULL_SUBTRACT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_subtract_32 +, .cmr = {{0xe7930d64u, 0x35a9680bu, 0xefb49db7u, 0xd87c2f50u, 0xafd46d98u, 0x880ded50u, 0xe5055fa3u, 0x09e1afcau}} +, .sourceIx = ty_pbw64 +, .targetIx = ty_pbw32 +, .cost = 92 /* milli weight units */ +} +,[FULL_SUBTRACT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_subtract_64 +, .cmr = {{0xff281df8u, 0xc42a3159u, 0xd9ffa925u, 0x16ca893eu, 0x23b0eb93u, 0x8b4cb0b3u, 0xf134468eu, 0x9f4ebc46u}} +, .sourceIx = ty_pbw128 +, .targetIx = ty_pbw64 +, .cost = 109 /* milli weight units */ +} +,[FULL_SUBTRACT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_full_subtract_8 +, .cmr = {{0x7e3dcfe4u, 0x56ae3c5cu, 0x87debf04u, 0x7189c274u, 0x82a4ff4eu, 0x8cfd1f17u, 0x30c87d2bu, 0x7bff73bau}} +, .sourceIx = ty_pbw16 +, .targetIx = ty_pbw8 +, .cost = 106 /* milli weight units */ +} +,[GE_IS_ON_CURVE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_ge_is_on_curve +, .cmr = {{0x7d448719u, 0xf5f9572bu, 0xf5402e12u, 0xd193aff6u, 0x77482d66u, 0xff3dcf27u, 0x48f25c6bu, 0x7377028cu}} +, .sourceIx = ty_w512 +, .targetIx = ty_b +, .cost = 688 /* milli weight units */ +} +,[GE_NEGATE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_ge_negate +, .cmr = {{0x3d2c8de4u, 0xc7015fd3u, 0x132695fdu, 0x66dfcf0fu, 0x1778c791u, 0x85268e9fu, 0xae7789dau, 0x538eca59u}} +, .sourceIx = ty_w512 +, .targetIx = ty_w512 +, .cost = 1071 /* milli weight units */ +} +,[GEJ_ADD] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_add +, .cmr = {{0x45ba7f3du, 0x1e1e6d34u, 0x9fcf8698u, 0x7b0e7f7au, 0xce662e82u, 0x201d3502u, 0x60454e2fu, 0xfeecb54du}} +, .sourceIx = ty_ppw512w256pw512w256 +, .targetIx = ty_pw512w256 +, .cost = 3000 /* milli weight units */ +} +,[GEJ_DOUBLE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_double +, .cmr = {{0x23e978f3u, 0x4154119bu, 0xdefc5d13u, 0xfcfd0a34u, 0xa75e3726u, 0xd6cb2581u, 0x3370ad7du, 0x9de5e133u}} +, .sourceIx = ty_pw512w256 +, .targetIx = ty_pw512w256 +, .cost = 1862 /* milli weight units */ +} +,[GEJ_EQUIV] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_equiv +, .cmr = {{0xb94b2aacu, 0x73a67f44u, 0x95859913u, 0x4de23017u, 0x9e9d6bb6u, 0x47fd0611u, 0x158aaba7u, 0x0b73e400u}} +, .sourceIx = ty_ppw512w256pw512w256 +, .targetIx = ty_b +, .cost = 2376 /* milli weight units */ +} +,[GEJ_GE_ADD] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_ge_add +, .cmr = {{0xf1160b6fu, 0x5ee2c582u, 0xe49566e6u, 0xc386b380u, 0x94abc1a7u, 0x182d33a1u, 0x501fa2aau, 0xf00af3eau}} +, .sourceIx = ty_ppw512w256w512 +, .targetIx = ty_pw512w256 +, .cost = 2609 /* milli weight units */ +} +,[GEJ_GE_ADD_EX] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_ge_add_ex +, .cmr = {{0xc3d7347fu, 0xfe2d9c83u, 0x9aac567eu, 0x2998e016u, 0xaf394e2au, 0x1929314bu, 0x52e31eedu, 0x678e30bfu}} +, .sourceIx = ty_ppw512w256w512 +, .targetIx = ty_pw256pw512w256 +, .cost = 2860 /* milli weight units */ +} +,[GEJ_GE_EQUIV] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_ge_equiv +, .cmr = {{0x27c29969u, 0x139f8d57u, 0xedc9895cu, 0x30403df0u, 0x15c50ce7u, 0x21c381fbu, 0x197c0c04u, 0x03f1db0cu}} +, .sourceIx = ty_ppw512w256w512 +, .targetIx = ty_b +, .cost = 1823 /* milli weight units */ +} +,[GEJ_INFINITY] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_infinity +, .cmr = {{0xaafb9380u, 0xd61a7f14u, 0x7846806bu, 0x2cc374fbu, 0xe82dd1aeu, 0xd485b98au, 0x0f164b3au, 0x54c2c0b0u}} +, .sourceIx = ty_u +, .targetIx = ty_pw512w256 +, .cost = 765 /* milli weight units */ +} +,[GEJ_IS_INFINITY] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_is_infinity +, .cmr = {{0xdb495fd1u, 0x3142e9b3u, 0x3763fc6du, 0x48d2fb0eu, 0x71b0d9d9u, 0x9bd726f4u, 0x7ad13fc5u, 0x560670a2u}} +, .sourceIx = ty_pw512w256 +, .targetIx = ty_b +, .cost = 701 /* milli weight units */ +} +,[GEJ_IS_ON_CURVE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_is_on_curve +, .cmr = {{0xbf4ca13fu, 0xf212e34bu, 0xf17d90c1u, 0x2e453d08u, 0xac7daa4au, 0x47d57e85u, 0xb43f2d43u, 0x66d43ddau}} +, .sourceIx = ty_pw512w256 +, .targetIx = ty_b +, .cost = 1039 /* milli weight units */ +} +,[GEJ_NEGATE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_negate +, .cmr = {{0x01bd1a35u, 0x1fb8164cu, 0x813d916du, 0x07774999u, 0x6b7db118u, 0xd31586cau, 0x9d75e756u, 0x3518f454u}} +, .sourceIx = ty_pw512w256 +, .targetIx = ty_pw512w256 +, .cost = 1549 /* milli weight units */ +} +,[GEJ_NORMALIZE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_normalize +, .cmr = {{0xec597d17u, 0xe2efb6d2u, 0xa002d50eu, 0x677527d3u, 0xd4a2907au, 0x119d68f1u, 0x2284b9a1u, 0xb0d2303au}} +, .sourceIx = ty_pw512w256 +, .targetIx = ty_mw512 +, .cost = 4184 /* milli weight units */ +} +,[GEJ_RESCALE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_rescale +, .cmr = {{0x2977d953u, 0xef7a1156u, 0xcec6db2du, 0xc2925412u, 0x75cbc82fu, 0xb829fd67u, 0x1b972e89u, 0xebed0c24u}} +, .sourceIx = ty_ppw512w256w256 +, .targetIx = ty_pw512w256 +, .cost = 2011 /* milli weight units */ +} +,[GEJ_X_EQUIV] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_x_equiv +, .cmr = {{0xf9f189fcu, 0x00b61f72u, 0xf10baaa2u, 0x1bcd88e5u, 0xd22e0aa9u, 0xb7509ae1u, 0x62a183a4u, 0xb664a4afu}} +, .sourceIx = ty_pw256pw512w256 +, .targetIx = ty_b +, .cost = 1103 /* milli weight units */ +} +,[GEJ_Y_IS_ODD] = +{ .tag = JET +, .jet = rustsimplicity_0_6_gej_y_is_odd +, .cmr = {{0x9eb6e453u, 0x5fb69bf6u, 0x09916599u, 0xf1345ad7u, 0x735da3f3u, 0x948d0686u, 0x908e44f4u, 0x5b2ff60cu}} +, .sourceIx = ty_pw512w256 +, .targetIx = ty_b +, .cost = 3702 /* milli weight units */ +} +,[GENERATE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_generate +, .cmr = {{0x148885acu, 0x73813113u, 0xc523e809u, 0xbea47ffdu, 0x8b1daf37u, 0x8d9dd54bu, 0xf966ccb8u, 0x83b1a984u}} +, .sourceIx = ty_w256 +, .targetIx = ty_pw512w256 +, .cost = 49851 /* milli weight units */ +} +,[HASH_TO_CURVE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_hash_to_curve +, .cmr = {{0xef4f548bu, 0x3c6c7517u, 0x5f2ce2d1u, 0x993b2d19u, 0x9beb16c0u, 0xa140175cu, 0x48a1277eu, 0xfc43a99bu}} +, .sourceIx = ty_w256 +, .targetIx = ty_w512 +, .cost = 69844 /* milli weight units */ +} +,[HIGH_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_high_1 +, .cmr = {{0xb109cf1cu, 0xce35f7e9u, 0xb649671au, 0x9b45dbc2u, 0x4099a713u, 0xaeb9a89cu, 0xc4cf6ef6u, 0xed8b308bu}} +, .sourceIx = ty_u +, .targetIx = ty_b +, .cost = 42 /* milli weight units */ +} +,[HIGH_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_high_16 +, .cmr = {{0x035dadd9u, 0xd7bf7433u, 0x6445e71du, 0xdc4d8202u, 0x24ff7e38u, 0xe0b8d52bu, 0xec9729b5u, 0x72b531f9u}} +, .sourceIx = ty_u +, .targetIx = ty_w16 +, .cost = 50 /* milli weight units */ +} +,[HIGH_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_high_32 +, .cmr = {{0xc5f1df0du, 0x64a2737au, 0x631b3aaeu, 0x8f260e8bu, 0x8dc1957bu, 0xd092911bu, 0x91d2078au, 0xd21e418au}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 64 /* milli weight units */ +} +,[HIGH_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_high_64 +, .cmr = {{0xa312633eu, 0x0a2305e6u, 0x9b3f341du, 0x91d683ddu, 0x94196a2fu, 0x9005c9b1u, 0x872a2c15u, 0xad46cf17u}} +, .sourceIx = ty_u +, .targetIx = ty_w64 +, .cost = 52 /* milli weight units */ +} +,[HIGH_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_high_8 +, .cmr = {{0xcbd78d50u, 0xaf779985u, 0x5adc4903u, 0xdbbefc13u, 0x45d51484u, 0xf03d3c75u, 0x5caaa5cau, 0xa97d4a14u}} +, .sourceIx = ty_u +, .targetIx = ty_w8 +, .cost = 59 /* milli weight units */ +} +,[INCREMENT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_increment_16 +, .cmr = {{0x86774949u, 0x39b27b86u, 0xcb5a8c7fu, 0x8172ad55u, 0x509531c9u, 0xb0e11e99u, 0x757e296cu, 0xc3c7c192u}} +, .sourceIx = ty_w16 +, .targetIx = ty_pbw16 +, .cost = 56 /* milli weight units */ +} +,[INCREMENT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_increment_32 +, .cmr = {{0x6bdbab7cu, 0xfc16c503u, 0x363c2f07u, 0x7e02c335u, 0xda406175u, 0xd192fbefu, 0x50c07fc2u, 0x79b3f40cu}} +, .sourceIx = ty_w32 +, .targetIx = ty_pbw32 +, .cost = 73 /* milli weight units */ +} +,[INCREMENT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_increment_64 +, .cmr = {{0x20e75e71u, 0x7cb76d46u, 0x95564f7cu, 0x20221b7au, 0x01431387u, 0x38f151aau, 0x195eb170u, 0xec13c049u}} +, .sourceIx = ty_w64 +, .targetIx = ty_pbw64 +, .cost = 64 /* milli weight units */ +} +,[INCREMENT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_increment_8 +, .cmr = {{0x5f4e056eu, 0xf4ed8d68u, 0xbf911fc5u, 0xcb69037eu, 0xbf6c9221u, 0x7343a890u, 0x5d38c432u, 0xc183233cu}} +, .sourceIx = ty_w8 +, .targetIx = ty_pbw8 +, .cost = 69 /* milli weight units */ +} +,[INPUT_ANNEX_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_annex_hash +, .cmr = {{0x945b147eu, 0x5f0edb83u, 0x2d62348cu, 0xaeeac224u, 0x56eee944u, 0x65376dbfu, 0x596b9d62u, 0x985b01b6u}} +, .sourceIx = ty_w32 +, .targetIx = ty_mmw256 +, .cost = 77 /* milli weight units */ +} +,[INPUT_ANNEXES_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_annexes_hash +, .cmr = {{0x89b60270u, 0x44141f20u, 0x65b6f236u, 0xcfcc13b9u, 0x68485e00u, 0x746b7859u, 0x286903c6u, 0x8c7f880du}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 124 /* milli weight units */ +} +,[INPUT_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_hash +, .cmr = {{0x3ad22231u, 0xd6b9dff6u, 0xa0b4dbcfu, 0xf044e11cu, 0x082e0468u, 0x4e73ce95u, 0xc205e0c4u, 0x496e5ecau}} +, .sourceIx = ty_w32 +, .targetIx = ty_mw256 +, .cost = 832 /* milli weight units */ +} +,[INPUT_OUTPOINTS_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_outpoints_hash +, .cmr = {{0x1759c6f4u, 0x70b9aba6u, 0x2a31791eu, 0xa01056e3u, 0x608bdf22u, 0xf5dd43bfu, 0x7db00ea5u, 0x823f7cceu}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 126 /* milli weight units */ +} +,[INPUT_PREV_OUTPOINT] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_prev_outpoint +, .cmr = {{0x5d171242u, 0x09ee0521u, 0x24e55238u, 0xe0b6a6feu, 0x85a48688u, 0xc1e15e61u, 0x81de94f7u, 0x8db04018u}} +, .sourceIx = ty_w32 +, .targetIx = ty_mpw256w32 +, .cost = 140 /* milli weight units */ +} +,[INPUT_SCRIPT_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_script_hash +, .cmr = {{0x0562412fu, 0x021da481u, 0x9b019c8cu, 0xd887d530u, 0x492b9f94u, 0x2c4ebf21u, 0xae39ed32u, 0x330d7cfeu}} +, .sourceIx = ty_w32 +, .targetIx = ty_mw256 +, .cost = 143 /* milli weight units */ +} +,[INPUT_SCRIPT_SIG_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_script_sig_hash +, .cmr = {{0x1c7efb37u, 0xcbc4b996u, 0xd9b8c617u, 0x08e66573u, 0xce87c1f0u, 0xaa0522d0u, 0x65ba9025u, 0x056e3f80u}} +, .sourceIx = ty_w32 +, .targetIx = ty_mw256 +, .cost = 137 /* milli weight units */ +} +,[INPUT_SCRIPT_SIGS_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_script_sigs_hash +, .cmr = {{0xe729c5f5u, 0x8a938908u, 0x1a5ca845u, 0xf76cb980u, 0xf08599ceu, 0xb3c7d7eau, 0xe1145b53u, 0xa60ae3d5u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 127 /* milli weight units */ +} +,[INPUT_SCRIPTS_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_scripts_hash +, .cmr = {{0xf177671du, 0x60960e46u, 0x3a9a8f7eu, 0x1f5213aau, 0xba9122d2u, 0xdb75fe91u, 0xf8f1cf91u, 0xbe001907u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 129 /* milli weight units */ +} +,[INPUT_SEQUENCE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_sequence +, .cmr = {{0x5dd17fe1u, 0x550f48f7u, 0xbaed4d06u, 0x8008d4a1u, 0xff98cbebu, 0xe2541c5du, 0xc77ac53au, 0xd83fa779u}} +, .sourceIx = ty_w32 +, .targetIx = ty_mw32 +, .cost = 78 /* milli weight units */ +} +,[INPUT_SEQUENCES_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_sequences_hash +, .cmr = {{0x55973d64u, 0x43457472u, 0x81377364u, 0xbad2a80bu, 0x758f4566u, 0x60c18de5u, 0xc01a3882u, 0x071d50e8u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 125 /* milli weight units */ +} +,[INPUT_UTXO_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_utxo_hash +, .cmr = {{0x931e4e95u, 0xe0a64760u, 0x276e91b5u, 0xdc746780u, 0xd0697d0au, 0xf5aaf5bbu, 0xc81dbeb3u, 0x98596abbu}} +, .sourceIx = ty_w32 +, .targetIx = ty_mw256 +, .cost = 824 /* milli weight units */ +} +,[INPUT_UTXOS_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_utxos_hash +, .cmr = {{0xd6f90cd1u, 0x04e1a5c6u, 0x1a4b5000u, 0xad9aba8du, 0x43004bf9u, 0x43df325fu, 0xa636d1a2u, 0x2beca0cbu}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 122 /* milli weight units */ +} +,[INPUT_VALUE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_value +, .cmr = {{0x7d3c3f95u, 0x5b2cf0d0u, 0xd1280a1bu, 0xb1204692u, 0x92d1329cu, 0x83a9c2ffu, 0x7e7e1eb3u, 0xf69783a3u}} +, .sourceIx = ty_w32 +, .targetIx = ty_mw64 +, .cost = 81 /* milli weight units */ +} +,[INPUT_VALUES_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_input_values_hash +, .cmr = {{0x29839eadu, 0x0eb03fe4u, 0x6542e36du, 0x71e9e6afu, 0xdf969301u, 0x533d74eeu, 0x099b1266u, 0xa250552cu}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 126 /* milli weight units */ +} +,[INPUTS_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_inputs_hash +, .cmr = {{0xabbfe1c7u, 0xd115c419u, 0x1f504839u, 0xf98c3f20u, 0x422b84e7u, 0xfa14da14u, 0x02896c4du, 0x98bfa8d8u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 122 /* milli weight units */ +} +,[INTERNAL_KEY] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_internal_key +, .cmr = {{0x37483699u, 0x2810022fu, 0x88e0145bu, 0xcad77f4au, 0x8491fa80u, 0x83cb51c3u, 0x01fcf7a1u, 0x3478c2ccu}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 124 /* milli weight units */ +} +,[IS_ONE_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_is_one_16 +, .cmr = {{0x1bd3a253u, 0xdb243fcau, 0x45533799u, 0xfe914838u, 0xc38e3806u, 0xb12bd7e8u, 0x5ca71207u, 0xa88462b0u}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 64 /* milli weight units */ +} +,[IS_ONE_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_is_one_32 +, .cmr = {{0x78b1bae0u, 0x99ec9c59u, 0xcbf41262u, 0x51c1e967u, 0x41b350d5u, 0x63bd74d5u, 0x4418ba78u, 0xebea25bfu}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 64 /* milli weight units */ +} +,[IS_ONE_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_is_one_64 +, .cmr = {{0x817b95a5u, 0x395efbecu, 0xbb8515a5u, 0x5b3ffe1au, 0x4d7bac6eu, 0x23dbca54u, 0xad606666u, 0x2f202b93u}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 66 /* milli weight units */ +} +,[IS_ONE_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_is_one_8 +, .cmr = {{0xf6925491u, 0xd34b3774u, 0x2cb08decu, 0x193ee512u, 0x5f933cadu, 0xcc232aedu, 0xeedb572du, 0x1260ffd5u}} +, .sourceIx = ty_w8 +, .targetIx = ty_b +, .cost = 47 /* milli weight units */ +} +,[IS_ZERO_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_is_zero_16 +, .cmr = {{0x1ba7213bu, 0x588be092u, 0xb446599cu, 0x2a60ff54u, 0x67136a79u, 0x7599610bu, 0xd7a5f178u, 0x04e32a2cu}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 52 /* milli weight units */ +} +,[IS_ZERO_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_is_zero_32 +, .cmr = {{0x5ebf1466u, 0x93f0e2d2u, 0xf9361b47u, 0x6dba3485u, 0x8b832d66u, 0xfacf713bu, 0xfb32c3bbu, 0x8db9eebfu}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 58 /* milli weight units */ +} +,[IS_ZERO_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_is_zero_64 +, .cmr = {{0x19ab9ac0u, 0xcf426682u, 0x19ba6cb8u, 0x97e487feu, 0x3680937fu, 0xffa8d203u, 0x511db75du, 0xbb10c7e5u}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 68 /* milli weight units */ +} +,[IS_ZERO_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_is_zero_8 +, .cmr = {{0x8eff6208u, 0x4407e9afu, 0xd540f318u, 0xf66bcf31u, 0xdf1d42a5u, 0xc161cae3u, 0x5a294818u, 0x0ca2aa2eu}} +, .sourceIx = ty_w8 +, .targetIx = ty_b +, .cost = 59 /* milli weight units */ +} +,[LE_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_le_16 +, .cmr = {{0x016705a7u, 0xd7dce1afu, 0xc63eab84u, 0x203f5f42u, 0xd6b6bbadu, 0x75cee38cu, 0xec5a515bu, 0x5997489fu}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 83 /* milli weight units */ +} +,[LE_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_le_32 +, .cmr = {{0x5351fc5du, 0xebe5b298u, 0xad7057e4u, 0xa5a76a3bu, 0x9c658acdu, 0xe7d1bb52u, 0xe5889ca1u, 0xe38f5efbu}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 99 /* milli weight units */ +} +,[LE_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_le_64 +, .cmr = {{0xae2de1e0u, 0xcf730d1du, 0xcc96d7ccu, 0xfe71168au, 0x240deaf8u, 0x04615a7bu, 0xa920dc16u, 0xfd6ea45fu}} +, .sourceIx = ty_w128 +, .targetIx = ty_b +, .cost = 79 /* milli weight units */ +} +,[LE_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_le_8 +, .cmr = {{0xaf29f616u, 0x8ebdc09eu, 0xfbe0e639u, 0xcb750b12u, 0x05788f90u, 0x21d666efu, 0xcefe13f1u, 0x2f9671f0u}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 93 /* milli weight units */ +} +,[LEFT_EXTEND_16_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_16_32 +, .cmr = {{0x289997fbu, 0xa1fae7ecu, 0x1c4531c5u, 0x0bbf8671u, 0xb897139bu, 0xdd3aad97u, 0xa3763957u, 0x4a047c80u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w32 +, .cost = 72 /* milli weight units */ +} +,[LEFT_EXTEND_16_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_16_64 +, .cmr = {{0x5dff21f6u, 0xe6124775u, 0xc578eaf4u, 0x855c0b01u, 0x64f7879bu, 0x1760f902u, 0x7cb50f7bu, 0x5acb4918u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w64 +, .cost = 69 /* milli weight units */ +} +,[LEFT_EXTEND_1_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_1_16 +, .cmr = {{0x8c87d756u, 0xd14bd3d9u, 0xa7869081u, 0x2912b894u, 0x29c0171au, 0x41103a58u, 0xc6e9f225u, 0x141a0222u}} +, .sourceIx = ty_b +, .targetIx = ty_w16 +, .cost = 50 /* milli weight units */ +} +,[LEFT_EXTEND_1_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_1_32 +, .cmr = {{0xc8f154d4u, 0x6d2e7895u, 0xda1b33c2u, 0xb315e6d4u, 0xd4851ddeu, 0xe28aef8bu, 0x70709061u, 0x6bc7eea0u}} +, .sourceIx = ty_b +, .targetIx = ty_w32 +, .cost = 48 /* milli weight units */ +} +,[LEFT_EXTEND_1_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_1_64 +, .cmr = {{0xa3404df6u, 0x8cc92075u, 0x4c6e1847u, 0x207db384u, 0x5d11c749u, 0x09d07ca8u, 0x2ad1f1ccu, 0x67bf3a9bu}} +, .sourceIx = ty_b +, .targetIx = ty_w64 +, .cost = 49 /* milli weight units */ +} +,[LEFT_EXTEND_1_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_1_8 +, .cmr = {{0x3bca3397u, 0xb83c27f3u, 0x6316f8b8u, 0xb303350au, 0xfe8ba007u, 0x8f77f1d4u, 0x2a9b7892u, 0xb2a4dbeeu}} +, .sourceIx = ty_b +, .targetIx = ty_w8 +, .cost = 46 /* milli weight units */ +} +,[LEFT_EXTEND_32_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_32_64 +, .cmr = {{0x42cbeb01u, 0xfe7a3a6du, 0xd3311db3u, 0x365f91e5u, 0xc118c7e4u, 0x1f03aae7u, 0xb283de6bu, 0xb9053e6bu}} +, .sourceIx = ty_w32 +, .targetIx = ty_w64 +, .cost = 69 /* milli weight units */ +} +,[LEFT_EXTEND_8_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_8_16 +, .cmr = {{0x9a57c96au, 0xf5714896u, 0xb724de45u, 0xeb9fe97du, 0x73697de6u, 0x2e8dad78u, 0x71eb58f5u, 0x81a011bbu}} +, .sourceIx = ty_w8 +, .targetIx = ty_w16 +, .cost = 58 /* milli weight units */ +} +,[LEFT_EXTEND_8_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_8_32 +, .cmr = {{0xd624bd40u, 0x40763cb1u, 0x3ccad498u, 0xf53d38c1u, 0x12f19295u, 0x6826dafeu, 0xc9ac9165u, 0x792b347au}} +, .sourceIx = ty_w8 +, .targetIx = ty_w32 +, .cost = 86 /* milli weight units */ +} +,[LEFT_EXTEND_8_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_extend_8_64 +, .cmr = {{0x9dc4a205u, 0x4d5d2634u, 0x2ac590b6u, 0x67f1b01du, 0xf54fd0cdu, 0xaa405ef8u, 0xcbb76fd8u, 0xf9b00ee5u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w64 +, .cost = 98 /* milli weight units */ +} +,[LEFT_PAD_HIGH_16_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_16_32 +, .cmr = {{0x0545c4b5u, 0x8f004a21u, 0xe7f129a4u, 0xc0518997u, 0x1714caa2u, 0xd91d1dfdu, 0x5fad3e63u, 0x24499428u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w32 +, .cost = 71 /* milli weight units */ +} +,[LEFT_PAD_HIGH_16_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_16_64 +, .cmr = {{0x1c61d03du, 0x493bbd05u, 0x822259d1u, 0x730a8d7au, 0x5f55b0bau, 0x2a9391a6u, 0xc8881eb4u, 0x7504affdu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w64 +, .cost = 82 /* milli weight units */ +} +,[LEFT_PAD_HIGH_1_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_1_16 +, .cmr = {{0x56fdf54fu, 0x1fcd1982u, 0x5e7c3b79u, 0x0615c1d3u, 0xfe82886cu, 0x747bc487u, 0x5987f505u, 0x16945fb3u}} +, .sourceIx = ty_b +, .targetIx = ty_w16 +, .cost = 106 /* milli weight units */ +} +,[LEFT_PAD_HIGH_1_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_1_32 +, .cmr = {{0xdb33059au, 0xbe2d432du, 0x67f42b1eu, 0x942756dcu, 0xa6cde637u, 0x85e5bd43u, 0x0dc8f4aeu, 0xfc31b8dfu}} +, .sourceIx = ty_b +, .targetIx = ty_w32 +, .cost = 220 /* milli weight units */ +} +,[LEFT_PAD_HIGH_1_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_1_64 +, .cmr = {{0x1d669c1fu, 0xa5fd3ef6u, 0x6eb4aef6u, 0x186e3ec1u, 0x36ee7584u, 0x10df3edeu, 0xbb31bf26u, 0xd4562051u}} +, .sourceIx = ty_b +, .targetIx = ty_w64 +, .cost = 302 /* milli weight units */ +} +,[LEFT_PAD_HIGH_1_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_1_8 +, .cmr = {{0x9a1bad3du, 0x8ab90030u, 0x3da202f0u, 0xf449f0b7u, 0xe6795c2au, 0x7c121718u, 0x800ac40cu, 0x87d82729u}} +, .sourceIx = ty_b +, .targetIx = ty_w8 +, .cost = 73 /* milli weight units */ +} +,[LEFT_PAD_HIGH_32_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_32_64 +, .cmr = {{0x3920cc4bu, 0x33baf7efu, 0xa5caf9e7u, 0x80014467u, 0x06f6e4e8u, 0x26567405u, 0x7eed8717u, 0x78089e94u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w64 +, .cost = 69 /* milli weight units */ +} +,[LEFT_PAD_HIGH_8_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_8_16 +, .cmr = {{0x752e29f2u, 0xfe2becc3u, 0xf66290feu, 0x44e1aeb3u, 0x784180ddu, 0x905e1962u, 0x4e195f21u, 0x6c07c57cu}} +, .sourceIx = ty_w8 +, .targetIx = ty_w16 +, .cost = 65 /* milli weight units */ +} +,[LEFT_PAD_HIGH_8_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_8_32 +, .cmr = {{0xbee88f1cu, 0x8c30634cu, 0x6e95caccu, 0x0e9add49u, 0x413221fdu, 0xabbd8d4cu, 0x0accf1cau, 0xe2d2a778u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w32 +, .cost = 105 /* milli weight units */ +} +,[LEFT_PAD_HIGH_8_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_high_8_64 +, .cmr = {{0x392387f6u, 0xdc04bfc5u, 0x4dd4a281u, 0x19c81d15u, 0xd7a5809bu, 0xbf62fcc2u, 0x7dc55cf8u, 0x2e9e5ee6u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w64 +, .cost = 113 /* milli weight units */ +} +,[LEFT_PAD_LOW_16_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_16_32 +, .cmr = {{0x4ffd6cb3u, 0x40230582u, 0x1dd89970u, 0xd722d1c1u, 0x3f1ff773u, 0x9fd5f34bu, 0xa16c7365u, 0x3b044718u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w32 +, .cost = 65 /* milli weight units */ +} +,[LEFT_PAD_LOW_16_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_16_64 +, .cmr = {{0xbe3eb85cu, 0x5f199153u, 0xfb1c4613u, 0x5c04facfu, 0xdbc6f1b7u, 0x8c2bb7aeu, 0x75f155bcu, 0x3ea08a8bu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w64 +, .cost = 68 /* milli weight units */ +} +,[LEFT_PAD_LOW_1_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_1_16 +, .cmr = {{0xddd0153eu, 0xf312f28du, 0x642cd94cu, 0xb36f3297u, 0x75b00da8u, 0x8fccc4ceu, 0xa1bae89bu, 0xad13be6bu}} +, .sourceIx = ty_b +, .targetIx = ty_w16 +, .cost = 59 /* milli weight units */ +} +,[LEFT_PAD_LOW_1_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_1_32 +, .cmr = {{0xbc9d3114u, 0x35467bc0u, 0x8b1008e5u, 0x47aa7a07u, 0xe83b1514u, 0x6861a9e9u, 0xb5413be3u, 0x1b82b6b5u}} +, .sourceIx = ty_b +, .targetIx = ty_w32 +, .cost = 47 /* milli weight units */ +} +,[LEFT_PAD_LOW_1_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_1_64 +, .cmr = {{0x8bc62f93u, 0x60894e48u, 0xa4732c95u, 0x769c8faau, 0xe9568f9du, 0xe8e8a200u, 0x836bd4e5u, 0x0b02cd84u}} +, .sourceIx = ty_b +, .targetIx = ty_w64 +, .cost = 46 /* milli weight units */ +} +,[LEFT_PAD_LOW_1_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_1_8 +, .cmr = {{0xf66cd7a4u, 0x2b320f97u, 0xc19f2d54u, 0x16cde087u, 0x253a2791u, 0x2965d55bu, 0x65712ad8u, 0x09b83cfdu}} +, .sourceIx = ty_b +, .targetIx = ty_w8 +, .cost = 48 /* milli weight units */ +} +,[LEFT_PAD_LOW_32_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_32_64 +, .cmr = {{0xa33a07b9u, 0xbcf945f6u, 0x4f072b8bu, 0x9c914839u, 0xa585bfa9u, 0xf3425b14u, 0x7754ab55u, 0xa8ba6c0fu}} +, .sourceIx = ty_w32 +, .targetIx = ty_w64 +, .cost = 62 /* milli weight units */ +} +,[LEFT_PAD_LOW_8_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_8_16 +, .cmr = {{0x2a516a79u, 0x3f97c45fu, 0xeaebb1ccu, 0x961a156du, 0x80354928u, 0x79789d6eu, 0xdc9b57e7u, 0x2f11e5b5u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w16 +, .cost = 56 /* milli weight units */ +} +,[LEFT_PAD_LOW_8_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_8_32 +, .cmr = {{0x1aa2e4d0u, 0x4bd69055u, 0x123dd6aau, 0xfe27f5f7u, 0xf47c3b30u, 0x90c3a827u, 0x2973fe2fu, 0x75165a5du}} +, .sourceIx = ty_w8 +, .targetIx = ty_w32 +, .cost = 75 /* milli weight units */ +} +,[LEFT_PAD_LOW_8_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_pad_low_8_64 +, .cmr = {{0xb652e0aeu, 0xdd0f4f66u, 0xf6a1cd4bu, 0xebf875ffu, 0x7bbb2dd9u, 0x9b065b2du, 0xb5b5b590u, 0x5361614du}} +, .sourceIx = ty_w8 +, .targetIx = ty_w64 +, .cost = 116 /* milli weight units */ +} +,[LEFT_ROTATE_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_rotate_16 +, .cmr = {{0x8a12ff6au, 0x4bf23715u, 0xdd3b766bu, 0x9967c715u, 0x8bf3ed74u, 0xb3dce730u, 0xaffcf466u, 0x16478ecbu}} +, .sourceIx = ty_pw4w16 +, .targetIx = ty_w16 +, .cost = 88 /* milli weight units */ +} +,[LEFT_ROTATE_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_rotate_32 +, .cmr = {{0x2fcb5217u, 0x2fd49c36u, 0x217deae0u, 0xc2371432u, 0x1f69f5f1u, 0x3f6e94b2u, 0xbdfe4b74u, 0x88697fd5u}} +, .sourceIx = ty_pw8w32 +, .targetIx = ty_w32 +, .cost = 62 /* milli weight units */ +} +,[LEFT_ROTATE_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_rotate_64 +, .cmr = {{0x72ccd6c4u, 0xe5fdf68au, 0xd33b6d58u, 0xfb372be4u, 0xf1b80eefu, 0x701f9db7u, 0xe5ed859bu, 0x96b36209u}} +, .sourceIx = ty_pw8w64 +, .targetIx = ty_w64 +, .cost = 68 /* milli weight units */ +} +,[LEFT_ROTATE_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_rotate_8 +, .cmr = {{0x1aaec9f3u, 0xb75d89f8u, 0x2a649845u, 0x8c4483cbu, 0x9a784489u, 0x05f3bb39u, 0xfc083f14u, 0xddccdc9bu}} +, .sourceIx = ty_pw4w8 +, .targetIx = ty_w8 +, .cost = 66 /* milli weight units */ +} +,[LEFT_SHIFT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_shift_16 +, .cmr = {{0x37ac6387u, 0x21ab097au, 0x9602ba4du, 0xc92e19b5u, 0xa185b232u, 0x9f1aa600u, 0xcb9c1561u, 0x5a0081f8u}} +, .sourceIx = ty_pw4w16 +, .targetIx = ty_w16 +, .cost = 109 /* milli weight units */ +} +,[LEFT_SHIFT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_shift_32 +, .cmr = {{0x8e3c473bu, 0x2867f154u, 0x73b3632du, 0xbfdd9977u, 0x5551ef5fu, 0x9dba475eu, 0x9cf09075u, 0x8070f0bfu}} +, .sourceIx = ty_pw8w32 +, .targetIx = ty_w32 +, .cost = 79 /* milli weight units */ +} +,[LEFT_SHIFT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_shift_64 +, .cmr = {{0x5049f404u, 0xd173299au, 0x3aee04cbu, 0xc2462cb3u, 0x4c8069c1u, 0xb6db7fedu, 0x0e388ff6u, 0xd467a086u}} +, .sourceIx = ty_pw8w64 +, .targetIx = ty_w64 +, .cost = 70 /* milli weight units */ +} +,[LEFT_SHIFT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_shift_8 +, .cmr = {{0x832f636eu, 0x63446cefu, 0xba8df3a4u, 0x6efbb361u, 0x59c18854u, 0x567768adu, 0xc9b8db8au, 0x07492a58u}} +, .sourceIx = ty_pw4w8 +, .targetIx = ty_w8 +, .cost = 72 /* milli weight units */ +} +,[LEFT_SHIFT_WITH_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_shift_with_16 +, .cmr = {{0xe64762b1u, 0xc5e6144au, 0x7181eaafu, 0x4dd9d9b3u, 0xaa43aad9u, 0x55158198u, 0xee2090ebu, 0xd9e4bb0du}} +, .sourceIx = ty_pbpw4w16 +, .targetIx = ty_w16 +, .cost = 72 /* milli weight units */ +} +,[LEFT_SHIFT_WITH_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_shift_with_32 +, .cmr = {{0x6476ba89u, 0x95f83b5eu, 0xe1ebc22cu, 0xb416f558u, 0x157f2e57u, 0x699a5cafu, 0x84291ff3u, 0xfc1483c1u}} +, .sourceIx = ty_pbpw8w32 +, .targetIx = ty_w32 +, .cost = 87 /* milli weight units */ +} +,[LEFT_SHIFT_WITH_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_shift_with_64 +, .cmr = {{0x06b8fe67u, 0xcfc58632u, 0x2397af02u, 0x4fde2911u, 0xf7ae87a0u, 0x6abc6c59u, 0x30934097u, 0x15691c19u}} +, .sourceIx = ty_pbpw8w64 +, .targetIx = ty_w64 +, .cost = 97 /* milli weight units */ +} +,[LEFT_SHIFT_WITH_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_left_shift_with_8 +, .cmr = {{0xb1ac9c68u, 0x2358c45bu, 0xabf40695u, 0x56fe6e37u, 0x5b4554deu, 0x9e10c591u, 0xc1483984u, 0x47ac180eu}} +, .sourceIx = ty_pbpw4w8 +, .targetIx = ty_w8 +, .cost = 104 /* milli weight units */ +} +,[LEFTMOST_16_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_16_1 +, .cmr = {{0x5bff4cb5u, 0x587605d5u, 0xfd059d77u, 0x33490d7du, 0xd22d278bu, 0x599e06d3u, 0xb5db6d79u, 0xf3c923bdu}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 68 /* milli weight units */ +} +,[LEFTMOST_16_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_16_2 +, .cmr = {{0x536db486u, 0xb12227e5u, 0xb09d6febu, 0xd2776b1au, 0xbbc67499u, 0x96aa783eu, 0xd7e53744u, 0x6bbf151bu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w2 +, .cost = 58 /* milli weight units */ +} +,[LEFTMOST_16_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_16_4 +, .cmr = {{0xf2321367u, 0x496d1a77u, 0xeea05e95u, 0xe3b807d3u, 0xba5f0513u, 0x6ce0912au, 0xe717c83au, 0x0261b2e1u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w4 +, .cost = 51 /* milli weight units */ +} +,[LEFTMOST_16_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_16_8 +, .cmr = {{0x24148ef3u, 0x0ad43ebeu, 0xc5637283u, 0x22c3ce11u, 0x79aed7a7u, 0x8216d799u, 0x888bf18bu, 0x39570671u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w8 +, .cost = 62 /* milli weight units */ +} +,[LEFTMOST_32_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_32_1 +, .cmr = {{0xb92e15ecu, 0x5da07ee8u, 0xed397cb9u, 0xf60a4c5du, 0xa8386293u, 0x1a907359u, 0xd27caeb6u, 0x0e60ef8au}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 53 /* milli weight units */ +} +,[LEFTMOST_32_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_32_16 +, .cmr = {{0xadb027b2u, 0x06567358u, 0x5326c01cu, 0x3be2faebu, 0x386349e2u, 0x9009b657u, 0x6ee53a85u, 0x5512cc67u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 63 /* milli weight units */ +} +,[LEFTMOST_32_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_32_2 +, .cmr = {{0xb75b31c5u, 0x59123d3du, 0x63359859u, 0x32b8b1b2u, 0x664ee597u, 0xafb15fd1u, 0xa499d007u, 0xcff2755cu}} +, .sourceIx = ty_w32 +, .targetIx = ty_w2 +, .cost = 62 /* milli weight units */ +} +,[LEFTMOST_32_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_32_4 +, .cmr = {{0xcb757e47u, 0x1e9d9a40u, 0x771dd1cfu, 0x3c1bf5d2u, 0x3c17ed68u, 0xcdbdb22du, 0xada17a73u, 0xa7b407b2u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w4 +, .cost = 61 /* milli weight units */ +} +,[LEFTMOST_32_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_32_8 +, .cmr = {{0xbfc534b4u, 0x9e06006eu, 0x19f3b68eu, 0x0a02391cu, 0x149f9a34u, 0xf43ee36bu, 0x9f1d79a7u, 0x9c9a9e4du}} +, .sourceIx = ty_w32 +, .targetIx = ty_w8 +, .cost = 60 /* milli weight units */ +} +,[LEFTMOST_64_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_64_1 +, .cmr = {{0x1b1d4e92u, 0x384b8b15u, 0x9ba0d806u, 0x558b5494u, 0xe3614eedu, 0xe03c946cu, 0xeaf141f3u, 0x6f01c79bu}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 65 /* milli weight units */ +} +,[LEFTMOST_64_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_64_16 +, .cmr = {{0x0debdc1au, 0xa0433034u, 0x42e18fe0u, 0x3d8a99d2u, 0xbe6bb8a8u, 0x691aba19u, 0x566259e3u, 0x6760f7f9u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w16 +, .cost = 62 /* milli weight units */ +} +,[LEFTMOST_64_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_64_2 +, .cmr = {{0x839ecfa3u, 0x18705c25u, 0x3d0c52ffu, 0x27b90464u, 0x923d8c0eu, 0x55a82c0du, 0x16240239u, 0x7f365378u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w2 +, .cost = 61 /* milli weight units */ +} +,[LEFTMOST_64_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_64_32 +, .cmr = {{0x929197a9u, 0x642861a7u, 0x7bd66258u, 0x051197beu, 0x86ff08e6u, 0x28e30f7eu, 0xfcbd2c4du, 0xfecf9bddu}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 77 /* milli weight units */ +} +,[LEFTMOST_64_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_64_4 +, .cmr = {{0x02bd1645u, 0xd575f04bu, 0x3cbbaa6du, 0x8ca986efu, 0x1c8cd0ffu, 0xe1658903u, 0x939db764u, 0x562a2647u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w4 +, .cost = 80 /* milli weight units */ +} +,[LEFTMOST_64_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_64_8 +, .cmr = {{0x3558b31bu, 0x3b6e8f9au, 0x288fdc72u, 0xf24602beu, 0x05581910u, 0x71a54a99u, 0xfa03a025u, 0x34f88005u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w8 +, .cost = 54 /* milli weight units */ +} +,[LEFTMOST_8_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_8_1 +, .cmr = {{0x2865efd4u, 0x2983cbe3u, 0xf816373au, 0xb8a882f1u, 0x8317194du, 0xc1aba38du, 0xa0304b8cu, 0x144b1da4u}} +, .sourceIx = ty_w8 +, .targetIx = ty_b +, .cost = 54 /* milli weight units */ +} +,[LEFTMOST_8_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_8_2 +, .cmr = {{0x51964cb0u, 0x7405a8d2u, 0x3d218774u, 0x1a9ed304u, 0xbcb469d9u, 0xac9f5d92u, 0x55825cfdu, 0xa3da07c0u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w2 +, .cost = 71 /* milli weight units */ +} +,[LEFTMOST_8_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_leftmost_8_4 +, .cmr = {{0x883c94f8u, 0xa26cdab7u, 0xbc5cd631u, 0xe52255a8u, 0x5ef6e070u, 0x766457f6u, 0x321e2ccbu, 0x119d9b2bu}} +, .sourceIx = ty_w8 +, .targetIx = ty_w4 +, .cost = 65 /* milli weight units */ +} +,[LINEAR_COMBINATION_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_linear_combination_1 +, .cmr = {{0x3410a9eeu, 0x333df8c8u, 0xa01c1411u, 0x5b544327u, 0xe324e287u, 0xaa1107e0u, 0x1955bd20u, 0x506ea987u}} +, .sourceIx = ty_ppw256pw512w256w256 +, .targetIx = ty_pw512w256 +, .cost = 85743 /* milli weight units */ +} +,[LINEAR_VERIFY_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_linear_verify_1 +, .cmr = {{0xdc66d331u, 0xc17f3fddu, 0xa3994698u, 0x1b39b357u, 0xd0555c35u, 0x62ecae02u, 0xaa2dad16u, 0x3e6c9a2eu}} +, .sourceIx = ty_pppw256w512w256w512 +, .targetIx = ty_u +, .cost = 43579 /* milli weight units */ +} +,[LOCK_TIME] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_lock_time +, .cmr = {{0x9ae0acc3u, 0x7bc20447u, 0x79b07c3du, 0x4602a5fdu, 0xe8bc33f8u, 0x79f66b73u, 0x9b10f01au, 0xeb1154ecu}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 66 /* milli weight units */ +} +,[LOW_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_low_1 +, .cmr = {{0xfe6214f9u, 0x67156dcdu, 0xe6dd49fdu, 0xc55efb86u, 0x5069feabu, 0xfff0fe93u, 0x1dba8531u, 0x34eed130u}} +, .sourceIx = ty_u +, .targetIx = ty_b +, .cost = 40 /* milli weight units */ +} +,[LOW_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_low_16 +, .cmr = {{0x7493cf69u, 0x8a4882e5u, 0xc3579d06u, 0x518e7ecau, 0x2b8428f6u, 0x2e2b5138u, 0x02abe622u, 0x170c20feu}} +, .sourceIx = ty_u +, .targetIx = ty_w16 +, .cost = 60 /* milli weight units */ +} +,[LOW_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_low_32 +, .cmr = {{0x362d66a4u, 0xf0aeb965u, 0x84a56757u, 0x8271b1f7u, 0xbbfcc2deu, 0x0dcf9579u, 0x6b6f7a82u, 0x6b2a8af7u}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 52 /* milli weight units */ +} +,[LOW_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_low_64 +, .cmr = {{0x973323bcu, 0x2b92e428u, 0x04d2e4f5u, 0x8b86f65bu, 0x56f91deeu, 0xb4810eabu, 0x8a1deda9u, 0x697a0872u}} +, .sourceIx = ty_u +, .targetIx = ty_w64 +, .cost = 50 /* milli weight units */ +} +,[LOW_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_low_8 +, .cmr = {{0xcd1a8558u, 0xef99a322u, 0x60217a76u, 0x49ff5140u, 0xda69da70u, 0x0672690bu, 0x27917b07u, 0xd7c14c67u}} +, .sourceIx = ty_u +, .targetIx = ty_w8 +, .cost = 45 /* milli weight units */ +} +,[LT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_lt_16 +, .cmr = {{0x04aca87eu, 0x3e17f805u, 0xa21cf291u, 0x7aee9957u, 0xb950b2dbu, 0x5d7ae5c8u, 0x26d4ac2eu, 0xc97b5a52u}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 83 /* milli weight units */ +} +,[LT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_lt_32 +, .cmr = {{0x23a0a5c1u, 0x97747e3au, 0x9579e90eu, 0x0f22f84au, 0x29bfb5f0u, 0x7b84b59bu, 0x26688a0cu, 0xd59dfebdu}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 89 /* milli weight units */ +} +,[LT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_lt_64 +, .cmr = {{0xd299901cu, 0x7b5b3a59u, 0xffc8dd09u, 0x545a3238u, 0x24b779a9u, 0x9b2d1a2fu, 0x87452d9eu, 0x4befaf30u}} +, .sourceIx = ty_w128 +, .targetIx = ty_b +, .cost = 71 /* milli weight units */ +} +,[LT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_lt_8 +, .cmr = {{0xdd94413bu, 0x529c298cu, 0x1696e9fbu, 0x08e66767u, 0xb3f8337au, 0xc02e44b0u, 0x68e94014u, 0xf7c41f2au}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 86 /* milli weight units */ +} +,[MAJ_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_maj_1 +, .cmr = {{0x0e6fb40fu, 0xe31a3a52u, 0x6b44cf0bu, 0x7c7936c7u, 0x77cbba89u, 0x65a72552u, 0x32a7cf53u, 0xa922885au}} +, .sourceIx = ty_pbw2 +, .targetIx = ty_b +, .cost = 54 /* milli weight units */ +} +,[MAJ_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_maj_16 +, .cmr = {{0x38669ce5u, 0xe1e17147u, 0x5400731bu, 0xeeb60bcau, 0xfad66604u, 0xc9394016u, 0x0cd71288u, 0x35559342u}} +, .sourceIx = ty_pw16w32 +, .targetIx = ty_w16 +, .cost = 85 /* milli weight units */ +} +,[MAJ_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_maj_32 +, .cmr = {{0x5554349bu, 0x584f5c38u, 0x72c7f4f2u, 0x57829e2au, 0xe822d823u, 0x424ceb95u, 0x98f08318u, 0x586a8807u}} +, .sourceIx = ty_pw32w64 +, .targetIx = ty_w32 +, .cost = 73 /* milli weight units */ +} +,[MAJ_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_maj_64 +, .cmr = {{0x734903bau, 0xefb71d5eu, 0xa41648ffu, 0x43eee698u, 0x94e063b3u, 0x88ea422fu, 0x96aede19u, 0x3ceab839u}} +, .sourceIx = ty_pw64w128 +, .targetIx = ty_w64 +, .cost = 79 /* milli weight units */ +} +,[MAJ_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_maj_8 +, .cmr = {{0xba47a399u, 0xdc9435e1u, 0x8e080a4eu, 0x18af7c65u, 0x7fd39f7cu, 0xe7d6052eu, 0x46902311u, 0xb078d585u}} +, .sourceIx = ty_pw8w16 +, .targetIx = ty_w8 +, .cost = 64 /* milli weight units */ +} +,[MAX_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_max_16 +, .cmr = {{0xaa552374u, 0x6cabfaf5u, 0x668e9e07u, 0x37e56b06u, 0x062251d7u, 0xe80ab9b9u, 0x106d8f17u, 0x2dc84dd6u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 80 /* milli weight units */ +} +,[MAX_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_max_32 +, .cmr = {{0x6922965du, 0x144345c9u, 0x13ecb30bu, 0x5ed47e88u, 0xdae35c12u, 0x21f26aa9u, 0x2dd5a5f6u, 0x15dbdb53u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 70 /* milli weight units */ +} +,[MAX_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_max_64 +, .cmr = {{0x8a9be907u, 0xb6a4c30au, 0xbcc0f22du, 0x013074c2u, 0xd56bb081u, 0xf2621857u, 0xd538cc97u, 0x131e4409u}} +, .sourceIx = ty_w128 +, .targetIx = ty_w64 +, .cost = 75 /* milli weight units */ +} +,[MAX_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_max_8 +, .cmr = {{0xb4bf9323u, 0x4022e860u, 0xfe76c0b5u, 0x360e8b36u, 0xff81ee67u, 0x05b593acu, 0xdf655ac6u, 0xe6d7aebau}} +, .sourceIx = ty_w16 +, .targetIx = ty_w8 +, .cost = 79 /* milli weight units */ +} +,[MEDIAN_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_median_16 +, .cmr = {{0x17e2e87fu, 0x0760f4fbu, 0x3c9fd0beu, 0xd000d739u, 0x73ab60f5u, 0xe6c2c1fau, 0xb17f9b23u, 0xee6aca48u}} +, .sourceIx = ty_pw16w32 +, .targetIx = ty_w16 +, .cost = 80 /* milli weight units */ +} +,[MEDIAN_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_median_32 +, .cmr = {{0x1160ae8eu, 0xa8d30f9au, 0x2233c48eu, 0x731240f8u, 0x4493b828u, 0xb55793e2u, 0xf4042a19u, 0x82ac26a5u}} +, .sourceIx = ty_pw32w64 +, .targetIx = ty_w32 +, .cost = 77 /* milli weight units */ +} +,[MEDIAN_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_median_64 +, .cmr = {{0xc8737364u, 0x9e7e4050u, 0xbb73337eu, 0x08eb5de4u, 0x5228ab86u, 0xad4e1f41u, 0x91e5202au, 0xa6afa0c5u}} +, .sourceIx = ty_pw64w128 +, .targetIx = ty_w64 +, .cost = 89 /* milli weight units */ +} +,[MEDIAN_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_median_8 +, .cmr = {{0xc3b4e089u, 0x8a21bde9u, 0x4daed37au, 0x20adf90cu, 0x8be5691au, 0x03b6a1e5u, 0x56385d42u, 0xeb19022bu}} +, .sourceIx = ty_pw8w16 +, .targetIx = ty_w8 +, .cost = 77 /* milli weight units */ +} +,[MIN_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_min_16 +, .cmr = {{0x5fd0051eu, 0xdb3719a6u, 0x45b272a0u, 0x2108efbbu, 0x3d9bc0f6u, 0x0621bf5au, 0x5babe116u, 0xd555d578u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 83 /* milli weight units */ +} +,[MIN_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_min_32 +, .cmr = {{0xd80782a2u, 0xb5d86ab6u, 0xb9c9c3fbu, 0x778a3473u, 0xf600b185u, 0xfe1925eeu, 0x9fc2e877u, 0x7ed26601u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 96 /* milli weight units */ +} +,[MIN_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_min_64 +, .cmr = {{0xc5c09d50u, 0x1338e9a5u, 0x12cf8976u, 0xca4b32b9u, 0x2480bef6u, 0xaeb29d36u, 0xd590d35bu, 0xf9f9ece1u}} +, .sourceIx = ty_w128 +, .targetIx = ty_w64 +, .cost = 82 /* milli weight units */ +} +,[MIN_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_min_8 +, .cmr = {{0x81d21e12u, 0x81423881u, 0x802c0e0cu, 0x7d22bd34u, 0xd26bd12au, 0x4c4f1b70u, 0x68e7e183u, 0x820848e9u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w8 +, .cost = 78 /* milli weight units */ +} +,[MODULO_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_modulo_16 +, .cmr = {{0xb6b87cfau, 0xb67e5519u, 0xf1c998dau, 0x479437bbu, 0x79e674f7u, 0x15e9a2e5u, 0x38eec5ecu, 0x18e18ea5u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 85 /* milli weight units */ +} +,[MODULO_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_modulo_32 +, .cmr = {{0x8d486e83u, 0x1654f38au, 0x32da35ebu, 0x7bb655a6u, 0xed694dbfu, 0xa058957du, 0x9f5cbfccu, 0x5792c65bu}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 81 /* milli weight units */ +} +,[MODULO_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_modulo_64 +, .cmr = {{0x14df20d9u, 0x3dfdefe2u, 0x559bac50u, 0xed38193bu, 0xd78bd63fu, 0x929d86fbu, 0x4f29a7c5u, 0xaf3242adu}} +, .sourceIx = ty_w128 +, .targetIx = ty_w64 +, .cost = 71 /* milli weight units */ +} +,[MODULO_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_modulo_8 +, .cmr = {{0x2c758a7cu, 0x0f59e800u, 0xe94f3dc5u, 0xa001bf8eu, 0xd9435f75u, 0xa2d96930u, 0xc57eaab0u, 0xcd80af5cu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w8 +, .cost = 85 /* milli weight units */ +} +,[MULTIPLY_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_multiply_16 +, .cmr = {{0x75bd41f2u, 0xd2b339f0u, 0x69bfdfd8u, 0x02d61e6cu, 0xa8e3bad6u, 0xfb6d95b6u, 0x72095b93u, 0x345f047fu}} +, .sourceIx = ty_w32 +, .targetIx = ty_w32 +, .cost = 79 /* milli weight units */ +} +,[MULTIPLY_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_multiply_32 +, .cmr = {{0x84cbe6ceu, 0x87037992u, 0x13877c1bu, 0xd505c764u, 0x34336900u, 0x2e502c43u, 0xd97f3d57u, 0x772d6c87u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w64 +, .cost = 78 /* milli weight units */ +} +,[MULTIPLY_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_multiply_64 +, .cmr = {{0x92987b80u, 0x1b92f679u, 0xeb961368u, 0x8444a178u, 0x8750a850u, 0x6e03a921u, 0x8c21ecc7u, 0x2082dc6au}} +, .sourceIx = ty_w128 +, .targetIx = ty_w128 +, .cost = 72 /* milli weight units */ +} +,[MULTIPLY_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_multiply_8 +, .cmr = {{0x764cab71u, 0xdb9459a7u, 0x696d944au, 0x50095b1au, 0xebdfd928u, 0x4bdb7496u, 0xa7b30241u, 0xccba3eceu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w16 +, .cost = 79 /* milli weight units */ +} +,[NEGATE_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_negate_16 +, .cmr = {{0xe760ee40u, 0x29c34f89u, 0x7406ffdeu, 0xa5558486u, 0x62e89c98u, 0x3e6070bdu, 0x0272ad0fu, 0xa342efa3u}} +, .sourceIx = ty_w16 +, .targetIx = ty_pbw16 +, .cost = 69 /* milli weight units */ +} +,[NEGATE_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_negate_32 +, .cmr = {{0x8495b740u, 0x09ad07c9u, 0x302a25aeu, 0x56c3e973u, 0x3f00c2bau, 0xa410eac4u, 0xa58e75dbu, 0x83af1d22u}} +, .sourceIx = ty_w32 +, .targetIx = ty_pbw32 +, .cost = 56 /* milli weight units */ +} +,[NEGATE_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_negate_64 +, .cmr = {{0x34e89fafu, 0x345afd5eu, 0x7b290014u, 0x52fc5fc2u, 0xe3783af7u, 0xf2101643u, 0xbd76706au, 0x6fc3f36au}} +, .sourceIx = ty_w64 +, .targetIx = ty_pbw64 +, .cost = 56 /* milli weight units */ +} +,[NEGATE_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_negate_8 +, .cmr = {{0xe81be0b1u, 0x5c671ab8u, 0xdf1f4869u, 0xc57f1111u, 0x18cb6683u, 0x54975c63u, 0x66ecb2b8u, 0xbb7c15cfu}} +, .sourceIx = ty_w8 +, .targetIx = ty_pbw8 +, .cost = 69 /* milli weight units */ +} +,[NUM_INPUTS] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_num_inputs +, .cmr = {{0x5c5ac4ffu, 0x6da56cb3u, 0x72b23266u, 0x6e8334b9u, 0xe2cfb0dcu, 0xb418f161u, 0xbff149e8u, 0x4ec92c3eu}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 74 /* milli weight units */ +} +,[NUM_OUTPUTS] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_num_outputs +, .cmr = {{0x98a1cca7u, 0x05dfcfafu, 0xd3a69e9au, 0xdc05ba47u, 0xe1fefa6au, 0x29f34286u, 0x2048e496u, 0x8648c3d7u}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 68 /* milli weight units */ +} +,[ONE_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_one_16 +, .cmr = {{0x2e5e3d95u, 0xe4531688u, 0x8e4f3709u, 0xef832b9fu, 0xd9e15f30u, 0x719bf55fu, 0xc2e0e09au, 0x3657d882u}} +, .sourceIx = ty_u +, .targetIx = ty_w16 +, .cost = 45 /* milli weight units */ +} +,[ONE_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_one_32 +, .cmr = {{0x06426b85u, 0x3c1bcb33u, 0x8aedbe1fu, 0x89a6d9b7u, 0xa3da038cu, 0xd00a4471u, 0x18369349u, 0x669e2976u}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 45 /* milli weight units */ +} +,[ONE_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_one_64 +, .cmr = {{0xab1d2cd9u, 0x9678da3cu, 0x128d39adu, 0x9fe6ffa9u, 0x55c16e5eu, 0xf2c25bb4u, 0x31831559u, 0x6951f427u}} +, .sourceIx = ty_u +, .targetIx = ty_w64 +, .cost = 45 /* milli weight units */ +} +,[ONE_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_one_8 +, .cmr = {{0x3cc5f523u, 0xd6a6355du, 0xc924ee0au, 0xc1f5fe2cu, 0x521275e3u, 0xaa9f21d3u, 0x1b082db2u, 0xac230d9du}} +, .sourceIx = ty_u +, .targetIx = ty_w8 +, .cost = 46 /* milli weight units */ +} +,[OR_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_or_1 +, .cmr = {{0xc4659643u, 0x69fca209u, 0x7f83530cu, 0x87bcbc90u, 0xc306579du, 0x9f3bfeddu, 0xf4a172a4u, 0xea0b58ecu}} +, .sourceIx = ty_w2 +, .targetIx = ty_b +, .cost = 56 /* milli weight units */ +} +,[OR_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_or_16 +, .cmr = {{0x5a985e04u, 0x3b85273bu, 0x90f90e20u, 0xf82b7532u, 0x3351cf2au, 0x4e62a7f9u, 0xcb2f0596u, 0x402e9e28u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 78 /* milli weight units */ +} +,[OR_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_or_32 +, .cmr = {{0x3552383au, 0x57ffb48du, 0x63a0337au, 0xf0dd6efau, 0xb6b46c5du, 0xe1720e42u, 0x0bdd1c82u, 0x276bc9a9u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 80 /* milli weight units */ +} +,[OR_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_or_64 +, .cmr = {{0x51a173dau, 0xdca01ac6u, 0xf62e75d5u, 0xcd3522f0u, 0x9fde62b1u, 0x1513e068u, 0x422852a4u, 0x9167b606u}} +, .sourceIx = ty_w128 +, .targetIx = ty_w64 +, .cost = 71 /* milli weight units */ +} +,[OR_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_or_8 +, .cmr = {{0x79efbdcbu, 0x537bebcbu, 0x188d1116u, 0xb78a109bu, 0xffbc2a6cu, 0xe3d1f870u, 0x154a7956u, 0x091b342fu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w8 +, .cost = 81 /* milli weight units */ +} +,[OUTPOINT_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_outpoint_hash +, .cmr = {{0x3a1ae90eu, 0x167fb40du, 0x6e13b451u, 0xad67410du, 0x8dd991c8u, 0x7d6a4a59u, 0xcc76c63fu, 0x3b9e5e56u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pw256w32 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 1788 /* milli weight units */ +} +,[OUTPUT_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_output_hash +, .cmr = {{0x91211fc6u, 0x011a6493u, 0x00c6bee9u, 0x4fdd48a9u, 0x7fa2a9b6u, 0xf284be01u, 0x5d462d17u, 0xde664ac3u}} +, .sourceIx = ty_w32 +, .targetIx = ty_mw256 +, .cost = 822 /* milli weight units */ +} +,[OUTPUT_SCRIPT_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_output_script_hash +, .cmr = {{0xbdfdb231u, 0xf4f1a62cu, 0x9d7b0393u, 0x1e7f19a4u, 0x546af234u, 0x754cbf70u, 0x059fdd42u, 0xbbbc4126u}} +, .sourceIx = ty_w32 +, .targetIx = ty_mw256 +, .cost = 135 /* milli weight units */ +} +,[OUTPUT_SCRIPTS_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_output_scripts_hash +, .cmr = {{0xff20bc43u, 0x65e71707u, 0x571c6e17u, 0x38e1ed32u, 0x6f7c351du, 0xe13022aeu, 0xa3d6406bu, 0x8aee8e3bu}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 123 /* milli weight units */ +} +,[OUTPUT_VALUE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_output_value +, .cmr = {{0x933643b6u, 0xc5a6220au, 0xbbca6f35u, 0x09feff6du, 0x13efa6c9u, 0xfae95924u, 0x575364f2u, 0xb164d2bcu}} +, .sourceIx = ty_w32 +, .targetIx = ty_mw64 +, .cost = 82 /* milli weight units */ +} +,[OUTPUT_VALUES_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_output_values_hash +, .cmr = {{0x22899379u, 0x0057066fu, 0x2016971du, 0xf55e6f67u, 0xd252efb6u, 0xdaabd0fcu, 0x566a8d21u, 0x56efbbfcu}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 119 /* milli weight units */ +} +,[OUTPUTS_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_outputs_hash +, .cmr = {{0xf2eb6d0fu, 0x018e6f15u, 0xe35baa82u, 0xe57e14feu, 0x343796f2u, 0x196826beu, 0xd7c78755u, 0x98d6641du}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 117 /* milli weight units */ +} +,[PARSE_LOCK] = +{ .tag = JET +, .jet = rustsimplicity_0_6_parse_lock +, .cmr = {{0x3db84535u, 0xfa3d90efu, 0x0b581e22u, 0xb61d2127u, 0x844b2116u, 0xe84f814au, 0x5cbac52du, 0xf515f2d2u}} +, .sourceIx = ty_w32 +, .targetIx = ty_sw32w32 +, .cost = 82 /* milli weight units */ +} +,[PARSE_SEQUENCE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_parse_sequence +, .cmr = {{0x38b2533fu, 0x5fede869u, 0xbaa17069u, 0x83df4c89u, 0xd62d5f90u, 0x800b47eau, 0xb2111331u, 0x1a5aaec9u}} +, .sourceIx = ty_w32 +, .targetIx = ty_msw16w16 +, .cost = 93 /* milli weight units */ +} +,[POINT_VERIFY_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_point_verify_1 +, .cmr = {{0xbe2a9890u, 0xf1d5b615u, 0x147f8241u, 0xe0609b5cu, 0xac01ece0u, 0xa3f92368u, 0x67b2bfdeu, 0xa1b8044eu}} +, .sourceIx = ty_pppw256pbw256w256pbw256 +, .targetIx = ty_u +, .cost = 41394 /* milli weight units */ +} +,[RIGHT_EXTEND_16_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_extend_16_32 +, .cmr = {{0xdbf18d87u, 0xa7892139u, 0xa388e9a9u, 0x83c48992u, 0xac35a845u, 0x56ee0defu, 0xc1dadf0cu, 0x5f471a26u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w32 +, .cost = 73 /* milli weight units */ +} +,[RIGHT_EXTEND_16_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_extend_16_64 +, .cmr = {{0xd011acc7u, 0x94e3c478u, 0x9accd0d5u, 0xfe4997d3u, 0x34d91f08u, 0x31a1eb35u, 0x04b4cb2du, 0xdf4797afu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w64 +, .cost = 70 /* milli weight units */ +} +,[RIGHT_EXTEND_32_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_extend_32_64 +, .cmr = {{0xa5aa5db1u, 0xe535e723u, 0x2ad36dafu, 0xba6d5a20u, 0x0d54eb85u, 0x3b75dc70u, 0xa594ed64u, 0xaa6bd9abu}} +, .sourceIx = ty_w32 +, .targetIx = ty_w64 +, .cost = 62 /* milli weight units */ +} +,[RIGHT_EXTEND_8_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_extend_8_16 +, .cmr = {{0x8106d58au, 0x8066ee6eu, 0x15e55ca5u, 0x2cb7afd8u, 0xe3277587u, 0xbfd7dec0u, 0xbe37d406u, 0x742a3931u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w16 +, .cost = 63 /* milli weight units */ +} +,[RIGHT_EXTEND_8_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_extend_8_32 +, .cmr = {{0xdfa4bafau, 0x432a5338u, 0xd374deb6u, 0xb724b7f6u, 0xeae55861u, 0xfe731d43u, 0x048aa304u, 0xd1f7f9a2u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w32 +, .cost = 69 /* milli weight units */ +} +,[RIGHT_EXTEND_8_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_extend_8_64 +, .cmr = {{0x620a3703u, 0x8b6fa127u, 0x495f0b46u, 0x496f6435u, 0xdd2dad7eu, 0xf0c0fd2cu, 0xd65f54dcu, 0x185e997bu}} +, .sourceIx = ty_w8 +, .targetIx = ty_w64 +, .cost = 141 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_16_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_16_32 +, .cmr = {{0x2b6abc38u, 0x321a7c54u, 0x2fb16974u, 0x621ced80u, 0x880db519u, 0xbb486093u, 0x426e8ce1u, 0x8e0169b1u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w32 +, .cost = 66 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_16_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_16_64 +, .cmr = {{0xad90d8ffu, 0xa57450b3u, 0xb5e90962u, 0x25349ed8u, 0xf072e101u, 0x7293f392u, 0xef854e03u, 0x19abc934u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w64 +, .cost = 81 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_1_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_1_16 +, .cmr = {{0x288158b1u, 0xc910877bu, 0x7eea3dfcu, 0xf2b2b788u, 0x922808b6u, 0xd6fa75f8u, 0x96771904u, 0x8b141249u}} +, .sourceIx = ty_b +, .targetIx = ty_w16 +, .cost = 114 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_1_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_1_32 +, .cmr = {{0xee2ad77fu, 0x668d3d6au, 0x2e68506eu, 0x4904cf50u, 0xa08460e1u, 0xd2b86a81u, 0xe14e41f8u, 0xda4cddf2u}} +, .sourceIx = ty_b +, .targetIx = ty_w32 +, .cost = 220 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_1_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_1_64 +, .cmr = {{0x3d6a7fe6u, 0x9a11642au, 0xced6842bu, 0x89aa1bb8u, 0x413e3990u, 0x63cc1678u, 0x6af7c033u, 0xdad58b95u}} +, .sourceIx = ty_b +, .targetIx = ty_w64 +, .cost = 313 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_1_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_1_8 +, .cmr = {{0x2844bdfdu, 0x6aba29dfu, 0x03f93aa6u, 0xaeb21c06u, 0x4028db05u, 0xff77d8d9u, 0x1cfdcdefu, 0xb190c5bdu}} +, .sourceIx = ty_b +, .targetIx = ty_w8 +, .cost = 73 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_32_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_32_64 +, .cmr = {{0xb432e532u, 0x1ae1714cu, 0xe19529d8u, 0x5f24ff89u, 0x87910ebcu, 0xf015f87fu, 0x15bbed55u, 0xf0a0e892u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w64 +, .cost = 62 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_8_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_8_16 +, .cmr = {{0x6f2d96c9u, 0x5413ca9au, 0xa8cc550fu, 0x2573e166u, 0x9956d607u, 0x692cf1cau, 0x6dc76d2fu, 0x2b4a3ac8u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w16 +, .cost = 75 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_8_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_8_32 +, .cmr = {{0xdf2c7f92u, 0x9900a449u, 0x01e6ff65u, 0x276a951au, 0xeb95df25u, 0x0b139714u, 0xd4195404u, 0xd77898edu}} +, .sourceIx = ty_w8 +, .targetIx = ty_w32 +, .cost = 81 /* milli weight units */ +} +,[RIGHT_PAD_HIGH_8_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_high_8_64 +, .cmr = {{0x79c01da3u, 0xe60b9c69u, 0x35ce3e15u, 0x98b17840u, 0xaf82dcb0u, 0xddc63aefu, 0x4a06e7f9u, 0xca5d2741u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w64 +, .cost = 118 /* milli weight units */ +} +,[RIGHT_PAD_LOW_16_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_16_32 +, .cmr = {{0x6f201027u, 0xcc759802u, 0x30a07085u, 0x9c3e3802u, 0x36a1cb10u, 0xe61a01aau, 0x1f6d231du, 0x15142f25u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w32 +, .cost = 62 /* milli weight units */ +} +,[RIGHT_PAD_LOW_16_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_16_64 +, .cmr = {{0xb86e1f0bu, 0xfec65598u, 0xd0a3d1ecu, 0x960305b9u, 0x6745673eu, 0x1b16bf32u, 0x7a716805u, 0x83d71d90u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w64 +, .cost = 98 /* milli weight units */ +} +,[RIGHT_PAD_LOW_1_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_1_16 +, .cmr = {{0x052a6499u, 0xc93ee6bcu, 0x1ae657f8u, 0x5fd4d4feu, 0x677abceeu, 0x540d1340u, 0x33542e9au, 0xb60a63ddu}} +, .sourceIx = ty_b +, .targetIx = ty_w16 +, .cost = 60 /* milli weight units */ +} +,[RIGHT_PAD_LOW_1_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_1_32 +, .cmr = {{0x5b70d428u, 0x960e95ccu, 0x40d51846u, 0xf53a4d0au, 0x35c9015du, 0x1500b6bcu, 0x849b7283u, 0x5e2bd440u}} +, .sourceIx = ty_b +, .targetIx = ty_w32 +, .cost = 47 /* milli weight units */ +} +,[RIGHT_PAD_LOW_1_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_1_64 +, .cmr = {{0x44efeb87u, 0xca2ad7fdu, 0x4b73f163u, 0x07c7f059u, 0x02656f35u, 0x090fb0a4u, 0x326c6489u, 0x88ae1d39u}} +, .sourceIx = ty_b +, .targetIx = ty_w64 +, .cost = 57 /* milli weight units */ +} +,[RIGHT_PAD_LOW_1_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_1_8 +, .cmr = {{0x9340398bu, 0xcc8ea83eu, 0xc840be72u, 0x9dbb8b81u, 0x207824eeu, 0x875d1582u, 0x59d6dad2u, 0x0a83930cu}} +, .sourceIx = ty_b +, .targetIx = ty_w8 +, .cost = 48 /* milli weight units */ +} +,[RIGHT_PAD_LOW_32_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_32_64 +, .cmr = {{0x693e2810u, 0x1e04fda4u, 0x3b97e611u, 0xf0fe9800u, 0x0e14302eu, 0x5dcd6ed6u, 0x5eee42e3u, 0x4014242fu}} +, .sourceIx = ty_w32 +, .targetIx = ty_w64 +, .cost = 74 /* milli weight units */ +} +,[RIGHT_PAD_LOW_8_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_8_16 +, .cmr = {{0x096b25c3u, 0xc8415f04u, 0xd8832743u, 0xeb2f8456u, 0xd5f0a644u, 0x913d3ec5u, 0x9d34f455u, 0x2501fa20u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w16 +, .cost = 62 /* milli weight units */ +} +,[RIGHT_PAD_LOW_8_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_8_32 +, .cmr = {{0xfc7f5722u, 0xa62aa220u, 0x18cc81cdu, 0x00a9326cu, 0x7fe9c63au, 0xbce2bda4u, 0xc0e66a3fu, 0x47c67c53u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w32 +, .cost = 69 /* milli weight units */ +} +,[RIGHT_PAD_LOW_8_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_pad_low_8_64 +, .cmr = {{0xa5bb7d5eu, 0xfca0e48du, 0x9d80c502u, 0x7115b485u, 0x781051e0u, 0xef46e4d6u, 0x08317a1cu, 0x4261bc46u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w64 +, .cost = 98 /* milli weight units */ +} +,[RIGHT_ROTATE_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_rotate_16 +, .cmr = {{0x482ea7e1u, 0x214501d9u, 0x3c9ad16fu, 0xa8b97bf5u, 0xb384fc2bu, 0x54789b8cu, 0xd9e784ccu, 0xd0eb9d57u}} +, .sourceIx = ty_pw4w16 +, .targetIx = ty_w16 +, .cost = 67 /* milli weight units */ +} +,[RIGHT_ROTATE_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_rotate_32 +, .cmr = {{0x0941b6eeu, 0xea9af819u, 0x5b028afcu, 0x0bd2a534u, 0x218bf90du, 0x1a0e373du, 0x74741854u, 0x0b726d73u}} +, .sourceIx = ty_pw8w32 +, .targetIx = ty_w32 +, .cost = 77 /* milli weight units */ +} +,[RIGHT_ROTATE_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_rotate_64 +, .cmr = {{0x444dbbc3u, 0xdd2a11a5u, 0xc7b0439fu, 0xdba99ac7u, 0x4a11b8eeu, 0xb2db301eu, 0x243ea891u, 0x22907152u}} +, .sourceIx = ty_pw8w64 +, .targetIx = ty_w64 +, .cost = 64 /* milli weight units */ +} +,[RIGHT_ROTATE_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_rotate_8 +, .cmr = {{0x7265a30cu, 0x2e836e65u, 0x544aba91u, 0x1b64d18fu, 0xa69b1765u, 0x45856c77u, 0xc4f0d76fu, 0xc3f58351u}} +, .sourceIx = ty_pw4w8 +, .targetIx = ty_w8 +, .cost = 72 /* milli weight units */ +} +,[RIGHT_SHIFT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_shift_16 +, .cmr = {{0xcd57a3d3u, 0xab2d92d4u, 0xf0865504u, 0x3a8b8bb6u, 0x738981fau, 0xe6da0134u, 0xb4dedaceu, 0x5f008860u}} +, .sourceIx = ty_pw4w16 +, .targetIx = ty_w16 +, .cost = 60 /* milli weight units */ +} +,[RIGHT_SHIFT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_shift_32 +, .cmr = {{0xd6b326b1u, 0xa32357a3u, 0x32807d3fu, 0xa1b156c2u, 0x8b1622f7u, 0x38def126u, 0x81467f34u, 0x9bd3494bu}} +, .sourceIx = ty_pw8w32 +, .targetIx = ty_w32 +, .cost = 69 /* milli weight units */ +} +,[RIGHT_SHIFT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_shift_64 +, .cmr = {{0xb2095f2du, 0x47335d5fu, 0x98c85434u, 0xa2faf5b0u, 0xf75cf899u, 0x012a34bbu, 0xcd0a14cbu, 0xedb61107u}} +, .sourceIx = ty_pw8w64 +, .targetIx = ty_w64 +, .cost = 68 /* milli weight units */ +} +,[RIGHT_SHIFT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_shift_8 +, .cmr = {{0x4b2b1aa2u, 0xef732173u, 0x170d621au, 0x38deb261u, 0xe473c07cu, 0x558b055au, 0x25a86e4eu, 0x321afc04u}} +, .sourceIx = ty_pw4w8 +, .targetIx = ty_w8 +, .cost = 63 /* milli weight units */ +} +,[RIGHT_SHIFT_WITH_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_shift_with_16 +, .cmr = {{0x14b77685u, 0x47b3d3f4u, 0x7ee5c2b8u, 0x0d9bdae2u, 0xaec1f9c6u, 0x594ed312u, 0x7b12645au, 0xdcf59754u}} +, .sourceIx = ty_pbpw4w16 +, .targetIx = ty_w16 +, .cost = 83 /* milli weight units */ +} +,[RIGHT_SHIFT_WITH_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_shift_with_32 +, .cmr = {{0x327b6e98u, 0xa6fd340cu, 0x60cf83aau, 0x64993311u, 0x4cb8d84fu, 0x590e0121u, 0x3a261001u, 0x2b4607eau}} +, .sourceIx = ty_pbpw8w32 +, .targetIx = ty_w32 +, .cost = 78 /* milli weight units */ +} +,[RIGHT_SHIFT_WITH_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_shift_with_64 +, .cmr = {{0x062fa74au, 0xf3476e59u, 0x387be08eu, 0x6949a005u, 0x43bc84a2u, 0xb689ea39u, 0xad6eed7fu, 0x756785d4u}} +, .sourceIx = ty_pbpw8w64 +, .targetIx = ty_w64 +, .cost = 72 /* milli weight units */ +} +,[RIGHT_SHIFT_WITH_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_right_shift_with_8 +, .cmr = {{0x141be47eu, 0x967b2fd7u, 0xc7126c5au, 0xdf2dfe47u, 0x315bbc10u, 0x53bbe605u, 0xb38898dbu, 0xed49f227u}} +, .sourceIx = ty_pbpw4w8 +, .targetIx = ty_w8 +, .cost = 71 /* milli weight units */ +} +,[RIGHTMOST_16_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_16_1 +, .cmr = {{0x3f3c4346u, 0x87174226u, 0x5e87f001u, 0xb46de7d1u, 0x98751b34u, 0xfaa18018u, 0xde60c846u, 0x8d9b98a4u}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 70 /* milli weight units */ +} +,[RIGHTMOST_16_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_16_2 +, .cmr = {{0xc18b9fddu, 0x340a267au, 0xc16d4f39u, 0xee754356u, 0x52aaca52u, 0x5650b51au, 0x45879804u, 0x8e627d51u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w2 +, .cost = 65 /* milli weight units */ +} +,[RIGHTMOST_16_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_16_4 +, .cmr = {{0xc6c53fa7u, 0x1e230cf0u, 0x585158f4u, 0x70588bacu, 0x5c518f84u, 0xf9fc2386u, 0x52f175fbu, 0x6ea18c11u}} +, .sourceIx = ty_w16 +, .targetIx = ty_w4 +, .cost = 72 /* milli weight units */ +} +,[RIGHTMOST_16_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_16_8 +, .cmr = {{0xee769c1cu, 0xc8a3fdd1u, 0x838fc9f0u, 0x490ce703u, 0x93fd91bau, 0x3cbd4abdu, 0x08649fb9u, 0xc44311bdu}} +, .sourceIx = ty_w16 +, .targetIx = ty_w8 +, .cost = 69 /* milli weight units */ +} +,[RIGHTMOST_32_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_32_1 +, .cmr = {{0x1c442369u, 0xfb81f611u, 0xd328010bu, 0x864bccb7u, 0xf35ed477u, 0xdfa38555u, 0x74c13564u, 0xcdbdb860u}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 70 /* milli weight units */ +} +,[RIGHTMOST_32_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_32_16 +, .cmr = {{0xadd2c339u, 0x0d9af7c2u, 0x4a159a37u, 0xd69d4484u, 0xd2c24a2cu, 0xb5b0eb2du, 0x3c493d98u, 0x12acfd74u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 56 /* milli weight units */ +} +,[RIGHTMOST_32_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_32_2 +, .cmr = {{0x00b8815au, 0xd7423dd5u, 0x8cb98be8u, 0x2cad2667u, 0x5c3bf54au, 0x0bedbadeu, 0x3464b4feu, 0x5a4e8ce6u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w2 +, .cost = 74 /* milli weight units */ +} +,[RIGHTMOST_32_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_32_4 +, .cmr = {{0x84fa5a54u, 0xf7729f9du, 0x68994beau, 0xb93ae79bu, 0x8c4a10d5u, 0xb7ae9727u, 0xaa1716e5u, 0x7d033b74u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w4 +, .cost = 57 /* milli weight units */ +} +,[RIGHTMOST_32_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_32_8 +, .cmr = {{0x7d3805d3u, 0xc78c4eeau, 0x91e3d35eu, 0xfdd47eedu, 0xd421af84u, 0xd2191032u, 0x9332a0b5u, 0x487fab63u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w8 +, .cost = 55 /* milli weight units */ +} +,[RIGHTMOST_64_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_64_1 +, .cmr = {{0xd3b164c5u, 0xdc66cc7eu, 0xf9234fedu, 0xe4dc7f0du, 0xa5cd71c1u, 0xc1d4cad6u, 0x0fb4ec57u, 0x3e2b8a75u}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 61 /* milli weight units */ +} +,[RIGHTMOST_64_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_64_16 +, .cmr = {{0xeae43478u, 0xf9f2f452u, 0xefac15eeu, 0xe60f8b52u, 0x53d80a2du, 0x32129b4eu, 0x5ba38300u, 0xad9852fdu}} +, .sourceIx = ty_w64 +, .targetIx = ty_w16 +, .cost = 63 /* milli weight units */ +} +,[RIGHTMOST_64_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_64_2 +, .cmr = {{0x9cd4a98bu, 0xbdb8a335u, 0x85c00f47u, 0xd6adab7au, 0xf54286fbu, 0x8ae60f72u, 0x3011fb84u, 0xc0ee78f9u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w2 +, .cost = 65 /* milli weight units */ +} +,[RIGHTMOST_64_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_64_32 +, .cmr = {{0x7f2420aeu, 0x5b0f5a3fu, 0x6f2e60b6u, 0x1f8a415cu, 0x088b94b2u, 0x1c1a62a3u, 0xfdaac749u, 0xdbdf4c71u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 64 /* milli weight units */ +} +,[RIGHTMOST_64_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_64_4 +, .cmr = {{0xe265552au, 0x24fbcdecu, 0x0583d718u, 0x3e48ebc2u, 0xff6d3165u, 0x57bac591u, 0x5c03cb23u, 0x35d23295u}} +, .sourceIx = ty_w64 +, .targetIx = ty_w4 +, .cost = 57 /* milli weight units */ +} +,[RIGHTMOST_64_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_64_8 +, .cmr = {{0x98cd95f9u, 0x5d46641bu, 0x049e77bfu, 0x90eea598u, 0xadf29ee5u, 0x00e65072u, 0x87548bb1u, 0xcdaf784du}} +, .sourceIx = ty_w64 +, .targetIx = ty_w8 +, .cost = 49 /* milli weight units */ +} +,[RIGHTMOST_8_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_8_1 +, .cmr = {{0x0876fcd4u, 0x698591f3u, 0x31910157u, 0x4ce153fcu, 0xdfe94f58u, 0x1aac5e75u, 0xf3cd7446u, 0xdf56f3c7u}} +, .sourceIx = ty_w8 +, .targetIx = ty_b +, .cost = 65 /* milli weight units */ +} +,[RIGHTMOST_8_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_8_2 +, .cmr = {{0xb9f7b290u, 0xafe7f189u, 0xe32aebf2u, 0xcc4ddca9u, 0x6bb00764u, 0xc7be2887u, 0xdce054d0u, 0x9e38c353u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w2 +, .cost = 63 /* milli weight units */ +} +,[RIGHTMOST_8_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_rightmost_8_4 +, .cmr = {{0xf28e9af5u, 0xaf4c9ccau, 0x4b43cc6au, 0xdf9d9d8du, 0x169c87c5u, 0x559f9f3cu, 0xcac8f235u, 0x2b629f18u}} +, .sourceIx = ty_w8 +, .targetIx = ty_w4 +, .cost = 56 /* milli weight units */ +} +,[SCALAR_ADD] = +{ .tag = JET +, .jet = rustsimplicity_0_6_scalar_add +, .cmr = {{0x11ddbebau, 0xebf42180u, 0xa0b7eddfu, 0xfdc48ec7u, 0x511330fbu, 0x3315fa65u, 0xd58aff66u, 0xb9caf2d4u}} +, .sourceIx = ty_w512 +, .targetIx = ty_w256 +, .cost = 778 /* milli weight units */ +} +,[SCALAR_INVERT] = +{ .tag = JET +, .jet = rustsimplicity_0_6_scalar_invert +, .cmr = {{0xa6392725u, 0xbb2dadbbu, 0x1e76df2du, 0xec57df55u, 0xc3fcc577u, 0x3b62218au, 0xec55a75eu, 0x14f3d60du}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 3178 /* milli weight units */ +} +,[SCALAR_IS_ZERO] = +{ .tag = JET +, .jet = rustsimplicity_0_6_scalar_is_zero +, .cmr = {{0xf75eda06u, 0xce6af09fu, 0xae37db4eu, 0x6225e6a8u, 0xac86a236u, 0x37627d62u, 0x6409190fu, 0xf3b39d90u}} +, .sourceIx = ty_w256 +, .targetIx = ty_b +, .cost = 271 /* milli weight units */ +} +,[SCALAR_MULTIPLY] = +{ .tag = JET +, .jet = rustsimplicity_0_6_scalar_multiply +, .cmr = {{0x4a61672au, 0xcec48877u, 0x56de1db6u, 0x0421a12bu, 0x901a858au, 0x6ee6352eu, 0x559d4ce5u, 0x973352beu}} +, .sourceIx = ty_w512 +, .targetIx = ty_w256 +, .cost = 793 /* milli weight units */ +} +,[SCALAR_MULTIPLY_LAMBDA] = +{ .tag = JET +, .jet = rustsimplicity_0_6_scalar_multiply_lambda +, .cmr = {{0x49ea9c3fu, 0xb1d8ff52u, 0xd2db0346u, 0x9fdfe850u, 0x503fddebu, 0x45e16d26u, 0xe8928addu, 0x25870e91u}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 567 /* milli weight units */ +} +,[SCALAR_NEGATE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_scalar_negate +, .cmr = {{0x1dbf8b49u, 0x1ec66580u, 0x3f633330u, 0xd3ffb0e7u, 0x81e67c18u, 0x01ac9d49u, 0xbbf43589u, 0xabf782bfu}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 516 /* milli weight units */ +} +,[SCALAR_NORMALIZE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_scalar_normalize +, .cmr = {{0x4633180eu, 0xa02c4df7u, 0x819d3d54u, 0xa401734fu, 0x965b31acu, 0xc784054eu, 0xbfb73168u, 0x16b029ecu}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 500 /* milli weight units */ +} +,[SCALAR_SQUARE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_scalar_square +, .cmr = {{0x8a279e6fu, 0x613aa9e9u, 0x34f2f2a3u, 0x43c0d329u, 0x1c3670e2u, 0x97ddae20u, 0x529e8250u, 0x69efea0eu}} +, .sourceIx = ty_w256 +, .targetIx = ty_w256 +, .cost = 571 /* milli weight units */ +} +,[SCALE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_scale +, .cmr = {{0x126e2212u, 0x5bac80b9u, 0x9b7b7343u, 0xb4e5e586u, 0x60821610u, 0x5d4de6f7u, 0x94add34eu, 0x23b195cau}} +, .sourceIx = ty_pw256pw512w256 +, .targetIx = ty_pw512w256 +, .cost = 73548 /* milli weight units */ +} +,[SCRIPT_CMR] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_script_cmr +, .cmr = {{0xa8a4a622u, 0x10b5e495u, 0x0e253424u, 0x7c7411d1u, 0xc8ff2286u, 0x5b5456bbu, 0xb21638e9u, 0x14f5e528u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 122 /* milli weight units */ +} +,[SHA_256_BLOCK] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_block +, .cmr = {{0x4535f3e1u, 0xab9f1b75u, 0x7a069137u, 0xe1d5b1cau, 0xad8e31f7u, 0x8dc5fbd0u, 0x734649f9u, 0x40a7fc96u}} +, .sourceIx = ty_pw256w512 +, .targetIx = ty_w256 +, .cost = 765 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_1 +, .cmr = {{0x9a4711b8u, 0xc5690e58u, 0x7e5f79e6u, 0x8d6eca04u, 0x7458aa63u, 0xb8bc9ee5u, 0x68086a4au, 0x1b56d834u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w8 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 664 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_128] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_128 +, .cmr = {{0x1cb1db8au, 0x055b3197u, 0xacf0f08cu, 0xe9c635adu, 0xd695b60fu, 0x234b18e0u, 0xb323c937u, 0xb0385aeau}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w1Ki +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 1778 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_16 +, .cmr = {{0xe0845475u, 0xebb90140u, 0xfa4e01afu, 0x8a943599u, 0x1ad87af9u, 0x8c08aeceu, 0x110e99cbu, 0xcecdee79u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w128 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 781 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_2] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_2 +, .cmr = {{0x7d69138fu, 0x1c942beeu, 0x2fdf600cu, 0xe44b36ffu, 0x97839dc2u, 0xbbdafbd5u, 0xfab4dfbcu, 0x3c976f29u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w16 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 674 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_256] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_256 +, .cmr = {{0x4f5c29d5u, 0x3686c060u, 0x62b38324u, 0xf8aff17eu, 0xc556a295u, 0xff098b10u, 0xe705dd22u, 0xe13bc3c9u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w2Ki +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 2894 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_32 +, .cmr = {{0xd57b67b1u, 0x74e78e38u, 0xf9bca8e0u, 0x7add61c7u, 0x53e2c156u, 0xd8e9832au, 0xa6620455u, 0x00f51a80u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w256 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 928 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_4] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_4 +, .cmr = {{0x95da3299u, 0x3f5c7d00u, 0x83064cdfu, 0xf1bec3b9u, 0x36c63833u, 0x7adec547u, 0x487af232u, 0xd69fdf65u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w32 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 656 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_512] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_512 +, .cmr = {{0x4acb163au, 0xa48f09d5u, 0xf26d2b2au, 0xb188a6c6u, 0xb6c4aedfu, 0x23c91900u, 0x1c02ee15u, 0xb337a96eu}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w4Ki +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 5161 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_64 +, .cmr = {{0x52e53ec5u, 0x770f9be4u, 0x069aeefcu, 0xb21322b1u, 0x3ab6e394u, 0x1fdc2c85u, 0xf4b41be6u, 0x7d38ea7eu}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w512 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 1220 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_8 +, .cmr = {{0xc26b28afu, 0xe5e866d8u, 0x4616814du, 0x1a13fb86u, 0x30b9e84eu, 0x5d781556u, 0xc6d8236eu, 0xfb45dff9u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w64 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 694 /* milli weight units */ +} +,[SHA_256_CTX_8_ADD_BUFFER_511] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_add_buffer_511 +, .cmr = {{0xad699046u, 0x48a8238du, 0x00d85163u, 0xfce81963u, 0xa0047ab5u, 0x82be97a4u, 0x14006559u, 0x79cfdd28u}} +, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8 +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 5137 /* milli weight units */ +} +,[SHA_256_CTX_8_FINALIZE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_finalize +, .cmr = {{0x8e45bdc3u, 0x87d4edfau, 0x733525f3u, 0xab19e42bu, 0x58ecb1b5u, 0xf6dccf94u, 0xedbf5995u, 0x8ae3e116u}} +, .sourceIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .targetIx = ty_w256 +, .cost = 833 /* milli weight units */ +} +,[SHA_256_CTX_8_INIT] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_ctx_8_init +, .cmr = {{0x635f6405u, 0x848685c0u, 0x11febd41u, 0xfaac874bu, 0xbbf5b24du, 0x5fb12fedu, 0xbcb6cbffu, 0x95a0f366u}} +, .sourceIx = ty_u +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 123 /* milli weight units */ +} +,[SHA_256_IV] = +{ .tag = JET +, .jet = rustsimplicity_0_6_sha_256_iv +, .cmr = {{0x12e45937u, 0x51c9463bu, 0x562503c1u, 0x40d78b3bu, 0x757a1f4fu, 0x16321d28u, 0x62d32543u, 0x8538971bu}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 92 /* milli weight units */ +} +,[SIG_ALL_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_sig_all_hash +, .cmr = {{0x0978b9e5u, 0x0b9e8e09u, 0x8b27f2b8u, 0xb59de54fu, 0x62ba7c13u, 0x33df3bedu, 0x221e2662u, 0x6805bc55u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 120 /* milli weight units */ +} +,[SOME_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_some_1 +, .cmr = {{0x15ca4e4bu, 0x82c2f91bu, 0x9a792992u, 0xcdc1b292u, 0xab86a2d2u, 0x939c9a64u, 0xb50be60bu, 0xda6ab4cau}} +, .sourceIx = ty_b +, .targetIx = ty_b +, .cost = 60 /* milli weight units */ +} +,[SOME_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_some_16 +, .cmr = {{0xa9dfbbeau, 0xb59df72au, 0x45fc3fc7u, 0xac581ec8u, 0xda713f2fu, 0x8103f787u, 0xaa1cee4eu, 0x0ba64866u}} +, .sourceIx = ty_w16 +, .targetIx = ty_b +, .cost = 52 /* milli weight units */ +} +,[SOME_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_some_32 +, .cmr = {{0x4633a397u, 0x742ef482u, 0xbe2fa3fbu, 0x6410ec79u, 0xc3738365u, 0x69fbbcb1u, 0xf948ec32u, 0x487378b7u}} +, .sourceIx = ty_w32 +, .targetIx = ty_b +, .cost = 49 /* milli weight units */ +} +,[SOME_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_some_64 +, .cmr = {{0x1dc245acu, 0x6f5b422bu, 0xd1886ef5u, 0x144c4dc7u, 0x2c967315u, 0x5966076cu, 0xd839681du, 0x9ec7f8f5u}} +, .sourceIx = ty_w64 +, .targetIx = ty_b +, .cost = 62 /* milli weight units */ +} +,[SOME_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_some_8 +, .cmr = {{0x33afb9c6u, 0x454e590eu, 0xc13ed75eu, 0x1b7d9c3au, 0x3de6752bu, 0xcc7c1d4cu, 0xb363fa51u, 0x828bcb74u}} +, .sourceIx = ty_w8 +, .targetIx = ty_b +, .cost = 57 /* milli weight units */ +} +,[SUBTRACT_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_subtract_16 +, .cmr = {{0x4e06ec31u, 0x376222e2u, 0x5e27d015u, 0x9dc1c071u, 0x4a44ca6au, 0xacf9505cu, 0xaad280e9u, 0x73fb5cabu}} +, .sourceIx = ty_w32 +, .targetIx = ty_pbw16 +, .cost = 93 /* milli weight units */ +} +,[SUBTRACT_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_subtract_32 +, .cmr = {{0xb9c0f36eu, 0x7522a8d9u, 0x49050d51u, 0x6a05ce20u, 0x3a1f9a9eu, 0x372fd263u, 0xde38b0e9u, 0x03134198u}} +, .sourceIx = ty_w64 +, .targetIx = ty_pbw32 +, .cost = 87 /* milli weight units */ +} +,[SUBTRACT_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_subtract_64 +, .cmr = {{0x1cdb5c74u, 0xadd102f5u, 0x0f938ed8u, 0x86f496e5u, 0xbab2755cu, 0x3c484e88u, 0x87903d2fu, 0x6a57f3aau}} +, .sourceIx = ty_w128 +, .targetIx = ty_pbw64 +, .cost = 125 /* milli weight units */ +} +,[SUBTRACT_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_subtract_8 +, .cmr = {{0x4f2117a0u, 0xe81059ffu, 0x0cd64d84u, 0x886542e5u, 0x75ea8d6eu, 0xc03108fdu, 0x0b508b39u, 0x208cd0efu}} +, .sourceIx = ty_w16 +, .targetIx = ty_pbw8 +, .cost = 96 /* milli weight units */ +} +,[SWU] = +{ .tag = JET +, .jet = rustsimplicity_0_6_swu +, .cmr = {{0x00f51f4fu, 0x4bece790u, 0x03ecad48u, 0x1a125af7u, 0x176e4de9u, 0x8c339242u, 0x5cb91466u, 0x26c13b3bu}} +, .sourceIx = ty_w256 +, .targetIx = ty_w512 +, .cost = 32780 /* milli weight units */ +} +,[TAP_ENV_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tap_env_hash +, .cmr = {{0x19d9944cu, 0x4d457c70u, 0xbabc45ccu, 0xcbd573b3u, 0x9a51d0c9u, 0x9115b412u, 0x783b4900u, 0x82fd0e58u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 120 /* milli weight units */ +} +,[TAPDATA_INIT] = +{ .tag = JET +, .jet = rustsimplicity_0_6_tapdata_init +, .cmr = {{0xa4d022efu, 0x5cf467bcu, 0xa0325e46u, 0x3fcace7cu, 0xbdd64ff8u, 0xf71c5c7fu, 0x63e60784u, 0xaa0ac486u}} +, .sourceIx = ty_u +, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256 +, .cost = 1233 /* milli weight units */ +} +,[TAPLEAF_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tapleaf_hash +, .cmr = {{0x0c0716feu, 0x5d978ea8u, 0xe0c75adcu, 0x8210d660u, 0x062e3da0u, 0x6f1a6661u, 0x317927d3u, 0xb84b5073u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 116 /* milli weight units */ +} +,[TAPLEAF_VERSION] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tapleaf_version +, .cmr = {{0xe2ecb1cbu, 0x0ed4ed93u, 0x483545fdu, 0x8a62f8aau, 0x10175349u, 0xffcc5ad3u, 0xde7f3484u, 0xea1f103fu}} +, .sourceIx = ty_u +, .targetIx = ty_w8 +, .cost = 66 /* milli weight units */ +} +,[TAPPATH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tappath +, .cmr = {{0x99e8211eu, 0x8c1be6d9u, 0xca98d3d4u, 0x3d914256u, 0x7e06a840u, 0x22393303u, 0xfab0b57du, 0x394074e8u}} +, .sourceIx = ty_w8 +, .targetIx = ty_mw256 +, .cost = 76 /* milli weight units */ +} +,[TAPPATH_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tappath_hash +, .cmr = {{0x0211546du, 0x0778e787u, 0x141ece65u, 0xdf6cd1dbu, 0x31388fc1u, 0x421968c8u, 0xcfd8d759u, 0x26db47b3u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 123 /* milli weight units */ +} +,[TOTAL_INPUT_VALUE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_total_input_value +, .cmr = {{0x81287a15u, 0x89ddc217u, 0x9926b706u, 0x5e9b2677u, 0xb7fb099bu, 0x95f947a7u, 0xdd590cddu, 0x4ccf4a56u}} +, .sourceIx = ty_u +, .targetIx = ty_w64 +, .cost = 69 /* milli weight units */ +} +,[TOTAL_OUTPUT_VALUE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_total_output_value +, .cmr = {{0xba032f3eu, 0x62f8fcb0u, 0x4b0429a2u, 0x53b5ec57u, 0xe4c87ae2u, 0xe951e145u, 0xd7650e7fu, 0x0c63e555u}} +, .sourceIx = ty_u +, .targetIx = ty_w64 +, .cost = 71 /* milli weight units */ +} +,[TRANSACTION_ID] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_transaction_id +, .cmr = {{0x5c49ea98u, 0x6b328be2u, 0xa4e0b315u, 0xb6b3fef2u, 0x3c1f6856u, 0xbbc3b056u, 0xc99cf59fu, 0xbd546e65u}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 122 /* milli weight units */ +} +,[TX_HASH] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tx_hash +, .cmr = {{0x54e53c99u, 0x93abd55du, 0x1f8523d2u, 0xbb217b32u, 0xe6fe861fu, 0x84c986b7u, 0xee8bdc68u, 0x8106874au}} +, .sourceIx = ty_u +, .targetIx = ty_w256 +, .cost = 119 /* milli weight units */ +} +,[TX_IS_FINAL] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tx_is_final +, .cmr = {{0x7b0e4f4cu, 0xa8e5af61u, 0xa1d3454eu, 0x11ef9ab6u, 0x88706121u, 0x1c0090ebu, 0xa9553da2u, 0xe45d8473u}} +, .sourceIx = ty_u +, .targetIx = ty_b +, .cost = 62 /* milli weight units */ +} +,[TX_LOCK_DISTANCE] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tx_lock_distance +, .cmr = {{0x8c0b0c44u, 0x2bc20978u, 0xfa4c2b3du, 0x52a7fe7cu, 0x3f86e3d2u, 0x1b42130eu, 0xbb8dba45u, 0xe0f5e64bu}} +, .sourceIx = ty_u +, .targetIx = ty_w16 +, .cost = 72 /* milli weight units */ +} +,[TX_LOCK_DURATION] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tx_lock_duration +, .cmr = {{0x09b18d5cu, 0x2f08402bu, 0xbcf8c31eu, 0xa43435efu, 0xffd9ea0eu, 0xf8758f76u, 0xbb27272bu, 0x4d60dc62u}} +, .sourceIx = ty_u +, .targetIx = ty_w16 +, .cost = 66 /* milli weight units */ +} +,[TX_LOCK_HEIGHT] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tx_lock_height +, .cmr = {{0x449f61dfu, 0x1a7bad8du, 0x9e0a9667u, 0x14227e57u, 0x1007f93cu, 0x517b805du, 0x616510e8u, 0xff62172bu}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 72 /* milli weight units */ +} +,[TX_LOCK_TIME] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_tx_lock_time +, .cmr = {{0x31df363fu, 0x17b2cfc9u, 0x7a1f9372u, 0xc14a3258u, 0x64d7cb13u, 0xaa8d5215u, 0xfb253d33u, 0x10917762u}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 72 /* milli weight units */ +} +,[VERIFY] = +{ .tag = JET +, .jet = rustsimplicity_0_6_verify +, .cmr = {{0xcdca2a05u, 0xe52cefa5u, 0x9dc7a5b0u, 0xdae22098u, 0xfb896e39u, 0x13bfdd44u, 0x6b594e1fu, 0x9250783eu}} +, .sourceIx = ty_b +, .targetIx = ty_u +, .cost = 44 /* milli weight units */ +} +,[VERSION] = +{ .tag = JET +, .jet = rustsimplicity_0_6_bitcoin_version +, .cmr = {{0x83735864u, 0x00b6790bu, 0x46ab0410u, 0x523cf01eu, 0xb74d10fau, 0xf48a3accu, 0x86c4c51du, 0x06a52c49u}} +, .sourceIx = ty_u +, .targetIx = ty_w32 +, .cost = 78 /* milli weight units */ +} +,[XOR_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_1 +, .cmr = {{0x8c4e4e6eu, 0xbf4630b2u, 0x9b5a57eau, 0x79f0c9afu, 0x6bff54c4u, 0xd2d769bfu, 0x51594774u, 0xa52b99c9u}} +, .sourceIx = ty_w2 +, .targetIx = ty_b +, .cost = 60 /* milli weight units */ +} +,[XOR_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_16 +, .cmr = {{0xd9f0af3fu, 0xe3fd247cu, 0x1df34a25u, 0x2713b2e9u, 0x33a945a5u, 0x6719487fu, 0x8ed7f563u, 0xea861ab5u}} +, .sourceIx = ty_w32 +, .targetIx = ty_w16 +, .cost = 73 /* milli weight units */ +} +,[XOR_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_32 +, .cmr = {{0xd5ae2712u, 0xedeaf676u, 0x520fa3bau, 0x0f40bf4au, 0x1657437eu, 0xffbd9986u, 0xd06ae81bu, 0x29a4f98cu}} +, .sourceIx = ty_w64 +, .targetIx = ty_w32 +, .cost = 77 /* milli weight units */ +} +,[XOR_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_64 +, .cmr = {{0xc4df1ccfu, 0x333edebdu, 0xd40dea9au, 0x0e6cbb83u, 0x0631e83au, 0x94bb779fu, 0xe6007bc6u, 0xcb53a544u}} +, .sourceIx = ty_w128 +, .targetIx = ty_w64 +, .cost = 68 /* milli weight units */ +} +,[XOR_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_8 +, .cmr = {{0x4ab14a81u, 0x4a39528au, 0x80fdb430u, 0x589ba450u, 0x104b9c72u, 0x09aa2fe2u, 0x85cd60c0u, 0x9043114au}} +, .sourceIx = ty_w16 +, .targetIx = ty_w8 +, .cost = 80 /* milli weight units */ +} +,[XOR_XOR_1] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_xor_1 +, .cmr = {{0x18b9446au, 0x4166a3feu, 0xe2bcb254u, 0x5bb90118u, 0xdcf0e8f8u, 0x86a1076du, 0x4c386006u, 0x0cde1a51u}} +, .sourceIx = ty_pbw2 +, .targetIx = ty_b +, .cost = 50 /* milli weight units */ +} +,[XOR_XOR_16] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_xor_16 +, .cmr = {{0x946cde87u, 0x2e30e650u, 0x9daff405u, 0xf0e0fefeu, 0x275547b4u, 0x0eb20384u, 0xafe9a863u, 0x60fc80efu}} +, .sourceIx = ty_pw16w32 +, .targetIx = ty_w16 +, .cost = 82 /* milli weight units */ +} +,[XOR_XOR_32] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_xor_32 +, .cmr = {{0x6527df67u, 0xa50d148du, 0xb4fc8feeu, 0xc7845564u, 0x99a8c7f0u, 0xfa7d28e6u, 0x278e997fu, 0x4959be39u}} +, .sourceIx = ty_pw32w64 +, .targetIx = ty_w32 +, .cost = 82 /* milli weight units */ +} +,[XOR_XOR_64] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_xor_64 +, .cmr = {{0xf162f9e6u, 0x5663a69au, 0xc5f92a5eu, 0xb52c0332u, 0x392edd1eu, 0xd1ba355eu, 0x6f19406eu, 0xabe3f6edu}} +, .sourceIx = ty_pw64w128 +, .targetIx = ty_w64 +, .cost = 80 /* milli weight units */ +} +,[XOR_XOR_8] = +{ .tag = JET +, .jet = rustsimplicity_0_6_xor_xor_8 +, .cmr = {{0xe06d694cu, 0x5b407ddau, 0xd7aa1f88u, 0x0716bcb7u, 0x0acdba75u, 0x85ca4009u, 0x9a0a0a61u, 0xf3ad2db5u}} +, .sourceIx = ty_pw8w16 +, .targetIx = ty_w8 +, .cost = 86 /* milli weight units */ +} diff --git a/simplicity-sys/depend/simplicity/bitcoin/txEnv.c b/simplicity-sys/depend/simplicity/bitcoin/txEnv.c new file mode 100644 index 00000000..7da56a55 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/txEnv.c @@ -0,0 +1,22 @@ +#include "txEnv.h" + +/* Construct a txEnv structure from its components. + * This function will precompute any cached values. + * + * Precondition: NULL != tx + * NULL != taproot + * ix < tx->numInputs + */ +txEnv rustsimplicity_0_6_bitcoin_build_txEnv(const bitcoinTransaction* tx, const bitcoinTapEnv* taproot, uint_fast32_t ix) { + txEnv result = { .tx = tx + , .taproot = taproot + , .ix = ix + }; + sha256_context ctx = sha256_init(result.sigAllHash.s); + sha256_hash(&ctx, &tx->txHash); + sha256_hash(&ctx, &taproot->tapEnvHash); + sha256_u32be(&ctx, ix); + sha256_finalize(&ctx); + + return result; +} diff --git a/simplicity-sys/depend/simplicity/bitcoin/txEnv.h b/simplicity-sys/depend/simplicity/bitcoin/txEnv.h new file mode 100644 index 00000000..12d2d6f0 --- /dev/null +++ b/simplicity-sys/depend/simplicity/bitcoin/txEnv.h @@ -0,0 +1,109 @@ +/* This module defines the environment ('txEnv') for Simplicity evaluation for Bitcoin. + * It includes the transaction data and input index of the input whose Simplicity program is being executed. + * It also includes the commitment Merkle root of the program being executed. + */ +#ifndef SIMPLICITY_BITCOIN_TXENV_H +#define SIMPLICITY_BITCOIN_TXENV_H + +#include +#include "../sha256.h" + +/* An Bitcoin 'outpoint' consists of a transaction id and output index within that transaction. + */ +typedef struct outpoint { + sha256_midstate txid; + uint_fast32_t ix; +} outpoint; + +/* A structure representing data from one output from a Bitcoin transaction. + * 'scriptPubKey' is the SHA-256 hash of the outputs scriptPubKey. + */ +typedef struct sigOutput { + uint_fast64_t value; + sha256_midstate scriptPubKey; +} sigOutput; + +/* A structure representing data from one input from a Bitcoin transaction along with the utxo data of the output being redeemed. + * When 'hasAnnex' then 'annexHash' is a cache of the hash of the input's segwit annex. + */ +typedef struct sigInput { + sha256_midstate annexHash; + sha256_midstate scriptSigHash; + outpoint prevOutpoint; + sigOutput txo; + uint_fast32_t sequence; + bool hasAnnex; +} sigInput; + +/* A structure representing data from a Bitcoin transaction (along with the utxo data of the outputs being redeemed). + * Includes a variety of cached hash values that are used in signature hash jets. + */ +typedef struct bitcoinTransaction { + const sigInput* input; + const sigOutput* output; + sha256_midstate outputValuesHash; + sha256_midstate outputScriptsHash; + sha256_midstate outputsHash; + sha256_midstate inputOutpointsHash; + sha256_midstate inputValuesHash; + sha256_midstate inputScriptsHash; + sha256_midstate inputUTXOsHash; + sha256_midstate inputSequencesHash; + sha256_midstate inputAnnexesHash; + sha256_midstate inputScriptSigsHash; + sha256_midstate inputsHash; + sha256_midstate txHash; + sha256_midstate txid; + uint_fast64_t totalInputValue; + uint_fast64_t totalOutputValue; + uint_fast32_t numInputs; + uint_fast32_t numOutputs; + uint_fast32_t version; + uint_fast32_t lockTime; + /* lockDuration and lockDistance values are set even when the version is 0 or 1. + * This is similar to lockTime whose value is also set, even when the transaction is final. + */ + uint_fast16_t lockDistance; + uint_fast16_t lockDuration; /* Units of 512 seconds */ + bool isFinal; +} bitcoinTransaction; + +/* A structure representing taproot spending data from a Bitcoin transaction. + * + * Invariant: pathLen <= 128 + * sha256_midstate path[pathLen]; + */ +typedef struct bitcoinTapEnv { + const sha256_midstate *path; + sha256_midstate tapLeafHash; + sha256_midstate tappathHash; + sha256_midstate tapEnvHash; + sha256_midstate internalKey; + sha256_midstate scriptCMR; + unsigned char pathLen; + unsigned char leafVersion; +} bitcoinTapEnv; + +/* The 'txEnv' structure used by the Bitcoin application of Simplicity. + * + * It includes + * + the transaction data, which may be shared when Simplicity expressions are used for multiple inputs in the same transaction), + * + the input index under consideration, + */ +typedef struct txEnv { + const bitcoinTransaction* tx; + const bitcoinTapEnv* taproot; + sha256_midstate sigAllHash; + uint_fast32_t ix; +} txEnv; + +/* Construct a txEnv structure from its components. + * This function will precompute any cached values. + * + * Precondition: NULL != tx + * NULL != taproot + * ix < tx->numInputs + */ +txEnv rustsimplicity_0_6_bitcoin_build_txEnv(const bitcoinTransaction* tx, const bitcoinTapEnv* taproot, uint_fast32_t ix); + +#endif diff --git a/simplicity-sys/depend/simplicity/cmr.c b/simplicity-sys/depend/simplicity/cmr.c new file mode 100644 index 00000000..eb7c2a39 --- /dev/null +++ b/simplicity-sys/depend/simplicity/cmr.c @@ -0,0 +1,41 @@ +#include "cmr.h" + +#include "limitations.h" +#include "simplicity_alloc.h" +#include "simplicity_assert.h" + +/* Deserialize a Simplicity 'program' and compute its CMR. + * + * Caution: no typechecking is performed, only a well-formedness check. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If the operation completes successfully then '*error' is set to 'SIMPLICITY_NO_ERROR', and the 'cmr' array is filled in with the program's computed CMR. + * + * Precondition: NULL != error; + * unsigned char cmr[32] + * unsigned char program[program_len] + */ +bool rustsimplicity_0_6_computeCmr( simplicity_err* error, unsigned char* cmr, rustsimplicity_0_6_callback_decodeJet decodeJet + , const unsigned char* program, size_t program_len) { + rustsimplicity_0_6_assert(NULL != error); + rustsimplicity_0_6_assert(NULL != cmr); + rustsimplicity_0_6_assert(NULL != program || 0 == program_len); + + bitstream stream = initializeBitstream(program, program_len); + dag_node* dag = NULL; + int_fast32_t dag_len = rustsimplicity_0_6_decodeMallocDag(&dag, decodeJet, NULL, &stream); + if (dag_len <= 0) { + rustsimplicity_0_6_assert(dag_len < 0); + *error = (simplicity_err)dag_len; + } else { + rustsimplicity_0_6_assert(NULL != dag); + rustsimplicity_0_6_assert((uint_fast32_t)dag_len <= DAG_LEN_MAX); + *error = rustsimplicity_0_6_closeBitstream(&stream); + sha256_fromMidstate(cmr, dag[dag_len-1].cmr.s); + } + + rustsimplicity_0_6_free(dag); + return IS_PERMANENT(*error); +} diff --git a/simplicity-sys/depend/simplicity/cmr.h b/simplicity-sys/depend/simplicity/cmr.h new file mode 100644 index 00000000..8e7762f6 --- /dev/null +++ b/simplicity-sys/depend/simplicity/cmr.h @@ -0,0 +1,24 @@ +#ifndef SIMPLICITY_CMR_H +#define SIMPLICITY_CMR_H + +#include +#include +#include +#include "deserialize.h" + +/* Deserialize a Simplicity 'program' and compute its CMR. + * + * Caution: no typechecking is performed, only a well-formedness check. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If the operation completes successfully then '*error' is set to 'SIMPLICITY_NO_ERROR', and the 'cmr' array is filled in with the program's computed CMR. + * + * Precondition: NULL != error; + * unsigned char cmr[32] + * unsigned char program[program_len] + */ +extern bool rustsimplicity_0_6_computeCmr( simplicity_err* error, unsigned char* cmr, rustsimplicity_0_6_callback_decodeJet decodeJet + , const unsigned char* program, size_t program_len); +#endif diff --git a/simplicity-sys/depend/simplicity/elements/cmr.c b/simplicity-sys/depend/simplicity/elements/cmr.c index 21a4c59d..f81b01b0 100644 --- a/simplicity-sys/depend/simplicity/elements/cmr.c +++ b/simplicity-sys/depend/simplicity/elements/cmr.c @@ -1,9 +1,6 @@ #include -#include "../deserialize.h" -#include "../limitations.h" -#include "../simplicity_alloc.h" -#include "../simplicity_assert.h" +#include "../cmr.h" #include "primitive.h" /* Deserialize a Simplicity 'program' and compute its CMR. @@ -21,23 +18,5 @@ */ bool rustsimplicity_0_6_elements_computeCmr( simplicity_err* error, unsigned char* cmr , const unsigned char* program, size_t program_len) { - rustsimplicity_0_6_assert(NULL != error); - rustsimplicity_0_6_assert(NULL != cmr); - rustsimplicity_0_6_assert(NULL != program || 0 == program_len); - - bitstream stream = initializeBitstream(program, program_len); - dag_node* dag = NULL; - int_fast32_t dag_len = rustsimplicity_0_6_decodeMallocDag(&dag, rustsimplicity_0_6_elements_decodeJet, NULL, &stream); - if (dag_len <= 0) { - rustsimplicity_0_6_assert(dag_len < 0); - *error = (simplicity_err)dag_len; - } else { - rustsimplicity_0_6_assert(NULL != dag); - rustsimplicity_0_6_assert((uint_fast32_t)dag_len <= DAG_LEN_MAX); - *error = rustsimplicity_0_6_closeBitstream(&stream); - sha256_fromMidstate(cmr, dag[dag_len-1].cmr.s); - } - - rustsimplicity_0_6_free(dag); - return IS_PERMANENT(*error); + return rustsimplicity_0_6_computeCmr(error, cmr, rustsimplicity_0_6_elements_decodeJet, program, program_len); } diff --git a/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/cmr.h b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/cmr.h new file mode 100644 index 00000000..4611f7b4 --- /dev/null +++ b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/cmr.h @@ -0,0 +1,23 @@ +#ifndef SIMPLICITY_BITCOIN_CMR_H +#define SIMPLICITY_BITCOIN_CMR_H + +#include +#include +#include + +/* Deserialize a Simplicity 'program' and compute its CMR. + * + * Caution: no typechecking is performed, only a well-formedness check. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If the operation completes successfully then '*error' is set to 'SIMPLICITY_NO_ERROR', and the 'cmr' array is filled in with the program's computed CMR. + * + * Precondition: NULL != error; + * unsigned char cmr[32] + * unsigned char program[program_len] + */ +extern bool rustsimplicity_0_6_bitcoin_computeCmr( simplicity_err* error, unsigned char* cmr + , const unsigned char* program, size_t program_len); +#endif diff --git a/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/env.h b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/env.h new file mode 100644 index 00000000..0cb253f7 --- /dev/null +++ b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/env.h @@ -0,0 +1,98 @@ +#ifndef SIMPLICITY_BITCOIN_ENV_H +#define SIMPLICITY_BITCOIN_ENV_H + +#include +#include + +/* This section builds the 'rawBitcoinTransaction' structure which is the transaction data needed to build a Bitcoin 'txEnv' environment + * for evaluating Simplicity expressions within. + * The 'rawBitcoinTransaction' is copied into an opaque 'bitcoinTransaction' structure that can be reused within evaluating Simplicity on multiple + * inputs within the same transaction. + */ + +/* A type for an unparsed buffer + * + * Invariant: if 0 < len then unsigned char buf[len] + */ +typedef struct rawBitcoinBuffer { + const unsigned char* buf; + uint32_t len; +} rawBitcoinBuffer; + +/* A structure representing data for one output from a Bitcoin transaction. + */ +typedef struct rawBitcoinOutput { + uint64_t value; + rawBitcoinBuffer scriptPubKey; +} rawBitcoinOutput; + +/* A structure representing data for one input from a Bitcoin transaction, including its taproot annex, + * plus the TXO data of the output being redeemed. + * + * Invariant: unsigned char prevTxid[32]; + */ +typedef struct rawInput { + const rawBitcoinBuffer* annex; + const unsigned char* prevTxid; + rawBitcoinOutput txo; + rawBitcoinBuffer scriptSig; + uint32_t prevIx; + uint32_t sequence; +} rawBitcoinInput; + +/* A structure representing data for a Bitcoin transaction, including the TXO data of each output being redeemed. + * + * Invariant: unsigned char txid[32]; + * rawBitcoinInput input[numInputs]; + * rawBitcoinOutput output[numOutputs]; + */ +typedef struct rawBitcoinTransaction { + const unsigned char* txid; /* While in theory we could recompute the txid ourselves, it is easier and safer for it to be provided. */ + const rawBitcoinInput* input; + const rawBitcoinOutput* output; + uint32_t numInputs; + uint32_t numOutputs; + uint32_t version; + uint32_t lockTime; +} rawBitcoinTransaction; + +/* A forward declaration for the structure containing a copy (and digest) of the rawTransaction data */ +typedef struct bitcoinTransaction bitcoinTransaction; + +/* Allocate and initialize a 'bitcoinTransaction' from a 'rawBitcoinTransaction', copying or hashing the data as needed. + * Returns NULL if malloc fails (or if malloc cannot be called because we require an allocation larger than SIZE_MAX). + * + * Precondition: NULL != rawTx + */ +extern bitcoinTransaction* rustsimplicity_0_6_bitcoin_mallocTransaction(const rawBitcoinTransaction* rawTx); + +/* Free a pointer to 'bitcoinTransaction'. + */ +extern void rustsimplicity_0_6_bitcoin_freeTransaction(bitcoinTransaction* tx); + +/* A structure representing taproot spending data for a Bitcoin transaction. + * + * Invariant: pathLen <= 128; + * unsigned char controlBlock[33+pathLen*32]; + * unsigned char scriptCMR[32]; + */ +typedef struct rawBitcoinTapEnv { + const unsigned char* controlBlock; + const unsigned char* scriptCMR; + unsigned char pathLen; +} rawBitcoinTapEnv; + +/* A forward declaration for the structure containing a copy (and digest) of the rawBitcoinTapEnv data */ +typedef struct bitcoinTapEnv bitcoinTapEnv; + +/* Allocate and initialize a 'bitcoinTapEnv' from a 'rawBitcoinTapEnv', copying or hashing the data as needed. + * Returns NULL if malloc fails (or if malloc cannot be called because we require an allocation larger than SIZE_MAX). + * + * Precondition: *rawEnv is well-formed (i.e. rawEnv->pathLen <= 128.) + */ +extern bitcoinTapEnv* rustsimplicity_0_6_bitcoin_mallocTapEnv(const rawBitcoinTapEnv* rawEnv); + +/* Free a pointer to 'bitcoinTapEnv'. + */ +extern void rustsimplicity_0_6_bitcoin_freeTapEnv(bitcoinTapEnv* env); +#endif diff --git a/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/exec.h b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/exec.h new file mode 100644 index 00000000..74fd3b1c --- /dev/null +++ b/simplicity-sys/depend/simplicity/include/simplicity/bitcoin/exec.h @@ -0,0 +1,41 @@ +#ifndef SIMPLICITY_BITCOIN_EXEC_H +#define SIMPLICITY_BITCOIN_EXEC_H + +#include +#include +#include +#include +#include + +/* Deserialize a Simplicity 'program' with its 'witness' data and execute it in the environment of the 'ix'th input of 'tx' with `taproot`. + * + * If at any time malloc fails then '*error' is set to 'SIMPLICITY_ERR_MALLOC' and 'false' is returned, + * meaning we were unable to determine the result of the simplicity program. + * Otherwise, 'true' is returned indicating that the result was successfully computed and returned in the '*error' value. + * + * If deserialization, analysis, or execution fails, then '*error' is set to some simplicity_err. + * + * If 'amr != NULL' and the annotated Merkle root of the decoded expression doesn't match 'amr' then '*error' is set to 'SIMPLICITY_ERR_AMR'. + * + * Otherwise '*error' is set to 'SIMPLICITY_NO_ERROR'. + * + * If 'ihr != NULL' and '*error' is set to 'SIMPLICITY_NO_ERROR', then the identity hash of the root of the decoded expression is written to 'ihr'. + * Otherwise if 'ihr != NULL' and '*error' is not set to 'SIMPLCITY_NO_ERROR', then 'ihr' may or may not be written to. + * + * Precondition: NULL != error; + * NULL != ihr implies unsigned char ihr[32] + * NULL != tx; + * NULL != taproot; + * 0 <= budget; + * 0 <= minCost <= budget; + * NULL != amr implies unsigned char amr[32] + * unsigned char program[program_len] + * unsigned char witness[witness_len] + */ +extern bool rustsimplicity_0_6_bitcoin_execSimplicity( simplicity_err* error, unsigned char* ihr + , const bitcoinTransaction* tx, uint_fast32_t ix, const bitcoinTapEnv* taproot + , int64_t minCost, int64_t budget + , const unsigned char* amr + , const unsigned char* program, size_t program_len + , const unsigned char* witness, size_t witness_len); +#endif diff --git a/simplicity-sys/depend/simplicity/test.c b/simplicity-sys/depend/simplicity/test.c index 2f6e782c..ababfa8b 100644 --- a/simplicity-sys/depend/simplicity/test.c +++ b/simplicity-sys/depend/simplicity/test.c @@ -356,9 +356,9 @@ static void test_elements(void) { sha256_fromMidstate(cmr, elementsCheckSigHashAllTx1_cmr); sha256_fromMidstate(amr, elementsCheckSigHashAllTx1_amr); - unsigned char genesisHash[32] = "\x0f\x91\x88\xf1\x3c\xb7\xb2\xc7\x1f\x2a\x33\x5e\x3a\x4f\xc3\x28\xbf\x5b\xeb\x43\x60\x12\xaf\xca\x59\x0b\x1a\x11\x46\x6e\x22\x06"; + unsigned char genesisHash[32] = {0x0f, 0x91, 0x88, 0xf1, 0x3c, 0xb7, 0xb2, 0xc7, 0x1f, 0x2a, 0x33, 0x5e, 0x3a, 0x4f, 0xc3, 0x28, 0xbf, 0x5b, 0xeb, 0x43, 0x60, 0x12, 0xaf, 0xca, 0x59, 0x0b, 0x1a, 0x11, 0x46, 0x6e, 0x22, 0x06}; rawElementsTapEnv rawTaproot = (rawElementsTapEnv) - { .controlBlock = (unsigned char [33]){"\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x78\xce\x56\x3f\x89\xa0\xed\x94\x14\xf5\xaa\x28\xad\x0d\x96\xd6\x79\x5f\x9c\x63"} + { .controlBlock = (unsigned char [33]){0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x78, 0xce, 0x56, 0x3f, 0x89, 0xa0, 0xed, 0x94, 0x14, 0xf5, 0xaa, 0x28, 0xad, 0x0d, 0x96, 0xd6, 0x79, 0x5f, 0x9c, 0x63} , .pathLen = 0 , .scriptCMR = cmr }; @@ -367,28 +367,28 @@ static void test_elements(void) { printf("Test elements\n"); { rawElementsTransaction testTx1 = (rawElementsTransaction) - { .txid = (unsigned char[32]){"\xdb\x9a\x3d\xe0\xb6\xb8\xcc\x74\x1e\x4d\x6c\x8f\x19\xce\x75\xec\x0d\xfd\x01\x02\xdb\x9c\xb5\xcd\x27\xa4\x1a\x66\x91\x66\x3a\x07"} + { .txid = (unsigned char[32]){0xdb, 0x9a, 0x3d, 0xe0, 0xb6, 0xb8, 0xcc, 0x74, 0x1e, 0x4d, 0x6c, 0x8f, 0x19, 0xce, 0x75, 0xec, 0x0d, 0xfd, 0x01, 0x02, 0xdb, 0x9c, 0xb5, 0xcd, 0x27, 0xa4, 0x1a, 0x66, 0x91, 0x66, 0x3a, 0x07} , .input = (rawElementsInput[]) { { .annex = NULL - , .prevTxid = (unsigned char[32]){"\xeb\x04\xb6\x8e\x9a\x26\xd1\x16\x04\x6c\x76\xe8\xff\x47\x33\x2f\xb7\x1d\xda\x90\xff\x4b\xef\x53\x70\xf2\x52\x26\xd3\xbc\x09\xfc"} + , .prevTxid = (unsigned char[32]){0xeb, 0x04, 0xb6, 0x8e, 0x9a, 0x26, 0xd1, 0x16, 0x04, 0x6c, 0x76, 0xe8, 0xff, 0x47, 0x33, 0x2f, 0xb7, 0x1d, 0xda, 0x90, 0xff, 0x4b, 0xef, 0x53, 0x70, 0xf2, 0x52, 0x26, 0xd3, 0xbc, 0x09, 0xfc} , .prevIx = 0 , .sequence = 0xfffffffe , .issuance = {0} , .scriptSig = {0} - , .txo = { .asset = (unsigned char[33]){"\x01\x23\x0f\x4f\x5d\x4b\x7c\x6f\xa8\x45\x80\x6e\xe4\xf6\x77\x13\x45\x9e\x1b\x69\xe8\xe6\x0f\xce\xe2\xe4\x94\x0c\x7a\x0d\x5d\xe1\xb2"} - , .value = (unsigned char[9]){"\x01\x00\x00\x00\x02\x54\x0b\xe4\x00"} + , .txo = { .asset = (unsigned char[33]){0x01, 0x23, 0x0f, 0x4f, 0x5d, 0x4b, 0x7c, 0x6f, 0xa8, 0x45, 0x80, 0x6e, 0xe4, 0xf6, 0x77, 0x13, 0x45, 0x9e, 0x1b, 0x69, 0xe8, 0xe6, 0x0f, 0xce, 0xe2, 0xe4, 0x94, 0x0c, 0x7a, 0x0d, 0x5d, 0xe1, 0xb2} + , .value = (unsigned char[9]){0x01, 0x00, 0x00, 0x00, 0x02, 0x54, 0x0b, 0xe4, 0x00} , .scriptPubKey = {0} } } } , .output = (rawElementsOutput[]) - { { .asset = (unsigned char[33]){"\x01\x23\x0f\x4f\x5d\x4b\x7c\x6f\xa8\x45\x80\x6e\xe4\xf6\x77\x13\x45\x9e\x1b\x69\xe8\xe6\x0f\xce\xe2\xe4\x94\x0c\x7a\x0d\x5d\xe1\xb2"} - , .value = (unsigned char[9]){"\x01\x00\x00\x00\x02\x54\x0b\xd7\x1c"} + { { .asset = (unsigned char[33]){0x01, 0x23, 0x0f, 0x4f, 0x5d, 0x4b, 0x7c, 0x6f, 0xa8, 0x45, 0x80, 0x6e, 0xe4, 0xf6, 0x77, 0x13, 0x45, 0x9e, 0x1b, 0x69, 0xe8, 0xe6, 0x0f, 0xce, 0xe2, 0xe4, 0x94, 0x0c, 0x7a, 0x0d, 0x5d, 0xe1, 0xb2} + , .value = (unsigned char[9]){0x01, 0x00, 0x00, 0x00, 0x02, 0x54, 0x0b, 0xd7, 0x1c} , .nonce = NULL - , .scriptPubKey = { .buf = (unsigned char [26]){"\x19\x76\xa9\x14\x48\x63\x3e\x2c\x0e\xe9\x49\x5d\xd3\xf9\xc4\x37\x32\xc4\x7f\x47\x02\xa3\x62\xc8\x88\xac"} + , .scriptPubKey = { .buf = (unsigned char [26]){0x19, 0x76, 0xa9, 0x14, 0x48, 0x63, 0x3e, 0x2c, 0x0e, 0xe9, 0x49, 0x5d, 0xd3, 0xf9, 0xc4, 0x37, 0x32, 0xc4, 0x7f, 0x47, 0x02, 0xa3, 0x62, 0xc8, 0x88, 0xac} , .len = 26 } } - , { .asset = (unsigned char[33]){"\x01\x23\x0f\x4f\x5d\x4b\x7c\x6f\xa8\x45\x80\x6e\xe4\xf6\x77\x13\x45\x9e\x1b\x69\xe8\xe6\x0f\xce\xe2\xe4\x94\x0c\x7a\x0d\x5d\xe1\xb2"} - , .value = (unsigned char[9]){"\x01\x00\x00\x00\x00\x00\x00\x0c\xe4"} + , { .asset = (unsigned char[33]){0x01, 0x23, 0x0f, 0x4f, 0x5d, 0x4b, 0x7c, 0x6f, 0xa8, 0x45, 0x80, 0x6e, 0xe4, 0xf6, 0x77, 0x13, 0x45, 0x9e, 0x1b, 0x69, 0xe8, 0xe6, 0x0f, 0xce, 0xe2, 0xe4, 0x94, 0x0c, 0x7a, 0x0d, 0x5d, 0xe1, 0xb2} + , .value = (unsigned char[9]){0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe4} , .nonce = NULL , .scriptPubKey = {0} } } @@ -462,26 +462,26 @@ static void test_elements(void) { /* test a modified transaction with the same signature. */ { rawElementsTransaction testTx2 = (rawElementsTransaction) - { .txid = (unsigned char[32]){"\xdb\x9a\x3d\xe0\xb6\xb8\xcc\x74\x1e\x4d\x6c\x8f\x19\xce\x75\xec\x0d\xfd\x01\x02\xdb\x9c\xb5\xcd\x27\xa4\x1a\x66\x91\x66\x3a\x07"} + { .txid = (unsigned char[32]){0xdb, 0x9a, 0x3d, 0xe0, 0xb6, 0xb8, 0xcc, 0x74, 0x1e, 0x4d, 0x6c, 0x8f, 0x19, 0xce, 0x75, 0xec, 0x0d, 0xfd, 0x01, 0x02, 0xdb, 0x9c, 0xb5, 0xcd, 0x27, 0xa4, 0x1a, 0x66, 0x91, 0x66, 0x3a, 0x07} , .input = (rawElementsInput[]) - { { .prevTxid = (unsigned char[32]){"\xeb\x04\xb6\x8e\x9a\x26\xd1\x16\x04\x6c\x76\xe8\xff\x47\x33\x2f\xb7\x1d\xda\x90\xff\x4b\xef\x53\x70\xf2\x52\x26\xd3\xbc\x09\xfc"} + { { .prevTxid = (unsigned char[32]){0xeb, 0x04, 0xb6, 0x8e, 0x9a, 0x26, 0xd1, 0x16, 0x04, 0x6c, 0x76, 0xe8, 0xff, 0x47, 0x33, 0x2f, 0xb7, 0x1d, 0xda, 0x90, 0xff, 0x4b, 0xef, 0x53, 0x70, 0xf2, 0x52, 0x26, 0xd3, 0xbc, 0x09, 0xfc} , .prevIx = 0 , .sequence = 0xffffffff /* Here is the modification. */ , .issuance = {0} - , .txo = { .asset = (unsigned char[33]){"\x01\x23\x0f\x4f\x5d\x4b\x7c\x6f\xa8\x45\x80\x6e\xe4\xf6\x77\x13\x45\x9e\x1b\x69\xe8\xe6\x0f\xce\xe2\xe4\x94\x0c\x7a\x0d\x5d\xe1\xb2"} - , .value = (unsigned char[9]){"\x01\x00\x00\x00\x02\x54\x0b\xe4\x00"} + , .txo = { .asset = (unsigned char[33]){0x01, 0x23, 0x0f, 0x4f, 0x5d, 0x4b, 0x7c, 0x6f, 0xa8, 0x45, 0x80, 0x6e, 0xe4, 0xf6, 0x77, 0x13, 0x45, 0x9e, 0x1b, 0x69, 0xe8, 0xe6, 0x0f, 0xce, 0xe2, 0xe4, 0x94, 0x0c, 0x7a, 0x0d, 0x5d, 0xe1, 0xb2} + , .value = (unsigned char[9]){0x01, 0x00, 0x00, 0x00, 0x02, 0x54, 0x0b, 0xe4, 0x00} , .scriptPubKey = {0} } } } , .output = (rawElementsOutput[]) - { { .asset = (unsigned char[33]){"\x01\x23\x0f\x4f\x5d\x4b\x7c\x6f\xa8\x45\x80\x6e\xe4\xf6\x77\x13\x45\x9e\x1b\x69\xe8\xe6\x0f\xce\xe2\xe4\x94\x0c\x7a\x0d\x5d\xe1\xb2"} - , .value = (unsigned char[9]){"\x01\x00\x00\x00\x02\x54\x0b\xd7\x1c"} + { { .asset = (unsigned char[33]){0x01, 0x23, 0x0f, 0x4f, 0x5d, 0x4b, 0x7c, 0x6f, 0xa8, 0x45, 0x80, 0x6e, 0xe4, 0xf6, 0x77, 0x13, 0x45, 0x9e, 0x1b, 0x69, 0xe8, 0xe6, 0x0f, 0xce, 0xe2, 0xe4, 0x94, 0x0c, 0x7a, 0x0d, 0x5d, 0xe1, 0xb2} + , .value = (unsigned char[9]){0x01, 0x00, 0x00, 0x00, 0x02, 0x54, 0x0b, 0xd7, 0x1c} , .nonce = NULL - , .scriptPubKey = { .buf = (unsigned char [26]){"\x19\x76\xa9\x14\x48\x63\x3e\x2c\x0e\xe9\x49\x5d\xd3\xf9\xc4\x37\x32\xc4\x7f\x47\x02\xa3\x62\xc8\x88\xac"} + , .scriptPubKey = { .buf = (unsigned char [26]){0x19, 0x76, 0xa9, 0x14, 0x48, 0x63, 0x3e, 0x2c, 0x0e, 0xe9, 0x49, 0x5d, 0xd3, 0xf9, 0xc4, 0x37, 0x32, 0xc4, 0x7f, 0x47, 0x02, 0xa3, 0x62, 0xc8, 0x88, 0xac} , .len = 26 } } - , { .asset = (unsigned char[33]){"\x01\x23\x0f\x4f\x5d\x4b\x7c\x6f\xa8\x45\x80\x6e\xe4\xf6\x77\x13\x45\x9e\x1b\x69\xe8\xe6\x0f\xce\xe2\xe4\x94\x0c\x7a\x0d\x5d\xe1\xb2"} - , .value = (unsigned char[9]){"\x01\x00\x00\x00\x00\x00\x00\x0c\xe4"} + , { .asset = (unsigned char[33]){0x01, 0x23, 0x0f, 0x4f, 0x5d, 0x4b, 0x7c, 0x6f, 0xa8, 0x45, 0x80, 0x6e, 0xe4, 0xf6, 0x77, 0x13, 0x45, 0x9e, 0x1b, 0x69, 0xe8, 0xe6, 0x0f, 0xce, 0xe2, 0xe4, 0x94, 0x0c, 0x7a, 0x0d, 0x5d, 0xe1, 0xb2} + , .value = (unsigned char[9]){0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xe4} , .nonce = NULL , .scriptPubKey = {0} } } diff --git a/simplicity-sys/src/c_jets/c_env/bitcoin.rs b/simplicity-sys/src/c_jets/c_env/bitcoin.rs index 44e69f9c..53eb970e 100644 --- a/simplicity-sys/src/c_jets/c_env/bitcoin.rs +++ b/simplicity-sys/src/c_jets/c_env/bitcoin.rs @@ -68,7 +68,6 @@ pub struct CTapEnv { _data: (), } -/* // Will uncomment in a later commit; need to update libsimplicity first so these // symbols have something to link against. extern "C" { @@ -110,7 +109,7 @@ extern "C" { #[link_name = "rustsimplicity_0_6_bitcoin_mallocTransaction"] pub fn simplicity_mallocTransaction(rawTx: *const CRawTransaction) -> *mut CTransaction; } -*/ + impl CTxEnv { pub fn sighash_all(&self) -> sha256::Hash { let midstate: sha256::Midstate = self.sighash_all.into(); @@ -137,7 +136,6 @@ impl CRawBuffer { } } -/* // Will uncomment in a later commit; need to update libsimplicity first. #[cfg(test)] mod tests { @@ -173,4 +171,3 @@ mod tests { } } } -*/ diff --git a/simplicity-sys/src/c_jets/jets_ffi.rs b/simplicity-sys/src/c_jets/jets_ffi.rs index 70cd4bf1..b6be1798 100644 --- a/simplicity-sys/src/c_jets/jets_ffi.rs +++ b/simplicity-sys/src/c_jets/jets_ffi.rs @@ -1,7 +1,9 @@ /* This file has been automatically generated. */ +use crate::bitcoin; +use crate::elements; use crate::ffi::c_void; -use crate::{CElementsTxEnv, CFrameItem}; +use crate::CFrameItem; extern "C" { #[link_name = "rustsimplicity_0_6_c_add_16"] @@ -30,26 +32,90 @@ extern "C" { pub fn and_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_and_8"] pub fn and_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_annex_hash"] + pub fn bitcoin_annex_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_annex_hash"] - pub fn annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn annex_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_asset_amount_hash"] - pub fn asset_amount_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn asset_amount_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_bip_0340_verify"] - pub fn bip_0340_verify(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn bip_0340_verify( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_build_tapbranch"] + pub fn bitcoin_build_tapbranch( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_build_tapbranch"] - pub fn build_tapbranch(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn build_tapbranch( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_build_tapleaf_simplicity"] + pub fn bitcoin_build_tapleaf_simplicity( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_build_tapleaf_simplicity"] - pub fn build_tapleaf_simplicity(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn build_tapleaf_simplicity( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_build_taptweak"] + pub fn bitcoin_build_taptweak( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_build_taptweak"] - pub fn build_taptweak(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn build_taptweak( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_calculate_asset"] - pub fn calculate_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn calculate_asset( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_calculate_confidential_token"] - pub fn calculate_confidential_token(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn calculate_confidential_token( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_calculate_explicit_token"] - pub fn calculate_explicit_token(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn calculate_explicit_token( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_calculate_issuance_entropy"] - pub fn calculate_issuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn calculate_issuance_entropy( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_ch_1"] pub fn ch_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_ch_16"] @@ -60,16 +126,60 @@ extern "C" { pub fn ch_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_ch_8"] pub fn ch_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_check_lock_distance"] + pub fn bitcoin_check_lock_distance( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_check_lock_distance"] - pub fn check_lock_distance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn check_lock_distance( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_check_lock_duration"] + pub fn bitcoin_check_lock_duration( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_check_lock_duration"] - pub fn check_lock_duration(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn check_lock_duration( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_check_lock_height"] + pub fn bitcoin_check_lock_height( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_check_lock_height"] - pub fn check_lock_height(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn check_lock_height( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_check_lock_time"] + pub fn bitcoin_check_lock_time( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_check_lock_time"] - pub fn check_lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn check_lock_time( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_check_sig_verify"] - pub fn check_sig_verify(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn check_sig_verify( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_complement_1"] pub fn complement_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_complement_16"] @@ -81,37 +191,143 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_complement_8"] pub fn complement_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_current_amount"] - pub fn current_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_amount( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_current_annex_hash"] + pub fn bitcoin_current_annex_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_annex_hash"] - pub fn current_annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_annex_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_asset"] - pub fn current_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_asset( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_current_index"] + pub fn bitcoin_current_index( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_index"] - pub fn current_index(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_index( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_issuance_asset_amount"] - pub fn current_issuance_asset_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_issuance_asset_amount( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_issuance_asset_proof"] - pub fn current_issuance_asset_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_issuance_asset_proof( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_issuance_token_amount"] - pub fn current_issuance_token_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_issuance_token_amount( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_issuance_token_proof"] - pub fn current_issuance_token_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_issuance_token_proof( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_new_issuance_contract"] - pub fn current_new_issuance_contract(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_new_issuance_contract( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_pegin"] - pub fn current_pegin(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_pegin( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_current_prev_outpoint"] + pub fn bitcoin_current_prev_outpoint( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_prev_outpoint"] - pub fn current_prev_outpoint(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_prev_outpoint( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_reissuance_blinding"] - pub fn current_reissuance_blinding(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_reissuance_blinding( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_reissuance_entropy"] - pub fn current_reissuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_reissuance_entropy( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_current_script_hash"] + pub fn bitcoin_current_script_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_script_hash"] - pub fn current_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_script_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_current_script_sig_hash"] + pub fn bitcoin_current_script_sig_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_script_sig_hash"] - pub fn current_script_sig_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_script_sig_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_current_sequence"] + pub fn bitcoin_current_sequence( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_current_sequence"] - pub fn current_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn current_sequence( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_current_value"] + pub fn bitcoin_current_value( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_decompress"] pub fn decompress(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_decrement_16"] @@ -123,7 +339,8 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_decrement_8"] pub fn decrement_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_div_mod_128_64"] - pub fn div_mod_128_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn div_mod_128_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_div_mod_16"] pub fn div_mod_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_div_mod_32"] @@ -171,7 +388,11 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_fe_multiply"] pub fn fe_multiply(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_fe_multiply_beta"] - pub fn fe_multiply_beta(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn fe_multiply_beta( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_fe_negate"] pub fn fe_negate(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_fe_normalize"] @@ -179,7 +400,14 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_fe_square"] pub fn fe_square(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_fe_square_root"] - pub fn fe_square_root(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn fe_square_root(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_fee"] + pub fn bitcoin_fee( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_add_16"] pub fn full_add_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_full_add_32"] @@ -189,111 +417,320 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_full_add_8"] pub fn full_add_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_full_decrement_16"] - pub fn full_decrement_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_decrement_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_decrement_32"] - pub fn full_decrement_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_decrement_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_decrement_64"] - pub fn full_decrement_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_decrement_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_decrement_8"] - pub fn full_decrement_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_decrement_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_increment_16"] - pub fn full_increment_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_increment_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_increment_32"] - pub fn full_increment_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_increment_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_increment_64"] - pub fn full_increment_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_increment_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_increment_8"] - pub fn full_increment_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_increment_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_16_1"] - pub fn full_left_shift_16_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_16_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_16_2"] - pub fn full_left_shift_16_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_16_2( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_16_4"] - pub fn full_left_shift_16_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_16_4( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_16_8"] - pub fn full_left_shift_16_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_16_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_32_1"] - pub fn full_left_shift_32_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_32_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_32_16"] - pub fn full_left_shift_32_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_32_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_32_2"] - pub fn full_left_shift_32_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_32_2( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_32_4"] - pub fn full_left_shift_32_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_32_4( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_32_8"] - pub fn full_left_shift_32_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_32_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_64_1"] - pub fn full_left_shift_64_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_64_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_64_16"] - pub fn full_left_shift_64_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_64_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_64_2"] - pub fn full_left_shift_64_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_64_2( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_64_32"] - pub fn full_left_shift_64_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_64_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_64_4"] - pub fn full_left_shift_64_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_64_4( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_64_8"] - pub fn full_left_shift_64_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_64_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_8_1"] - pub fn full_left_shift_8_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_8_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_8_2"] - pub fn full_left_shift_8_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_8_2( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_left_shift_8_4"] - pub fn full_left_shift_8_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_left_shift_8_4( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_multiply_16"] - pub fn full_multiply_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_multiply_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_multiply_32"] - pub fn full_multiply_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_multiply_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_multiply_64"] - pub fn full_multiply_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_multiply_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_multiply_8"] - pub fn full_multiply_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_multiply_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_16_1"] - pub fn full_right_shift_16_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_16_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_16_2"] - pub fn full_right_shift_16_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_16_2( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_16_4"] - pub fn full_right_shift_16_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_16_4( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_16_8"] - pub fn full_right_shift_16_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_16_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_32_1"] - pub fn full_right_shift_32_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_32_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_32_16"] - pub fn full_right_shift_32_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_32_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_32_2"] - pub fn full_right_shift_32_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_32_2( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_32_4"] - pub fn full_right_shift_32_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_32_4( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_32_8"] - pub fn full_right_shift_32_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_32_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_64_1"] - pub fn full_right_shift_64_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_64_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_64_16"] - pub fn full_right_shift_64_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_64_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_64_2"] - pub fn full_right_shift_64_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_64_2( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_64_32"] - pub fn full_right_shift_64_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_64_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_64_4"] - pub fn full_right_shift_64_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_64_4( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_64_8"] - pub fn full_right_shift_64_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_64_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_8_1"] - pub fn full_right_shift_8_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_8_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_8_2"] - pub fn full_right_shift_8_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_8_2( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_right_shift_8_4"] - pub fn full_right_shift_8_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_right_shift_8_4( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_subtract_16"] - pub fn full_subtract_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_subtract_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_subtract_32"] - pub fn full_subtract_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_subtract_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_subtract_64"] - pub fn full_subtract_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_subtract_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_full_subtract_8"] - pub fn full_subtract_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn full_subtract_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_ge_is_on_curve"] - pub fn ge_is_on_curve(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn ge_is_on_curve(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_ge_negate"] pub fn ge_negate(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_gej_add"] @@ -311,9 +748,17 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_gej_infinity"] pub fn gej_infinity(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_gej_is_infinity"] - pub fn gej_is_infinity(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn gej_is_infinity( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_gej_is_on_curve"] - pub fn gej_is_on_curve(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn gej_is_on_curve( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_gej_negate"] pub fn gej_negate(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_gej_normalize"] @@ -327,7 +772,11 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_generate"] pub fn generate(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_genesis_block_hash"] - pub fn genesis_block_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn genesis_block_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_hash_to_curve"] pub fn hash_to_curve(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_high_1"] @@ -349,43 +798,221 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_increment_8"] pub fn increment_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_input_amount"] - pub fn input_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_amount( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_amounts_hash"] - pub fn input_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_amounts_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_annex_hash"] + pub fn bitcoin_input_annex_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_annex_hash"] - pub fn input_annex_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_annex_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_annexes_hash"] + pub fn bitcoin_input_annexes_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_annexes_hash"] - pub fn input_annexes_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_annexes_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_asset"] - pub fn input_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_asset( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_hash"] + pub fn bitcoin_input_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_hash"] - pub fn input_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_outpoints_hash"] + pub fn bitcoin_input_outpoints_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_outpoints_hash"] - pub fn input_outpoints_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_outpoints_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_pegin"] - pub fn input_pegin(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_pegin( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_prev_outpoint"] + pub fn bitcoin_input_prev_outpoint( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_prev_outpoint"] - pub fn input_prev_outpoint(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_prev_outpoint( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_script_hash"] + pub fn bitcoin_input_script_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_script_hash"] - pub fn input_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_script_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_script_sig_hash"] + pub fn bitcoin_input_script_sig_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_script_sig_hash"] - pub fn input_script_sig_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_script_sig_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_script_sigs_hash"] + pub fn bitcoin_input_script_sigs_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_script_sigs_hash"] - pub fn input_script_sigs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_script_sigs_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_scripts_hash"] + pub fn bitcoin_input_scripts_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_scripts_hash"] - pub fn input_scripts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_scripts_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_sequence"] + pub fn bitcoin_input_sequence( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_sequence"] - pub fn input_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_sequence( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_sequences_hash"] + pub fn bitcoin_input_sequences_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_sequences_hash"] - pub fn input_sequences_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_sequences_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_utxo_hash"] + pub fn bitcoin_input_utxo_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_utxo_hash"] - pub fn input_utxo_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_utxo_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_utxos_hash"] + pub fn bitcoin_input_utxos_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_input_utxos_hash"] - pub fn input_utxos_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn input_utxos_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_value"] + pub fn bitcoin_input_value( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_input_values_hash"] + pub fn bitcoin_input_values_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_inputs_hash"] + pub fn bitcoin_inputs_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_inputs_hash"] - pub fn inputs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn inputs_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_internal_key"] + pub fn bitcoin_internal_key( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_internal_key"] - pub fn internal_key(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn internal_key( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_is_one_16"] pub fn is_one_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_is_one_32"] @@ -403,35 +1030,95 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_is_zero_8"] pub fn is_zero_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance"] - pub fn issuance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_asset"] - pub fn issuance_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_asset( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_asset_amount"] - pub fn issuance_asset_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_asset_amount( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_asset_amounts_hash"] - pub fn issuance_asset_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_asset_amounts_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_asset_proof"] - pub fn issuance_asset_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_asset_proof( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_blinding_entropy_hash"] - pub fn issuance_blinding_entropy_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_blinding_entropy_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_entropy"] - pub fn issuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_entropy( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_hash"] - pub fn issuance_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_range_proofs_hash"] - pub fn issuance_range_proofs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_range_proofs_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_token"] - pub fn issuance_token(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_token( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_token_amount"] - pub fn issuance_token_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_token_amount( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_token_amounts_hash"] - pub fn issuance_token_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_token_amounts_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuance_token_proof"] - pub fn issuance_token_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuance_token_proof( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_issuances_hash"] - pub fn issuances_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn issuances_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_lbtc_asset"] - pub fn lbtc_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn lbtc_asset( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_le_16"] pub fn le_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_le_32"] @@ -441,71 +1128,194 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_le_8"] pub fn le_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_16_32"] - pub fn left_extend_16_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_16_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_16_64"] - pub fn left_extend_16_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_16_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_1_16"] - pub fn left_extend_1_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_1_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_1_32"] - pub fn left_extend_1_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_1_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_1_64"] - pub fn left_extend_1_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_1_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_1_8"] - pub fn left_extend_1_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_1_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_32_64"] - pub fn left_extend_32_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_32_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_8_16"] - pub fn left_extend_8_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_8_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_8_32"] - pub fn left_extend_8_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_8_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_extend_8_64"] - pub fn left_extend_8_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_extend_8_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_16_32"] - pub fn left_pad_high_16_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_16_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_16_64"] - pub fn left_pad_high_16_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_16_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_1_16"] - pub fn left_pad_high_1_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_1_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_1_32"] - pub fn left_pad_high_1_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_1_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_1_64"] - pub fn left_pad_high_1_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_1_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_1_8"] - pub fn left_pad_high_1_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_1_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_32_64"] - pub fn left_pad_high_32_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_32_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_8_16"] - pub fn left_pad_high_8_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_8_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_8_32"] - pub fn left_pad_high_8_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_8_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_high_8_64"] - pub fn left_pad_high_8_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_high_8_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_16_32"] - pub fn left_pad_low_16_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_16_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_16_64"] - pub fn left_pad_low_16_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_16_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_1_16"] - pub fn left_pad_low_1_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_1_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_1_32"] - pub fn left_pad_low_1_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_1_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_1_64"] - pub fn left_pad_low_1_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_1_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_1_8"] - pub fn left_pad_low_1_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_1_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_32_64"] - pub fn left_pad_low_32_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_32_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_8_16"] - pub fn left_pad_low_8_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_8_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_8_32"] - pub fn left_pad_low_8_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_8_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_pad_low_8_64"] - pub fn left_pad_low_8_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_pad_low_8_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_rotate_16"] - pub fn left_rotate_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_rotate_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_left_rotate_32"] - pub fn left_rotate_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_rotate_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_left_rotate_64"] - pub fn left_rotate_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_rotate_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_left_rotate_8"] pub fn left_rotate_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_left_shift_16"] @@ -517,13 +1327,29 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_left_shift_8"] pub fn left_shift_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_left_shift_with_16"] - pub fn left_shift_with_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_shift_with_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_shift_with_32"] - pub fn left_shift_with_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_shift_with_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_shift_with_64"] - pub fn left_shift_with_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_shift_with_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_left_shift_with_8"] - pub fn left_shift_with_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn left_shift_with_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_16_1"] pub fn leftmost_16_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_16_2"] @@ -535,7 +1361,8 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_leftmost_32_1"] pub fn leftmost_32_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_32_16"] - pub fn leftmost_32_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn leftmost_32_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_32_2"] pub fn leftmost_32_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_32_4"] @@ -545,11 +1372,13 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_leftmost_64_1"] pub fn leftmost_64_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_64_16"] - pub fn leftmost_64_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn leftmost_64_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_64_2"] pub fn leftmost_64_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_64_32"] - pub fn leftmost_64_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn leftmost_64_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_64_4"] pub fn leftmost_64_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_leftmost_64_8"] @@ -561,11 +1390,29 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_leftmost_8_4"] pub fn leftmost_8_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_linear_combination_1"] - pub fn linear_combination_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn linear_combination_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_linear_verify_1"] - pub fn linear_verify_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn linear_verify_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_lock_time"] + pub fn bitcoin_lock_time( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_lock_time"] - pub fn lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn lock_time( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_low_1"] pub fn low_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_low_16"] @@ -643,13 +1490,41 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_negate_8"] pub fn negate_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_new_issuance_contract"] - pub fn new_issuance_contract(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn new_issuance_contract( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_nonce_hash"] - pub fn nonce_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn nonce_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_num_inputs"] + pub fn bitcoin_num_inputs( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_num_inputs"] - pub fn num_inputs(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn num_inputs( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_num_outputs"] + pub fn bitcoin_num_outputs( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_num_outputs"] - pub fn num_outputs(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn num_outputs( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_one_16"] pub fn one_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_one_32"] @@ -668,154 +1543,430 @@ extern "C" { pub fn or_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_or_8"] pub fn or_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_outpoint_hash"] + pub fn bitcoin_outpoint_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_outpoint_hash"] - pub fn outpoint_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn outpoint_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_amount"] - pub fn output_amount(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_amount( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_amounts_hash"] - pub fn output_amounts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_amounts_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_asset"] - pub fn output_asset(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_asset( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_output_hash"] + pub fn bitcoin_output_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_hash"] - pub fn output_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_is_fee"] - pub fn output_is_fee(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_is_fee( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_nonce"] - pub fn output_nonce(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_nonce( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_nonces_hash"] - pub fn output_nonces_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_nonces_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_null_datum"] - pub fn output_null_datum(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_null_datum( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_range_proof"] - pub fn output_range_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_range_proof( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_range_proofs_hash"] - pub fn output_range_proofs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_range_proofs_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_output_script_hash"] + pub fn bitcoin_output_script_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_script_hash"] - pub fn output_script_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_script_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_output_scripts_hash"] + pub fn bitcoin_output_scripts_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_scripts_hash"] - pub fn output_scripts_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_scripts_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_surjection_proof"] - pub fn output_surjection_proof(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_surjection_proof( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_output_surjection_proofs_hash"] - pub fn output_surjection_proofs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn output_surjection_proofs_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_output_value"] + pub fn bitcoin_output_value( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_output_values_hash"] + pub fn bitcoin_output_values_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_outputs_hash"] + pub fn bitcoin_outputs_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_outputs_hash"] - pub fn outputs_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn outputs_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_parse_lock"] pub fn parse_lock(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_parse_sequence"] - pub fn parse_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn parse_sequence(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_point_verify_1"] - pub fn point_verify_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn point_verify_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_reissuance_blinding"] - pub fn reissuance_blinding(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn reissuance_blinding( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_reissuance_entropy"] - pub fn reissuance_entropy(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn reissuance_entropy( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_extend_16_32"] - pub fn right_extend_16_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_extend_16_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_extend_16_64"] - pub fn right_extend_16_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_extend_16_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_extend_32_64"] - pub fn right_extend_32_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_extend_32_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_extend_8_16"] - pub fn right_extend_8_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_extend_8_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_extend_8_32"] - pub fn right_extend_8_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_extend_8_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_extend_8_64"] - pub fn right_extend_8_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_extend_8_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_16_32"] - pub fn right_pad_high_16_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_16_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_16_64"] - pub fn right_pad_high_16_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_16_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_1_16"] - pub fn right_pad_high_1_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_1_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_1_32"] - pub fn right_pad_high_1_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_1_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_1_64"] - pub fn right_pad_high_1_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_1_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_1_8"] - pub fn right_pad_high_1_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_1_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_32_64"] - pub fn right_pad_high_32_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_32_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_8_16"] - pub fn right_pad_high_8_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_8_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_8_32"] - pub fn right_pad_high_8_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_8_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_high_8_64"] - pub fn right_pad_high_8_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_high_8_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_16_32"] - pub fn right_pad_low_16_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_16_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_16_64"] - pub fn right_pad_low_16_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_16_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_1_16"] - pub fn right_pad_low_1_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_1_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_1_32"] - pub fn right_pad_low_1_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_1_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_1_64"] - pub fn right_pad_low_1_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_1_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_1_8"] - pub fn right_pad_low_1_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_1_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_32_64"] - pub fn right_pad_low_32_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_32_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_8_16"] - pub fn right_pad_low_8_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_8_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_8_32"] - pub fn right_pad_low_8_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_8_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_pad_low_8_64"] - pub fn right_pad_low_8_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_pad_low_8_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_rotate_16"] - pub fn right_rotate_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_rotate_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_rotate_32"] - pub fn right_rotate_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_rotate_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_rotate_64"] - pub fn right_rotate_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_rotate_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_rotate_8"] - pub fn right_rotate_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_rotate_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_right_shift_16"] - pub fn right_shift_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_shift_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_right_shift_32"] - pub fn right_shift_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_shift_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_right_shift_64"] - pub fn right_shift_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_shift_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_right_shift_8"] pub fn right_shift_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_right_shift_with_16"] - pub fn right_shift_with_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_shift_with_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_shift_with_32"] - pub fn right_shift_with_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_shift_with_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_shift_with_64"] - pub fn right_shift_with_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_shift_with_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_right_shift_with_8"] - pub fn right_shift_with_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn right_shift_with_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_16_1"] - pub fn rightmost_16_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_16_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_16_2"] - pub fn rightmost_16_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_16_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_16_4"] - pub fn rightmost_16_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_16_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_16_8"] - pub fn rightmost_16_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_16_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_32_1"] - pub fn rightmost_32_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_32_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_32_16"] - pub fn rightmost_32_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_32_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_32_2"] - pub fn rightmost_32_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_32_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_32_4"] - pub fn rightmost_32_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_32_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_32_8"] - pub fn rightmost_32_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_32_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_64_1"] - pub fn rightmost_64_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_64_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_64_16"] - pub fn rightmost_64_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_64_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_64_2"] - pub fn rightmost_64_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_64_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_64_32"] - pub fn rightmost_64_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_64_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_64_4"] - pub fn rightmost_64_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_64_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_64_8"] - pub fn rightmost_64_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn rightmost_64_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_8_1"] pub fn rightmost_8_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_rightmost_8_2"] @@ -827,53 +1978,138 @@ extern "C" { #[link_name = "rustsimplicity_0_6_c_scalar_invert"] pub fn scalar_invert(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_scalar_is_zero"] - pub fn scalar_is_zero(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn scalar_is_zero(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) + -> bool; #[link_name = "rustsimplicity_0_6_c_scalar_multiply"] - pub fn scalar_multiply(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn scalar_multiply( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_scalar_multiply_lambda"] - pub fn scalar_multiply_lambda(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn scalar_multiply_lambda( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_scalar_negate"] pub fn scalar_negate(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_scalar_normalize"] - pub fn scalar_normalize(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn scalar_normalize( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_scalar_square"] pub fn scalar_square(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_scale"] pub fn scale(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_script_cmr"] + pub fn bitcoin_script_cmr( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_script_cmr"] - pub fn script_cmr(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn script_cmr( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_block"] pub fn sha_256_block(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_1"] - pub fn sha_256_ctx_8_add_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_1( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_128"] - pub fn sha_256_ctx_8_add_128(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_128( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_16"] - pub fn sha_256_ctx_8_add_16(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_16( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_2"] - pub fn sha_256_ctx_8_add_2(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_2( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_256"] - pub fn sha_256_ctx_8_add_256(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_256( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_32"] - pub fn sha_256_ctx_8_add_32(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_32( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_4"] - pub fn sha_256_ctx_8_add_4(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_4( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_512"] - pub fn sha_256_ctx_8_add_512(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_512( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_64"] - pub fn sha_256_ctx_8_add_64(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_64( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_8"] - pub fn sha_256_ctx_8_add_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_8( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_add_buffer_511"] - pub fn sha_256_ctx_8_add_buffer_511(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_add_buffer_511( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_finalize"] - pub fn sha_256_ctx_8_finalize(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_finalize( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_ctx_8_init"] - pub fn sha_256_ctx_8_init(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + pub fn sha_256_ctx_8_init( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const c_void, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sha_256_iv"] pub fn sha_256_iv(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_sig_all_hash"] + pub fn bitcoin_sig_all_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_sig_all_hash"] - pub fn sig_all_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn sig_all_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_some_1"] pub fn some_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_some_16"] @@ -894,38 +2130,184 @@ extern "C" { pub fn subtract_8(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_swu"] pub fn swu(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tap_env_hash"] + pub fn bitcoin_tap_env_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tap_env_hash"] - pub fn tap_env_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tap_env_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tapdata_init"] pub fn tapdata_init(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tapleaf_hash"] + pub fn bitcoin_tapleaf_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tapleaf_hash"] - pub fn tapleaf_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tapleaf_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tapleaf_version"] + pub fn bitcoin_tapleaf_version( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tapleaf_version"] - pub fn tapleaf_version(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tapleaf_version( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tappath"] + pub fn bitcoin_tappath( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tappath"] - pub fn tappath(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tappath( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tappath_hash"] + pub fn bitcoin_tappath_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tappath_hash"] - pub fn tappath_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tappath_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_total_fee"] - pub fn total_fee(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn total_fee( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_total_input_value"] + pub fn bitcoin_total_input_value( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_total_output_value"] + pub fn bitcoin_total_output_value( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_transaction_id"] + pub fn bitcoin_transaction_id( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_transaction_id"] - pub fn transaction_id(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn transaction_id( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tx_hash"] + pub fn bitcoin_tx_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tx_hash"] - pub fn tx_hash(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_hash( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tx_is_final"] + pub fn bitcoin_tx_is_final( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tx_is_final"] - pub fn tx_is_final(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_is_final( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tx_lock_distance"] + pub fn bitcoin_tx_lock_distance( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tx_lock_distance"] - pub fn tx_lock_distance(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_lock_distance( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tx_lock_duration"] + pub fn bitcoin_tx_lock_duration( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tx_lock_duration"] - pub fn tx_lock_duration(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_lock_duration( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tx_lock_height"] + pub fn bitcoin_tx_lock_height( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tx_lock_height"] - pub fn tx_lock_height(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_lock_height( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_tx_lock_time"] + pub fn bitcoin_tx_lock_time( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_tx_lock_time"] - pub fn tx_lock_time(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn tx_lock_time( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_verify"] pub fn verify(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; + #[link_name = "rustsimplicity_0_6_c_bitcoin_version"] + pub fn bitcoin_version( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const bitcoin::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_version"] - pub fn version(dst: *mut CFrameItem, src: *const CFrameItem, env: *const CElementsTxEnv) -> bool; + pub fn version( + dst: *mut CFrameItem, + src: *const CFrameItem, + env: *const elements::CTxEnv, + ) -> bool; #[link_name = "rustsimplicity_0_6_c_xor_1"] pub fn xor_1(dst: *mut CFrameItem, src: *const CFrameItem, env: *const c_void) -> bool; #[link_name = "rustsimplicity_0_6_c_xor_16"] diff --git a/simplicity-sys/src/c_jets/jets_wrapper.rs b/simplicity-sys/src/c_jets/jets_wrapper.rs index 208ff748..e02f5928 100644 --- a/simplicity-sys/src/c_jets/jets_wrapper.rs +++ b/simplicity-sys/src/c_jets/jets_wrapper.rs @@ -1,1889 +1,2370 @@ /* This file has been automatically generated. */ -use crate::{CElementsTxEnv, CFrameItem}; -use super::elements_ffi; +use super::jets_ffi; +use crate::bitcoin; +use crate::elements; +use crate::CFrameItem; pub fn add_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::add_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::add_16(dst, &src, std::ptr::null()) } } pub fn add_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::add_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::add_32(dst, &src, std::ptr::null()) } } pub fn add_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::add_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::add_64(dst, &src, std::ptr::null()) } } pub fn add_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::add_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::add_8(dst, &src, std::ptr::null()) } } pub fn all_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::all_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::all_16(dst, &src, std::ptr::null()) } } pub fn all_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::all_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::all_32(dst, &src, std::ptr::null()) } } pub fn all_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::all_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::all_64(dst, &src, std::ptr::null()) } } pub fn all_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::all_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::all_8(dst, &src, std::ptr::null()) } } pub fn and_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_1(dst, &src, std::ptr::null()) } } pub fn and_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_16(dst, &src, std::ptr::null()) } } pub fn and_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_32(dst, &src, std::ptr::null()) } } pub fn and_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_64(dst, &src, std::ptr::null()) } } pub fn and_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::and_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::and_8(dst, &src, std::ptr::null()) } } -pub fn annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::annex_hash(dst, &src, env) } +pub fn bitcoin_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_annex_hash(dst, &src, env) } } -pub fn asset_amount_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::asset_amount_hash(dst, &src, env) } +pub fn annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::annex_hash(dst, &src, env) } +} + +pub fn asset_amount_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::asset_amount_hash(dst, &src, env) } } pub fn bip_0340_verify(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::bip_0340_verify(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::bip_0340_verify(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_build_tapbranch( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_build_tapbranch(dst, &src, env) } +} + +pub fn build_tapbranch(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::build_tapbranch(dst, &src, env) } +} + +pub fn bitcoin_build_tapleaf_simplicity( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_build_tapleaf_simplicity(dst, &src, env) } } -pub fn build_tapbranch(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::build_tapbranch(dst, &src, env) } +pub fn build_tapleaf_simplicity( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::build_tapleaf_simplicity(dst, &src, env) } } -pub fn build_tapleaf_simplicity(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::build_tapleaf_simplicity(dst, &src, env) } +pub fn bitcoin_build_taptweak( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_build_taptweak(dst, &src, env) } } -pub fn build_taptweak(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::build_taptweak(dst, &src, env) } +pub fn build_taptweak(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::build_taptweak(dst, &src, env) } } -pub fn calculate_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::calculate_asset(dst, &src, env) } +pub fn calculate_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::calculate_asset(dst, &src, env) } } -pub fn calculate_confidential_token(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::calculate_confidential_token(dst, &src, env) } +pub fn calculate_confidential_token( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::calculate_confidential_token(dst, &src, env) } } -pub fn calculate_explicit_token(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::calculate_explicit_token(dst, &src, env) } +pub fn calculate_explicit_token( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::calculate_explicit_token(dst, &src, env) } } -pub fn calculate_issuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::calculate_issuance_entropy(dst, &src, env) } +pub fn calculate_issuance_entropy( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::calculate_issuance_entropy(dst, &src, env) } } pub fn ch_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_1(dst, &src, std::ptr::null()) } } pub fn ch_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_16(dst, &src, std::ptr::null()) } } pub fn ch_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_32(dst, &src, std::ptr::null()) } } pub fn ch_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_64(dst, &src, std::ptr::null()) } } pub fn ch_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ch_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ch_8(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_check_lock_distance( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_check_lock_distance(dst, &src, env) } +} + +pub fn check_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::check_lock_distance(dst, &src, env) } +} + +pub fn bitcoin_check_lock_duration( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_check_lock_duration(dst, &src, env) } +} + +pub fn check_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::check_lock_duration(dst, &src, env) } } -pub fn check_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::check_lock_distance(dst, &src, env) } +pub fn bitcoin_check_lock_height( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_check_lock_height(dst, &src, env) } } -pub fn check_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::check_lock_duration(dst, &src, env) } +pub fn check_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::check_lock_height(dst, &src, env) } } -pub fn check_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::check_lock_height(dst, &src, env) } +pub fn bitcoin_check_lock_time( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_check_lock_time(dst, &src, env) } } -pub fn check_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::check_lock_time(dst, &src, env) } +pub fn check_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::check_lock_time(dst, &src, env) } } pub fn check_sig_verify(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::check_sig_verify(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::check_sig_verify(dst, &src, std::ptr::null()) } } pub fn complement_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_1(dst, &src, std::ptr::null()) } } pub fn complement_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_16(dst, &src, std::ptr::null()) } } pub fn complement_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_32(dst, &src, std::ptr::null()) } } pub fn complement_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_64(dst, &src, std::ptr::null()) } } pub fn complement_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::complement_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::complement_8(dst, &src, std::ptr::null()) } } -pub fn current_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_amount(dst, &src, env) } +pub fn current_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_amount(dst, &src, env) } } -pub fn current_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_annex_hash(dst, &src, env) } +pub fn bitcoin_current_annex_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_current_annex_hash(dst, &src, env) } } -pub fn current_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_asset(dst, &src, env) } +pub fn current_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_annex_hash(dst, &src, env) } } -pub fn current_index(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_index(dst, &src, env) } +pub fn current_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_asset(dst, &src, env) } } -pub fn current_issuance_asset_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_issuance_asset_amount(dst, &src, env) } +pub fn bitcoin_current_index(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_current_index(dst, &src, env) } } -pub fn current_issuance_asset_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_issuance_asset_proof(dst, &src, env) } +pub fn current_index(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_index(dst, &src, env) } } -pub fn current_issuance_token_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_issuance_token_amount(dst, &src, env) } +pub fn current_issuance_asset_amount( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::current_issuance_asset_amount(dst, &src, env) } } -pub fn current_issuance_token_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_issuance_token_proof(dst, &src, env) } +pub fn current_issuance_asset_proof( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::current_issuance_asset_proof(dst, &src, env) } } -pub fn current_new_issuance_contract(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_new_issuance_contract(dst, &src, env) } +pub fn current_issuance_token_amount( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::current_issuance_token_amount(dst, &src, env) } } -pub fn current_pegin(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_pegin(dst, &src, env) } +pub fn current_issuance_token_proof( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::current_issuance_token_proof(dst, &src, env) } } -pub fn current_prev_outpoint(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_prev_outpoint(dst, &src, env) } +pub fn current_new_issuance_contract( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::current_new_issuance_contract(dst, &src, env) } } -pub fn current_reissuance_blinding(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_reissuance_blinding(dst, &src, env) } +pub fn current_pegin(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_pegin(dst, &src, env) } } -pub fn current_reissuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_reissuance_entropy(dst, &src, env) } +pub fn bitcoin_current_prev_outpoint( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_current_prev_outpoint(dst, &src, env) } } -pub fn current_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_script_hash(dst, &src, env) } +pub fn current_prev_outpoint( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::current_prev_outpoint(dst, &src, env) } } -pub fn current_script_sig_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_script_sig_hash(dst, &src, env) } +pub fn current_reissuance_blinding( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::current_reissuance_blinding(dst, &src, env) } } -pub fn current_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::current_sequence(dst, &src, env) } +pub fn current_reissuance_entropy( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::current_reissuance_entropy(dst, &src, env) } +} + +pub fn bitcoin_current_script_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_current_script_hash(dst, &src, env) } +} + +pub fn current_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_script_hash(dst, &src, env) } +} + +pub fn bitcoin_current_script_sig_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_current_script_sig_hash(dst, &src, env) } +} + +pub fn current_script_sig_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::current_script_sig_hash(dst, &src, env) } +} + +pub fn bitcoin_current_sequence( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_current_sequence(dst, &src, env) } +} + +pub fn current_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::current_sequence(dst, &src, env) } +} + +pub fn bitcoin_current_value(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_current_value(dst, &src, env) } } pub fn decompress(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decompress(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decompress(dst, &src, std::ptr::null()) } } pub fn decrement_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decrement_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decrement_16(dst, &src, std::ptr::null()) } } pub fn decrement_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decrement_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decrement_32(dst, &src, std::ptr::null()) } } pub fn decrement_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decrement_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decrement_64(dst, &src, std::ptr::null()) } } pub fn decrement_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::decrement_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::decrement_8(dst, &src, std::ptr::null()) } } pub fn div_mod_128_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_128_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_128_64(dst, &src, std::ptr::null()) } } pub fn div_mod_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_16(dst, &src, std::ptr::null()) } } pub fn div_mod_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_32(dst, &src, std::ptr::null()) } } pub fn div_mod_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_64(dst, &src, std::ptr::null()) } } pub fn div_mod_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::div_mod_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::div_mod_8(dst, &src, std::ptr::null()) } } pub fn divide_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divide_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divide_16(dst, &src, std::ptr::null()) } } pub fn divide_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divide_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divide_32(dst, &src, std::ptr::null()) } } pub fn divide_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divide_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divide_64(dst, &src, std::ptr::null()) } } pub fn divide_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divide_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divide_8(dst, &src, std::ptr::null()) } } pub fn divides_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divides_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divides_16(dst, &src, std::ptr::null()) } } pub fn divides_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divides_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divides_32(dst, &src, std::ptr::null()) } } pub fn divides_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divides_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divides_64(dst, &src, std::ptr::null()) } } pub fn divides_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::divides_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::divides_8(dst, &src, std::ptr::null()) } } pub fn eq_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_1(dst, &src, std::ptr::null()) } } pub fn eq_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_16(dst, &src, std::ptr::null()) } } pub fn eq_256(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_256(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_256(dst, &src, std::ptr::null()) } } pub fn eq_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_32(dst, &src, std::ptr::null()) } } pub fn eq_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_64(dst, &src, std::ptr::null()) } } pub fn eq_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::eq_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::eq_8(dst, &src, std::ptr::null()) } } pub fn fe_add(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_add(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_add(dst, &src, std::ptr::null()) } } pub fn fe_invert(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_invert(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_invert(dst, &src, std::ptr::null()) } } pub fn fe_is_odd(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_is_odd(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_is_odd(dst, &src, std::ptr::null()) } } pub fn fe_is_zero(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_is_zero(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_is_zero(dst, &src, std::ptr::null()) } } pub fn fe_multiply(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_multiply(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_multiply(dst, &src, std::ptr::null()) } } pub fn fe_multiply_beta(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_multiply_beta(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_multiply_beta(dst, &src, std::ptr::null()) } } pub fn fe_negate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_negate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_negate(dst, &src, std::ptr::null()) } } pub fn fe_normalize(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_normalize(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_normalize(dst, &src, std::ptr::null()) } } pub fn fe_square(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_square(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_square(dst, &src, std::ptr::null()) } } pub fn fe_square_root(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::fe_square_root(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::fe_square_root(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_fee(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_fee(dst, &src, env) } } pub fn full_add_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_add_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_add_16(dst, &src, std::ptr::null()) } } pub fn full_add_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_add_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_add_32(dst, &src, std::ptr::null()) } } pub fn full_add_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_add_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_add_64(dst, &src, std::ptr::null()) } } pub fn full_add_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_add_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_add_8(dst, &src, std::ptr::null()) } } pub fn full_decrement_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_decrement_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_decrement_16(dst, &src, std::ptr::null()) } } pub fn full_decrement_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_decrement_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_decrement_32(dst, &src, std::ptr::null()) } } pub fn full_decrement_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_decrement_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_decrement_64(dst, &src, std::ptr::null()) } } pub fn full_decrement_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_decrement_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_decrement_8(dst, &src, std::ptr::null()) } } pub fn full_increment_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_increment_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_increment_16(dst, &src, std::ptr::null()) } } pub fn full_increment_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_increment_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_increment_32(dst, &src, std::ptr::null()) } } pub fn full_increment_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_increment_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_increment_64(dst, &src, std::ptr::null()) } } pub fn full_increment_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_increment_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_increment_8(dst, &src, std::ptr::null()) } } pub fn full_left_shift_16_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_16_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_16_1(dst, &src, std::ptr::null()) } } pub fn full_left_shift_16_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_16_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_16_2(dst, &src, std::ptr::null()) } } pub fn full_left_shift_16_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_16_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_16_4(dst, &src, std::ptr::null()) } } pub fn full_left_shift_16_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_16_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_16_8(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_1(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_16(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_2(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_4(dst, &src, std::ptr::null()) } } pub fn full_left_shift_32_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_32_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_32_8(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_1(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_16(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_2(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_32(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_4(dst, &src, std::ptr::null()) } } pub fn full_left_shift_64_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_64_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_64_8(dst, &src, std::ptr::null()) } } pub fn full_left_shift_8_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_8_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_8_1(dst, &src, std::ptr::null()) } } pub fn full_left_shift_8_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_8_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_8_2(dst, &src, std::ptr::null()) } } pub fn full_left_shift_8_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_left_shift_8_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_left_shift_8_4(dst, &src, std::ptr::null()) } } pub fn full_multiply_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_multiply_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_multiply_16(dst, &src, std::ptr::null()) } } pub fn full_multiply_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_multiply_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_multiply_32(dst, &src, std::ptr::null()) } } pub fn full_multiply_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_multiply_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_multiply_64(dst, &src, std::ptr::null()) } } pub fn full_multiply_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_multiply_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_multiply_8(dst, &src, std::ptr::null()) } } pub fn full_right_shift_16_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_16_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_16_1(dst, &src, std::ptr::null()) } } pub fn full_right_shift_16_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_16_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_16_2(dst, &src, std::ptr::null()) } } pub fn full_right_shift_16_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_16_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_16_4(dst, &src, std::ptr::null()) } } pub fn full_right_shift_16_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_16_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_16_8(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_1(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_16(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_2(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_4(dst, &src, std::ptr::null()) } } pub fn full_right_shift_32_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_32_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_32_8(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_1(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_16(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_2(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_32(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_4(dst, &src, std::ptr::null()) } } pub fn full_right_shift_64_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_64_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_64_8(dst, &src, std::ptr::null()) } } pub fn full_right_shift_8_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_8_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_8_1(dst, &src, std::ptr::null()) } } pub fn full_right_shift_8_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_8_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_8_2(dst, &src, std::ptr::null()) } } pub fn full_right_shift_8_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_right_shift_8_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_right_shift_8_4(dst, &src, std::ptr::null()) } } pub fn full_subtract_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_subtract_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_subtract_16(dst, &src, std::ptr::null()) } } pub fn full_subtract_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_subtract_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_subtract_32(dst, &src, std::ptr::null()) } } pub fn full_subtract_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_subtract_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_subtract_64(dst, &src, std::ptr::null()) } } pub fn full_subtract_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::full_subtract_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::full_subtract_8(dst, &src, std::ptr::null()) } } pub fn ge_is_on_curve(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ge_is_on_curve(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ge_is_on_curve(dst, &src, std::ptr::null()) } } pub fn ge_negate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::ge_negate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::ge_negate(dst, &src, std::ptr::null()) } } pub fn gej_add(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_add(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_add(dst, &src, std::ptr::null()) } } pub fn gej_double(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_double(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_double(dst, &src, std::ptr::null()) } } pub fn gej_equiv(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_equiv(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_equiv(dst, &src, std::ptr::null()) } } pub fn gej_ge_add(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_ge_add(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_ge_add(dst, &src, std::ptr::null()) } } pub fn gej_ge_add_ex(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_ge_add_ex(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_ge_add_ex(dst, &src, std::ptr::null()) } } pub fn gej_ge_equiv(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_ge_equiv(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_ge_equiv(dst, &src, std::ptr::null()) } } pub fn gej_infinity(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_infinity(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_infinity(dst, &src, std::ptr::null()) } } pub fn gej_is_infinity(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_is_infinity(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_is_infinity(dst, &src, std::ptr::null()) } } pub fn gej_is_on_curve(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_is_on_curve(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_is_on_curve(dst, &src, std::ptr::null()) } } pub fn gej_negate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_negate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_negate(dst, &src, std::ptr::null()) } } pub fn gej_normalize(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_normalize(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_normalize(dst, &src, std::ptr::null()) } } pub fn gej_rescale(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_rescale(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_rescale(dst, &src, std::ptr::null()) } } pub fn gej_x_equiv(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_x_equiv(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_x_equiv(dst, &src, std::ptr::null()) } } pub fn gej_y_is_odd(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::gej_y_is_odd(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::gej_y_is_odd(dst, &src, std::ptr::null()) } } pub fn generate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::generate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::generate(dst, &src, std::ptr::null()) } } -pub fn genesis_block_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::genesis_block_hash(dst, &src, env) } +pub fn genesis_block_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::genesis_block_hash(dst, &src, env) } } pub fn hash_to_curve(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::hash_to_curve(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::hash_to_curve(dst, &src, std::ptr::null()) } } pub fn high_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_1(dst, &src, std::ptr::null()) } } pub fn high_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_16(dst, &src, std::ptr::null()) } } pub fn high_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_32(dst, &src, std::ptr::null()) } } pub fn high_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_64(dst, &src, std::ptr::null()) } } pub fn high_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::high_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::high_8(dst, &src, std::ptr::null()) } } pub fn increment_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::increment_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::increment_16(dst, &src, std::ptr::null()) } } pub fn increment_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::increment_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::increment_32(dst, &src, std::ptr::null()) } } pub fn increment_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::increment_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::increment_64(dst, &src, std::ptr::null()) } } pub fn increment_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::increment_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::increment_8(dst, &src, std::ptr::null()) } +} + +pub fn input_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_amount(dst, &src, env) } +} + +pub fn input_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_amounts_hash(dst, &src, env) } +} + +pub fn bitcoin_input_annex_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_annex_hash(dst, &src, env) } +} + +pub fn input_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_annex_hash(dst, &src, env) } +} + +pub fn bitcoin_input_annexes_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_annexes_hash(dst, &src, env) } +} + +pub fn input_annexes_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_annexes_hash(dst, &src, env) } +} + +pub fn input_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_asset(dst, &src, env) } } -pub fn input_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_amount(dst, &src, env) } +pub fn bitcoin_input_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_hash(dst, &src, env) } } -pub fn input_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_amounts_hash(dst, &src, env) } +pub fn input_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_hash(dst, &src, env) } } -pub fn input_annex_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_annex_hash(dst, &src, env) } +pub fn bitcoin_input_outpoints_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_outpoints_hash(dst, &src, env) } } -pub fn input_annexes_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_annexes_hash(dst, &src, env) } +pub fn input_outpoints_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_outpoints_hash(dst, &src, env) } } -pub fn input_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_asset(dst, &src, env) } +pub fn input_pegin(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_pegin(dst, &src, env) } } -pub fn input_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_hash(dst, &src, env) } +pub fn bitcoin_input_prev_outpoint( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_prev_outpoint(dst, &src, env) } } -pub fn input_outpoints_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_outpoints_hash(dst, &src, env) } +pub fn input_prev_outpoint(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_prev_outpoint(dst, &src, env) } } -pub fn input_pegin(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_pegin(dst, &src, env) } +pub fn bitcoin_input_script_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_script_hash(dst, &src, env) } } -pub fn input_prev_outpoint(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_prev_outpoint(dst, &src, env) } +pub fn input_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_script_hash(dst, &src, env) } } -pub fn input_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_script_hash(dst, &src, env) } +pub fn bitcoin_input_script_sig_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_script_sig_hash(dst, &src, env) } } -pub fn input_script_sig_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_script_sig_hash(dst, &src, env) } +pub fn input_script_sig_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::input_script_sig_hash(dst, &src, env) } } -pub fn input_script_sigs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_script_sigs_hash(dst, &src, env) } +pub fn bitcoin_input_script_sigs_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_script_sigs_hash(dst, &src, env) } } -pub fn input_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_scripts_hash(dst, &src, env) } +pub fn input_script_sigs_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::input_script_sigs_hash(dst, &src, env) } } -pub fn input_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_sequence(dst, &src, env) } +pub fn bitcoin_input_scripts_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_scripts_hash(dst, &src, env) } } -pub fn input_sequences_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_sequences_hash(dst, &src, env) } +pub fn input_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_scripts_hash(dst, &src, env) } } -pub fn input_utxo_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_utxo_hash(dst, &src, env) } +pub fn bitcoin_input_sequence( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_sequence(dst, &src, env) } } -pub fn input_utxos_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::input_utxos_hash(dst, &src, env) } +pub fn input_sequence(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_sequence(dst, &src, env) } } -pub fn inputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::inputs_hash(dst, &src, env) } +pub fn bitcoin_input_sequences_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_sequences_hash(dst, &src, env) } } -pub fn internal_key(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::internal_key(dst, &src, env) } +pub fn input_sequences_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_sequences_hash(dst, &src, env) } +} + +pub fn bitcoin_input_utxo_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_utxo_hash(dst, &src, env) } +} + +pub fn input_utxo_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_utxo_hash(dst, &src, env) } +} + +pub fn bitcoin_input_utxos_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_utxos_hash(dst, &src, env) } +} + +pub fn input_utxos_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::input_utxos_hash(dst, &src, env) } +} + +pub fn bitcoin_input_value(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_input_value(dst, &src, env) } +} + +pub fn bitcoin_input_values_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_input_values_hash(dst, &src, env) } +} + +pub fn bitcoin_inputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_inputs_hash(dst, &src, env) } +} + +pub fn inputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::inputs_hash(dst, &src, env) } +} + +pub fn bitcoin_internal_key(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_internal_key(dst, &src, env) } +} + +pub fn internal_key(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::internal_key(dst, &src, env) } } pub fn is_one_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_one_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_one_16(dst, &src, std::ptr::null()) } } pub fn is_one_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_one_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_one_32(dst, &src, std::ptr::null()) } } pub fn is_one_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_one_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_one_64(dst, &src, std::ptr::null()) } } pub fn is_one_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_one_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_one_8(dst, &src, std::ptr::null()) } } pub fn is_zero_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_zero_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_zero_16(dst, &src, std::ptr::null()) } } pub fn is_zero_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_zero_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_zero_32(dst, &src, std::ptr::null()) } } pub fn is_zero_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_zero_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_zero_64(dst, &src, std::ptr::null()) } } pub fn is_zero_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::is_zero_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::is_zero_8(dst, &src, std::ptr::null()) } } -pub fn issuance(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance(dst, &src, env) } +pub fn issuance(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance(dst, &src, env) } } -pub fn issuance_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_asset(dst, &src, env) } +pub fn issuance_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_asset(dst, &src, env) } } -pub fn issuance_asset_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_asset_amount(dst, &src, env) } +pub fn issuance_asset_amount( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::issuance_asset_amount(dst, &src, env) } } -pub fn issuance_asset_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_asset_amounts_hash(dst, &src, env) } +pub fn issuance_asset_amounts_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::issuance_asset_amounts_hash(dst, &src, env) } } -pub fn issuance_asset_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_asset_proof(dst, &src, env) } +pub fn issuance_asset_proof(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_asset_proof(dst, &src, env) } } -pub fn issuance_blinding_entropy_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_blinding_entropy_hash(dst, &src, env) } +pub fn issuance_blinding_entropy_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::issuance_blinding_entropy_hash(dst, &src, env) } } -pub fn issuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_entropy(dst, &src, env) } +pub fn issuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_entropy(dst, &src, env) } } -pub fn issuance_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_hash(dst, &src, env) } +pub fn issuance_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_hash(dst, &src, env) } } -pub fn issuance_range_proofs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_range_proofs_hash(dst, &src, env) } +pub fn issuance_range_proofs_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::issuance_range_proofs_hash(dst, &src, env) } } -pub fn issuance_token(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_token(dst, &src, env) } +pub fn issuance_token(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_token(dst, &src, env) } } -pub fn issuance_token_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_token_amount(dst, &src, env) } +pub fn issuance_token_amount( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::issuance_token_amount(dst, &src, env) } } -pub fn issuance_token_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_token_amounts_hash(dst, &src, env) } +pub fn issuance_token_amounts_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::issuance_token_amounts_hash(dst, &src, env) } } -pub fn issuance_token_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuance_token_proof(dst, &src, env) } +pub fn issuance_token_proof(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuance_token_proof(dst, &src, env) } } -pub fn issuances_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::issuances_hash(dst, &src, env) } +pub fn issuances_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::issuances_hash(dst, &src, env) } } -pub fn lbtc_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::lbtc_asset(dst, &src, env) } +pub fn lbtc_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::lbtc_asset(dst, &src, env) } } pub fn le_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::le_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::le_16(dst, &src, std::ptr::null()) } } pub fn le_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::le_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::le_32(dst, &src, std::ptr::null()) } } pub fn le_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::le_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::le_64(dst, &src, std::ptr::null()) } } pub fn le_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::le_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::le_8(dst, &src, std::ptr::null()) } } pub fn left_extend_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_16_32(dst, &src, std::ptr::null()) } } pub fn left_extend_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_16_64(dst, &src, std::ptr::null()) } } pub fn left_extend_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_1_16(dst, &src, std::ptr::null()) } } pub fn left_extend_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_1_32(dst, &src, std::ptr::null()) } } pub fn left_extend_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_1_64(dst, &src, std::ptr::null()) } } pub fn left_extend_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_1_8(dst, &src, std::ptr::null()) } } pub fn left_extend_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_32_64(dst, &src, std::ptr::null()) } } pub fn left_extend_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_8_16(dst, &src, std::ptr::null()) } } pub fn left_extend_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_8_32(dst, &src, std::ptr::null()) } } pub fn left_extend_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_extend_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_extend_8_64(dst, &src, std::ptr::null()) } } pub fn left_pad_high_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_16_32(dst, &src, std::ptr::null()) } } pub fn left_pad_high_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_16_64(dst, &src, std::ptr::null()) } } pub fn left_pad_high_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_1_16(dst, &src, std::ptr::null()) } } pub fn left_pad_high_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_1_32(dst, &src, std::ptr::null()) } } pub fn left_pad_high_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_1_64(dst, &src, std::ptr::null()) } } pub fn left_pad_high_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_1_8(dst, &src, std::ptr::null()) } } pub fn left_pad_high_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_32_64(dst, &src, std::ptr::null()) } } pub fn left_pad_high_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_8_16(dst, &src, std::ptr::null()) } } pub fn left_pad_high_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_8_32(dst, &src, std::ptr::null()) } } pub fn left_pad_high_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_high_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_high_8_64(dst, &src, std::ptr::null()) } } pub fn left_pad_low_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_16_32(dst, &src, std::ptr::null()) } } pub fn left_pad_low_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_16_64(dst, &src, std::ptr::null()) } } pub fn left_pad_low_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_1_16(dst, &src, std::ptr::null()) } } pub fn left_pad_low_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_1_32(dst, &src, std::ptr::null()) } } pub fn left_pad_low_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_1_64(dst, &src, std::ptr::null()) } } pub fn left_pad_low_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_1_8(dst, &src, std::ptr::null()) } } pub fn left_pad_low_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_32_64(dst, &src, std::ptr::null()) } } pub fn left_pad_low_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_8_16(dst, &src, std::ptr::null()) } } pub fn left_pad_low_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_8_32(dst, &src, std::ptr::null()) } } pub fn left_pad_low_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_pad_low_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_pad_low_8_64(dst, &src, std::ptr::null()) } } pub fn left_rotate_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_rotate_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_rotate_16(dst, &src, std::ptr::null()) } } pub fn left_rotate_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_rotate_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_rotate_32(dst, &src, std::ptr::null()) } } pub fn left_rotate_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_rotate_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_rotate_64(dst, &src, std::ptr::null()) } } pub fn left_rotate_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_rotate_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_rotate_8(dst, &src, std::ptr::null()) } } pub fn left_shift_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_16(dst, &src, std::ptr::null()) } } pub fn left_shift_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_32(dst, &src, std::ptr::null()) } } pub fn left_shift_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_64(dst, &src, std::ptr::null()) } } pub fn left_shift_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_8(dst, &src, std::ptr::null()) } } pub fn left_shift_with_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_with_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_with_16(dst, &src, std::ptr::null()) } } pub fn left_shift_with_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_with_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_with_32(dst, &src, std::ptr::null()) } } pub fn left_shift_with_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_with_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_with_64(dst, &src, std::ptr::null()) } } pub fn left_shift_with_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::left_shift_with_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::left_shift_with_8(dst, &src, std::ptr::null()) } } pub fn leftmost_16_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_16_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_16_1(dst, &src, std::ptr::null()) } } pub fn leftmost_16_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_16_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_16_2(dst, &src, std::ptr::null()) } } pub fn leftmost_16_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_16_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_16_4(dst, &src, std::ptr::null()) } } pub fn leftmost_16_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_16_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_16_8(dst, &src, std::ptr::null()) } } pub fn leftmost_32_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_1(dst, &src, std::ptr::null()) } } pub fn leftmost_32_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_16(dst, &src, std::ptr::null()) } } pub fn leftmost_32_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_2(dst, &src, std::ptr::null()) } } pub fn leftmost_32_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_4(dst, &src, std::ptr::null()) } } pub fn leftmost_32_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_32_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_32_8(dst, &src, std::ptr::null()) } } pub fn leftmost_64_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_1(dst, &src, std::ptr::null()) } } pub fn leftmost_64_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_16(dst, &src, std::ptr::null()) } } pub fn leftmost_64_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_2(dst, &src, std::ptr::null()) } } pub fn leftmost_64_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_32(dst, &src, std::ptr::null()) } } pub fn leftmost_64_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_4(dst, &src, std::ptr::null()) } } pub fn leftmost_64_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_64_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_64_8(dst, &src, std::ptr::null()) } } pub fn leftmost_8_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_8_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_8_1(dst, &src, std::ptr::null()) } } pub fn leftmost_8_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_8_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_8_2(dst, &src, std::ptr::null()) } } pub fn leftmost_8_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::leftmost_8_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::leftmost_8_4(dst, &src, std::ptr::null()) } } pub fn linear_combination_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::linear_combination_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::linear_combination_1(dst, &src, std::ptr::null()) } } pub fn linear_verify_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::linear_verify_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::linear_verify_1(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_lock_time(dst, &src, env) } } -pub fn lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::lock_time(dst, &src, env) } +pub fn lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::lock_time(dst, &src, env) } } pub fn low_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_1(dst, &src, std::ptr::null()) } } pub fn low_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_16(dst, &src, std::ptr::null()) } } pub fn low_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_32(dst, &src, std::ptr::null()) } } pub fn low_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_64(dst, &src, std::ptr::null()) } } pub fn low_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::low_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::low_8(dst, &src, std::ptr::null()) } } pub fn lt_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::lt_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::lt_16(dst, &src, std::ptr::null()) } } pub fn lt_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::lt_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::lt_32(dst, &src, std::ptr::null()) } } pub fn lt_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::lt_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::lt_64(dst, &src, std::ptr::null()) } } pub fn lt_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::lt_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::lt_8(dst, &src, std::ptr::null()) } } pub fn maj_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_1(dst, &src, std::ptr::null()) } } pub fn maj_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_16(dst, &src, std::ptr::null()) } } pub fn maj_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_32(dst, &src, std::ptr::null()) } } pub fn maj_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_64(dst, &src, std::ptr::null()) } } pub fn maj_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::maj_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::maj_8(dst, &src, std::ptr::null()) } } pub fn max_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::max_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::max_16(dst, &src, std::ptr::null()) } } pub fn max_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::max_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::max_32(dst, &src, std::ptr::null()) } } pub fn max_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::max_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::max_64(dst, &src, std::ptr::null()) } } pub fn max_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::max_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::max_8(dst, &src, std::ptr::null()) } } pub fn median_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::median_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::median_16(dst, &src, std::ptr::null()) } } pub fn median_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::median_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::median_32(dst, &src, std::ptr::null()) } } pub fn median_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::median_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::median_64(dst, &src, std::ptr::null()) } } pub fn median_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::median_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::median_8(dst, &src, std::ptr::null()) } } pub fn min_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::min_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::min_16(dst, &src, std::ptr::null()) } } pub fn min_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::min_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::min_32(dst, &src, std::ptr::null()) } } pub fn min_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::min_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::min_64(dst, &src, std::ptr::null()) } } pub fn min_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::min_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::min_8(dst, &src, std::ptr::null()) } } pub fn modulo_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::modulo_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::modulo_16(dst, &src, std::ptr::null()) } } pub fn modulo_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::modulo_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::modulo_32(dst, &src, std::ptr::null()) } } pub fn modulo_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::modulo_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::modulo_64(dst, &src, std::ptr::null()) } } pub fn modulo_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::modulo_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::modulo_8(dst, &src, std::ptr::null()) } } pub fn multiply_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::multiply_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::multiply_16(dst, &src, std::ptr::null()) } } pub fn multiply_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::multiply_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::multiply_32(dst, &src, std::ptr::null()) } } pub fn multiply_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::multiply_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::multiply_64(dst, &src, std::ptr::null()) } } pub fn multiply_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::multiply_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::multiply_8(dst, &src, std::ptr::null()) } } pub fn negate_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::negate_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::negate_16(dst, &src, std::ptr::null()) } } pub fn negate_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::negate_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::negate_32(dst, &src, std::ptr::null()) } } pub fn negate_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::negate_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::negate_64(dst, &src, std::ptr::null()) } } pub fn negate_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::negate_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::negate_8(dst, &src, std::ptr::null()) } } -pub fn new_issuance_contract(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::new_issuance_contract(dst, &src, env) } +pub fn new_issuance_contract( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::new_issuance_contract(dst, &src, env) } } -pub fn nonce_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::nonce_hash(dst, &src, env) } +pub fn nonce_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::nonce_hash(dst, &src, env) } } -pub fn num_inputs(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::num_inputs(dst, &src, env) } +pub fn bitcoin_num_inputs(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_num_inputs(dst, &src, env) } } -pub fn num_outputs(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::num_outputs(dst, &src, env) } +pub fn num_inputs(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::num_inputs(dst, &src, env) } +} + +pub fn bitcoin_num_outputs(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_num_outputs(dst, &src, env) } +} + +pub fn num_outputs(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::num_outputs(dst, &src, env) } } pub fn one_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::one_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::one_16(dst, &src, std::ptr::null()) } } pub fn one_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::one_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::one_32(dst, &src, std::ptr::null()) } } pub fn one_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::one_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::one_64(dst, &src, std::ptr::null()) } } pub fn one_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::one_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::one_8(dst, &src, std::ptr::null()) } } pub fn or_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_1(dst, &src, std::ptr::null()) } } pub fn or_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_16(dst, &src, std::ptr::null()) } } pub fn or_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_32(dst, &src, std::ptr::null()) } } pub fn or_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_64(dst, &src, std::ptr::null()) } } pub fn or_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::or_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::or_8(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_outpoint_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_outpoint_hash(dst, &src, env) } +} + +pub fn outpoint_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::outpoint_hash(dst, &src, env) } } -pub fn outpoint_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::outpoint_hash(dst, &src, env) } +pub fn output_amount(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_amount(dst, &src, env) } } -pub fn output_amount(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_amount(dst, &src, env) } +pub fn output_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_amounts_hash(dst, &src, env) } } -pub fn output_amounts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_amounts_hash(dst, &src, env) } +pub fn output_asset(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_asset(dst, &src, env) } } -pub fn output_asset(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_asset(dst, &src, env) } +pub fn bitcoin_output_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_output_hash(dst, &src, env) } } -pub fn output_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_hash(dst, &src, env) } +pub fn output_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_hash(dst, &src, env) } } -pub fn output_is_fee(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_is_fee(dst, &src, env) } +pub fn output_is_fee(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_is_fee(dst, &src, env) } } -pub fn output_nonce(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_nonce(dst, &src, env) } +pub fn output_nonce(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_nonce(dst, &src, env) } } -pub fn output_nonces_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_nonces_hash(dst, &src, env) } +pub fn output_nonces_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_nonces_hash(dst, &src, env) } } -pub fn output_null_datum(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_null_datum(dst, &src, env) } +pub fn output_null_datum(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_null_datum(dst, &src, env) } } -pub fn output_range_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_range_proof(dst, &src, env) } +pub fn output_range_proof(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_range_proof(dst, &src, env) } } -pub fn output_range_proofs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_range_proofs_hash(dst, &src, env) } +pub fn output_range_proofs_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::output_range_proofs_hash(dst, &src, env) } } -pub fn output_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_script_hash(dst, &src, env) } +pub fn bitcoin_output_script_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_output_script_hash(dst, &src, env) } } -pub fn output_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_scripts_hash(dst, &src, env) } +pub fn output_script_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_script_hash(dst, &src, env) } } -pub fn output_surjection_proof(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_surjection_proof(dst, &src, env) } +pub fn bitcoin_output_scripts_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_output_scripts_hash(dst, &src, env) } } -pub fn output_surjection_proofs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::output_surjection_proofs_hash(dst, &src, env) } +pub fn output_scripts_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::output_scripts_hash(dst, &src, env) } } -pub fn outputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::outputs_hash(dst, &src, env) } +pub fn output_surjection_proof( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::output_surjection_proof(dst, &src, env) } +} + +pub fn output_surjection_proofs_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &elements::CTxEnv, +) -> bool { + unsafe { jets_ffi::output_surjection_proofs_hash(dst, &src, env) } +} + +pub fn bitcoin_output_value(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_output_value(dst, &src, env) } +} + +pub fn bitcoin_output_values_hash( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_output_values_hash(dst, &src, env) } +} + +pub fn bitcoin_outputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_outputs_hash(dst, &src, env) } +} + +pub fn outputs_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::outputs_hash(dst, &src, env) } } pub fn parse_lock(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::parse_lock(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::parse_lock(dst, &src, std::ptr::null()) } } pub fn parse_sequence(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::parse_sequence(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::parse_sequence(dst, &src, std::ptr::null()) } } pub fn point_verify_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::point_verify_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::point_verify_1(dst, &src, std::ptr::null()) } } -pub fn reissuance_blinding(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::reissuance_blinding(dst, &src, env) } +pub fn reissuance_blinding(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::reissuance_blinding(dst, &src, env) } } -pub fn reissuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::reissuance_entropy(dst, &src, env) } +pub fn reissuance_entropy(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::reissuance_entropy(dst, &src, env) } } pub fn right_extend_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_16_32(dst, &src, std::ptr::null()) } } pub fn right_extend_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_16_64(dst, &src, std::ptr::null()) } } pub fn right_extend_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_32_64(dst, &src, std::ptr::null()) } } pub fn right_extend_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_8_16(dst, &src, std::ptr::null()) } } pub fn right_extend_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_8_32(dst, &src, std::ptr::null()) } } pub fn right_extend_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_extend_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_extend_8_64(dst, &src, std::ptr::null()) } } pub fn right_pad_high_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_16_32(dst, &src, std::ptr::null()) } } pub fn right_pad_high_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_16_64(dst, &src, std::ptr::null()) } } pub fn right_pad_high_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_1_16(dst, &src, std::ptr::null()) } } pub fn right_pad_high_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_1_32(dst, &src, std::ptr::null()) } } pub fn right_pad_high_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_1_64(dst, &src, std::ptr::null()) } } pub fn right_pad_high_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_1_8(dst, &src, std::ptr::null()) } } pub fn right_pad_high_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_32_64(dst, &src, std::ptr::null()) } } pub fn right_pad_high_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_8_16(dst, &src, std::ptr::null()) } } pub fn right_pad_high_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_8_32(dst, &src, std::ptr::null()) } } pub fn right_pad_high_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_high_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_high_8_64(dst, &src, std::ptr::null()) } } pub fn right_pad_low_16_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_16_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_16_32(dst, &src, std::ptr::null()) } } pub fn right_pad_low_16_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_16_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_16_64(dst, &src, std::ptr::null()) } } pub fn right_pad_low_1_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_1_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_1_16(dst, &src, std::ptr::null()) } } pub fn right_pad_low_1_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_1_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_1_32(dst, &src, std::ptr::null()) } } pub fn right_pad_low_1_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_1_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_1_64(dst, &src, std::ptr::null()) } } pub fn right_pad_low_1_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_1_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_1_8(dst, &src, std::ptr::null()) } } pub fn right_pad_low_32_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_32_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_32_64(dst, &src, std::ptr::null()) } } pub fn right_pad_low_8_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_8_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_8_16(dst, &src, std::ptr::null()) } } pub fn right_pad_low_8_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_8_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_8_32(dst, &src, std::ptr::null()) } } pub fn right_pad_low_8_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_pad_low_8_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_pad_low_8_64(dst, &src, std::ptr::null()) } } pub fn right_rotate_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_rotate_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_rotate_16(dst, &src, std::ptr::null()) } } pub fn right_rotate_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_rotate_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_rotate_32(dst, &src, std::ptr::null()) } } pub fn right_rotate_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_rotate_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_rotate_64(dst, &src, std::ptr::null()) } } pub fn right_rotate_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_rotate_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_rotate_8(dst, &src, std::ptr::null()) } } pub fn right_shift_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_16(dst, &src, std::ptr::null()) } } pub fn right_shift_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_32(dst, &src, std::ptr::null()) } } pub fn right_shift_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_64(dst, &src, std::ptr::null()) } } pub fn right_shift_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_8(dst, &src, std::ptr::null()) } } pub fn right_shift_with_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_with_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_with_16(dst, &src, std::ptr::null()) } } pub fn right_shift_with_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_with_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_with_32(dst, &src, std::ptr::null()) } } pub fn right_shift_with_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_with_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_with_64(dst, &src, std::ptr::null()) } } pub fn right_shift_with_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::right_shift_with_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::right_shift_with_8(dst, &src, std::ptr::null()) } } pub fn rightmost_16_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_16_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_16_1(dst, &src, std::ptr::null()) } } pub fn rightmost_16_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_16_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_16_2(dst, &src, std::ptr::null()) } } pub fn rightmost_16_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_16_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_16_4(dst, &src, std::ptr::null()) } } pub fn rightmost_16_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_16_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_16_8(dst, &src, std::ptr::null()) } } pub fn rightmost_32_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_1(dst, &src, std::ptr::null()) } } pub fn rightmost_32_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_16(dst, &src, std::ptr::null()) } } pub fn rightmost_32_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_2(dst, &src, std::ptr::null()) } } pub fn rightmost_32_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_4(dst, &src, std::ptr::null()) } } pub fn rightmost_32_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_32_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_32_8(dst, &src, std::ptr::null()) } } pub fn rightmost_64_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_1(dst, &src, std::ptr::null()) } } pub fn rightmost_64_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_16(dst, &src, std::ptr::null()) } } pub fn rightmost_64_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_2(dst, &src, std::ptr::null()) } } pub fn rightmost_64_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_32(dst, &src, std::ptr::null()) } } pub fn rightmost_64_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_4(dst, &src, std::ptr::null()) } } pub fn rightmost_64_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_64_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_64_8(dst, &src, std::ptr::null()) } } pub fn rightmost_8_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_8_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_8_1(dst, &src, std::ptr::null()) } } pub fn rightmost_8_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_8_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_8_2(dst, &src, std::ptr::null()) } } pub fn rightmost_8_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::rightmost_8_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::rightmost_8_4(dst, &src, std::ptr::null()) } } pub fn scalar_add(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_add(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_add(dst, &src, std::ptr::null()) } } pub fn scalar_invert(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_invert(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_invert(dst, &src, std::ptr::null()) } } pub fn scalar_is_zero(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_is_zero(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_is_zero(dst, &src, std::ptr::null()) } } pub fn scalar_multiply(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_multiply(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_multiply(dst, &src, std::ptr::null()) } } pub fn scalar_multiply_lambda(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_multiply_lambda(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_multiply_lambda(dst, &src, std::ptr::null()) } } pub fn scalar_negate(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_negate(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_negate(dst, &src, std::ptr::null()) } } pub fn scalar_normalize(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_normalize(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_normalize(dst, &src, std::ptr::null()) } } pub fn scalar_square(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scalar_square(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scalar_square(dst, &src, std::ptr::null()) } } pub fn scale(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::scale(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::scale(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_script_cmr(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_script_cmr(dst, &src, env) } } -pub fn script_cmr(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::script_cmr(dst, &src, env) } +pub fn script_cmr(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::script_cmr(dst, &src, env) } } pub fn sha_256_block(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_block(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_block(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_1(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_128(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_128(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_128(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_16(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_2(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_2(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_2(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_256(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_256(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_256(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_32(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_4(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_4(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_4(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_512(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_512(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_512(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_64(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_8(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_add_buffer_511(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_add_buffer_511(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_add_buffer_511(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_finalize(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_finalize(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_finalize(dst, &src, std::ptr::null()) } } pub fn sha_256_ctx_8_init(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_ctx_8_init(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_ctx_8_init(dst, &src, std::ptr::null()) } } pub fn sha_256_iv(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::sha_256_iv(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::sha_256_iv(dst, &src, std::ptr::null()) } } -pub fn sig_all_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::sig_all_hash(dst, &src, env) } +pub fn bitcoin_sig_all_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_sig_all_hash(dst, &src, env) } +} + +pub fn sig_all_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::sig_all_hash(dst, &src, env) } } pub fn some_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_1(dst, &src, std::ptr::null()) } } pub fn some_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_16(dst, &src, std::ptr::null()) } } pub fn some_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_32(dst, &src, std::ptr::null()) } } pub fn some_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_64(dst, &src, std::ptr::null()) } } pub fn some_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::some_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::some_8(dst, &src, std::ptr::null()) } } pub fn subtract_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::subtract_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::subtract_16(dst, &src, std::ptr::null()) } } pub fn subtract_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::subtract_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::subtract_32(dst, &src, std::ptr::null()) } } pub fn subtract_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::subtract_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::subtract_64(dst, &src, std::ptr::null()) } } pub fn subtract_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::subtract_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::subtract_8(dst, &src, std::ptr::null()) } } pub fn swu(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::swu(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::swu(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_tap_env_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tap_env_hash(dst, &src, env) } } -pub fn tap_env_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tap_env_hash(dst, &src, env) } +pub fn tap_env_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tap_env_hash(dst, &src, env) } } pub fn tapdata_init(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::tapdata_init(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::tapdata_init(dst, &src, std::ptr::null()) } +} + +pub fn bitcoin_tapleaf_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tapleaf_hash(dst, &src, env) } +} + +pub fn tapleaf_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tapleaf_hash(dst, &src, env) } +} + +pub fn bitcoin_tapleaf_version( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_tapleaf_version(dst, &src, env) } +} + +pub fn tapleaf_version(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tapleaf_version(dst, &src, env) } +} + +pub fn bitcoin_tappath(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tappath(dst, &src, env) } +} + +pub fn tappath(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tappath(dst, &src, env) } +} + +pub fn bitcoin_tappath_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tappath_hash(dst, &src, env) } } -pub fn tapleaf_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tapleaf_hash(dst, &src, env) } +pub fn tappath_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tappath_hash(dst, &src, env) } } -pub fn tapleaf_version(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tapleaf_version(dst, &src, env) } +pub fn total_fee(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::total_fee(dst, &src, env) } } -pub fn tappath(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tappath(dst, &src, env) } +pub fn bitcoin_total_input_value( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_total_input_value(dst, &src, env) } } -pub fn tappath_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tappath_hash(dst, &src, env) } +pub fn bitcoin_total_output_value( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_total_output_value(dst, &src, env) } } -pub fn total_fee(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::total_fee(dst, &src, env) } +pub fn bitcoin_transaction_id( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_transaction_id(dst, &src, env) } } -pub fn transaction_id(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::transaction_id(dst, &src, env) } +pub fn transaction_id(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::transaction_id(dst, &src, env) } } -pub fn tx_hash(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_hash(dst, &src, env) } +pub fn bitcoin_tx_hash(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tx_hash(dst, &src, env) } } -pub fn tx_is_final(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_is_final(dst, &src, env) } +pub fn tx_hash(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_hash(dst, &src, env) } } -pub fn tx_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_lock_distance(dst, &src, env) } +pub fn bitcoin_tx_is_final(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tx_is_final(dst, &src, env) } } -pub fn tx_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_lock_duration(dst, &src, env) } +pub fn tx_is_final(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_is_final(dst, &src, env) } } -pub fn tx_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_lock_height(dst, &src, env) } +pub fn bitcoin_tx_lock_distance( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_tx_lock_distance(dst, &src, env) } } -pub fn tx_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::tx_lock_time(dst, &src, env) } +pub fn tx_lock_distance(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_lock_distance(dst, &src, env) } +} + +pub fn bitcoin_tx_lock_duration( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_tx_lock_duration(dst, &src, env) } +} + +pub fn tx_lock_duration(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_lock_duration(dst, &src, env) } +} + +pub fn bitcoin_tx_lock_height( + dst: &mut CFrameItem, + src: CFrameItem, + env: &bitcoin::CTxEnv, +) -> bool { + unsafe { jets_ffi::bitcoin_tx_lock_height(dst, &src, env) } +} + +pub fn tx_lock_height(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_lock_height(dst, &src, env) } +} + +pub fn bitcoin_tx_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_tx_lock_time(dst, &src, env) } +} + +pub fn tx_lock_time(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::tx_lock_time(dst, &src, env) } } pub fn verify(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::verify(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::verify(dst, &src, std::ptr::null()) } } -pub fn version(dst: &mut CFrameItem, src: CFrameItem, env: &CElementsTxEnv) -> bool { - unsafe { elements_ffi::version(dst, &src, env) } +pub fn bitcoin_version(dst: &mut CFrameItem, src: CFrameItem, env: &bitcoin::CTxEnv) -> bool { + unsafe { jets_ffi::bitcoin_version(dst, &src, env) } +} + +pub fn version(dst: &mut CFrameItem, src: CFrameItem, env: &elements::CTxEnv) -> bool { + unsafe { jets_ffi::version(dst, &src, env) } } pub fn xor_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_1(dst, &src, std::ptr::null()) } } pub fn xor_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_16(dst, &src, std::ptr::null()) } } pub fn xor_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_32(dst, &src, std::ptr::null()) } } pub fn xor_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_64(dst, &src, std::ptr::null()) } } pub fn xor_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_8(dst, &src, std::ptr::null()) } } pub fn xor_xor_1(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_1(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_1(dst, &src, std::ptr::null()) } } pub fn xor_xor_16(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_16(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_16(dst, &src, std::ptr::null()) } } pub fn xor_xor_32(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_32(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_32(dst, &src, std::ptr::null()) } } pub fn xor_xor_64(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_64(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_64(dst, &src, std::ptr::null()) } } pub fn xor_xor_8(dst: &mut CFrameItem, src: CFrameItem, _env: &T) -> bool { - unsafe { elements_ffi::xor_xor_8(dst, &src, std::ptr::null()) } + unsafe { jets_ffi::xor_xor_8(dst, &src, std::ptr::null()) } } - diff --git a/src/bit_machine/mod.rs b/src/bit_machine/mod.rs index 68c88c22..d1a22ac9 100644 --- a/src/bit_machine/mod.rs +++ b/src/bit_machine/mod.rs @@ -10,6 +10,7 @@ mod frame; mod limits; mod tracker; +use core::borrow::Borrow; use std::error; use std::fmt; use std::sync::Arc; @@ -60,9 +61,9 @@ impl BitMachine { } #[cfg(test)] - pub fn test_exec( + pub fn test_exec>( program: Arc>, - env: &J::Environment, + env: &J::Environment, ) -> Result { use crate::node::SimpleFinalizer; @@ -220,10 +221,10 @@ impl BitMachine { /// ## Precondition /// /// The Bit Machine is constructed via [`Self::for_program()`] to ensure enough space. - pub fn exec( + pub fn exec>( &mut self, program: &RedeemNode, - env: &J::Environment, + env: &J::Environment, ) -> Result { self.exec_with_tracker(program, env, &mut NoTracker) } @@ -236,10 +237,10 @@ impl BitMachine { /// ## Precondition /// /// The Bit Machine is constructed via [`Self::for_program()`] to ensure enough space. - pub fn exec_with_tracker>( + pub fn exec_with_tracker, Tx: Borrow>( &mut self, program: &RedeemNode, - env: &J::Environment, + env: &J::Environment, tracker: &mut T, ) -> Result { enum CallStack<'a, J: Jet> { @@ -435,7 +436,11 @@ impl BitMachine { } } - fn exec_jet(&mut self, jet: J, env: &J::Environment) -> Result<(), JetFailed> { + fn exec_jet>( + &mut self, + jet: J, + env: &J::Environment, + ) -> Result<(), JetFailed> { use crate::ffi::c_jets::frame_ffi::{c_readBit, c_writeBit, CFrameItem}; use crate::ffi::c_jets::uword_width; use crate::ffi::ffi::UWORD; diff --git a/src/human_encoding/mod.rs b/src/human_encoding/mod.rs index 006f86cb..9606cc95 100644 --- a/src/human_encoding/mod.rs +++ b/src/human_encoding/mod.rs @@ -227,13 +227,14 @@ mod tests { use crate::jet::{Core, Jet}; use crate::types; use crate::{BitMachine, Value}; + use core::borrow::Borrow; use std::collections::HashMap; use std::sync::Arc; - fn assert_finalize_ok( + fn assert_finalize_ok>( s: &str, witness: &HashMap, Value>, - env: &J::Environment, + env: &J::Environment, ) { types::Context::with_context(|ctx| { let program = Forest::::parse(s) @@ -247,10 +248,10 @@ mod tests { }); } - fn assert_finalize_err( + fn assert_finalize_err>( s: &str, witness: &HashMap, Value>, - env: &J::Environment, + env: &J::Environment, err_msg: &'static str, ) { types::Context::with_context(|ctx| { @@ -290,13 +291,13 @@ mod tests { (Arc::from("a"), Value::u8(0x00)), (Arc::from("b"), Value::u8(0x01)), ]); - assert_finalize_ok::(s, &a_less_than_b, &crate::jet::CoreEnv::EMPTY); + assert_finalize_ok::(s, &a_less_than_b, &crate::jet::CoreEnv::EMPTY); let b_greater_equal_a = HashMap::from([ (Arc::from("a"), Value::u8(0x01)), (Arc::from("b"), Value::u8(0x01)), ]); - assert_finalize_err::( + assert_finalize_err::( s, &b_greater_equal_a, &crate::jet::CoreEnv::EMPTY, @@ -307,7 +308,7 @@ mod tests { #[test] fn executed_witness_without_value() { let witness = HashMap::from([(Arc::from("wit1"), Value::u32(1337))]); - assert_finalize_err::( + assert_finalize_err::( " wit1 := witness : 1 -> 2^32 wit2 := witness : 1 -> 2^32 @@ -331,10 +332,10 @@ mod tests { main := comp input comp process jet_verify : 1 -> 1 "; let wit2_is_pruned = HashMap::from([(Arc::from("wit1"), Value::u1(0))]); - assert_finalize_ok::(s, &wit2_is_pruned, &crate::jet::CoreEnv::EMPTY); + assert_finalize_ok::(s, &wit2_is_pruned, &crate::jet::CoreEnv::EMPTY); let wit2_is_missing = HashMap::from([(Arc::from("wit1"), Value::u1(1))]); - assert_finalize_err::( + assert_finalize_err::( s, &wit2_is_missing, &crate::jet::CoreEnv::EMPTY, @@ -345,13 +346,13 @@ mod tests { (Arc::from("wit1"), Value::u1(1)), (Arc::from("wit2"), Value::u64(u64::MAX)), ]); - assert_finalize_ok::(s, &wit2_is_present, &crate::jet::CoreEnv::EMPTY); + assert_finalize_ok::(s, &wit2_is_present, &crate::jet::CoreEnv::EMPTY); } #[test] fn executed_hole_with_value() { let empty = HashMap::new(); - assert_finalize_ok::( + assert_finalize_ok::( " id1 := iden : 2^256 * 1 -> 2^256 * 1 main := comp (disconnect id1 ?hole) unit @@ -365,7 +366,7 @@ mod tests { #[test] fn executed_hole_without_value() { let empty = HashMap::new(); - assert_finalize_err::( + assert_finalize_err::( " wit1 := witness main := comp wit1 comp disconnect iden ?dis2 unit @@ -384,7 +385,7 @@ mod tests { main := comp wit2 jet_verify : 1 -> 1 "; let wit1_populated = HashMap::from([(Arc::from("wit1"), Value::u1(1))]); - assert_finalize_err::( + assert_finalize_err::( s, &wit1_populated, &crate::jet::CoreEnv::EMPTY, @@ -392,6 +393,6 @@ mod tests { ); let wit2_populated = HashMap::from([(Arc::from("wit2"), Value::u1(1))]); - assert_finalize_ok::(s, &wit2_populated, &crate::jet::CoreEnv::EMPTY); + assert_finalize_ok::(s, &wit2_populated, &crate::jet::CoreEnv::EMPTY); } } diff --git a/src/human_encoding/parse/mod.rs b/src/human_encoding/parse/mod.rs index ef087929..eada498c 100644 --- a/src/human_encoding/parse/mod.rs +++ b/src/human_encoding/parse/mod.rs @@ -591,11 +591,12 @@ mod tests { use crate::value::Word; use crate::{BitMachine, Value}; - fn assert_cmr_witness( + #[track_caller] + fn assert_cmr_witness>( s: &str, cmr: &str, witness: &HashMap, Value>, - env: &J::Environment, + env: &J::Environment, ) { match parse::(s) { Ok(forest) => { @@ -673,7 +674,7 @@ mod tests { #[test] fn simple_program() { let empty = HashMap::new(); - assert_cmr_witness::( + assert_cmr_witness::( "main := unit", "c40a10263f7436b4160acbef1c36fba4be4d95df181a968afeab5eac247adff7", &empty, @@ -684,7 +685,7 @@ mod tests { (Arc::from("wit1"), Value::u32(0x00010203)), (Arc::from("wit2"), Value::u32(0x00010203)), ]); - assert_cmr_witness::( + assert_cmr_witness::( " wit1 := witness : 1 -> 2^32 wit2 := witness : 1 -> 2^32 @@ -692,7 +693,7 @@ mod tests { wits_are_equal := comp (pair wit1 wit2) jet_eq_32 : 1 -> 2 main := comp wits_are_equal jet_verify : 1 -> 1 ", - "d7969920eff9a1ed0359aaa8545b239c69969e22c304c645a7b49bcc976a40a8", + "ee2d966aeccfba7f1f1e54bc130237a6ae575db9c1132193d513aeb14b18151a", &witness, &crate::jet::CoreEnv::EMPTY, ); @@ -720,7 +721,7 @@ mod tests { let empty = HashMap::new(); let dummy = ElementsEnv::dummy(); - assert_cmr_witness::( + assert_cmr_witness::( "main := unit", "c40a10263f7436b4160acbef1c36fba4be4d95df181a968afeab5eac247adff7", &empty, @@ -737,7 +738,7 @@ mod tests { ]; let signature = HashMap::from([(Arc::from("wit1"), Value::u512(sig))]); - assert_cmr_witness::( + assert_cmr_witness::( " -- Witnesses wit1 := witness : 1 -> 2^512 diff --git a/src/jet/bitcoin/environment.rs b/src/jet/bitcoin/environment.rs index 22c9f85a..ba0eae40 100644 --- a/src/jet/bitcoin/environment.rs +++ b/src/jet/bitcoin/environment.rs @@ -3,8 +3,7 @@ use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin; /// Environment for Bitcoin Simplicity -// In later commit, when we update Jet trait, will remove default type. -pub struct BitcoinEnv { +pub struct BitcoinEnv { pub tx: T, } diff --git a/src/jet/core/environment.rs b/src/jet/core/environment.rs new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/src/jet/core/environment.rs @@ -0,0 +1 @@ + diff --git a/src/jet/core/mod.rs b/src/jet/core/mod.rs index bea0c672..f80dc742 100644 --- a/src/jet/core/mod.rs +++ b/src/jet/core/mod.rs @@ -6,7 +6,5 @@ use core::marker::PhantomData; pub struct CoreEnv(PhantomData); impl CoreEnv { - // After update to rust-simplicity this will be a Self. For now it needs to be () - // for compatibility with the existing impl of Jet for Core. - pub const EMPTY: () = (); + pub const EMPTY: Self = Self(PhantomData); } diff --git a/src/jet/init/bitcoin.rs b/src/jet/init/bitcoin.rs index 428820fe..dd05c946 100644 --- a/src/jet/init/bitcoin.rs +++ b/src/jet/init/bitcoin.rs @@ -1,16 +1,17 @@ /* This file has been automatically generated. */ +use crate::analysis::Cost; +use crate::decode_bits; +use crate::jet::bitcoin::BitcoinEnv; use crate::jet::type_name::TypeName; use crate::jet::Jet; use crate::merkle::cmr::Cmr; -use crate::decode_bits; use crate::{decode, BitIter, BitWriter}; -use crate::analysis::Cost; use hashes::sha256::Midstate; +use simplicity_sys::bitcoin::CTxEnv; use simplicity_sys::CFrameItem; use std::io::Write; -use std::{fmt, str}; -use crate::jet::bitcoin::BitcoinEnv; +use std::{borrow::Borrow, fmt, str}; /// The Bitcoin jet family. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] @@ -28,7 +29,11 @@ pub enum Bitcoin { And32, And64, And8, + AnnexHash, Bip0340Verify, + BuildTapbranch, + BuildTapleafSimplicity, + BuildTaptweak, Ch1, Ch16, Ch32, @@ -47,6 +52,7 @@ pub enum Bitcoin { CurrentAnnexHash, CurrentIndex, CurrentPrevOutpoint, + CurrentScriptHash, CurrentScriptSigHash, CurrentSequence, CurrentValue, @@ -84,6 +90,7 @@ pub enum Bitcoin { FeNormalize, FeSquare, FeSquareRoot, + Fee, FullAdd16, FullAdd32, FullAdd64, @@ -168,10 +175,21 @@ pub enum Bitcoin { Increment64, Increment8, InputAnnexHash, + InputAnnexesHash, + InputHash, + InputOutpointsHash, InputPrevOutpoint, + InputScriptHash, InputScriptSigHash, + InputScriptSigsHash, + InputScriptsHash, InputSequence, + InputSequencesHash, + InputUtxoHash, + InputUtxosHash, InputValue, + InputValuesHash, + InputsHash, InternalKey, IsOne16, IsOne32, @@ -297,8 +315,13 @@ pub enum Bitcoin { Or32, Or64, Or8, + OutpointHash, + OutputHash, OutputScriptHash, + OutputScriptsHash, OutputValue, + OutputValuesHash, + OutputsHash, ParseLock, ParseSequence, PointVerify1, @@ -383,6 +406,7 @@ pub enum Bitcoin { Sha256Ctx8Finalize, Sha256Ctx8Init, Sha256Iv, + SigAllHash, Some1, Some16, Some32, @@ -393,11 +417,16 @@ pub enum Bitcoin { Subtract64, Subtract8, Swu, + TapEnvHash, TapdataInit, + TapleafHash, TapleafVersion, Tappath, + TappathHash, TotalInputValue, TotalOutputValue, + TransactionId, + TxHash, TxIsFinal, TxLockDistance, TxLockDuration, @@ -419,7 +448,7 @@ pub enum Bitcoin { impl Bitcoin { /// Array of all Bitcoin jets. - pub const ALL: [Self; 400] = [ + pub const ALL: [Self; 428] = [ Self::Add16, Self::Add32, Self::Add64, @@ -433,7 +462,11 @@ impl Bitcoin { Self::And32, Self::And64, Self::And8, + Self::AnnexHash, Self::Bip0340Verify, + Self::BuildTapbranch, + Self::BuildTapleafSimplicity, + Self::BuildTaptweak, Self::Ch1, Self::Ch16, Self::Ch32, @@ -452,6 +485,7 @@ impl Bitcoin { Self::CurrentAnnexHash, Self::CurrentIndex, Self::CurrentPrevOutpoint, + Self::CurrentScriptHash, Self::CurrentScriptSigHash, Self::CurrentSequence, Self::CurrentValue, @@ -489,6 +523,7 @@ impl Bitcoin { Self::FeNormalize, Self::FeSquare, Self::FeSquareRoot, + Self::Fee, Self::FullAdd16, Self::FullAdd32, Self::FullAdd64, @@ -573,10 +608,21 @@ impl Bitcoin { Self::Increment64, Self::Increment8, Self::InputAnnexHash, + Self::InputAnnexesHash, + Self::InputHash, + Self::InputOutpointsHash, Self::InputPrevOutpoint, + Self::InputScriptHash, Self::InputScriptSigHash, + Self::InputScriptSigsHash, + Self::InputScriptsHash, Self::InputSequence, + Self::InputSequencesHash, + Self::InputUtxoHash, + Self::InputUtxosHash, Self::InputValue, + Self::InputValuesHash, + Self::InputsHash, Self::InternalKey, Self::IsOne16, Self::IsOne32, @@ -702,8 +748,13 @@ impl Bitcoin { Self::Or32, Self::Or64, Self::Or8, + Self::OutpointHash, + Self::OutputHash, Self::OutputScriptHash, + Self::OutputScriptsHash, Self::OutputValue, + Self::OutputValuesHash, + Self::OutputsHash, Self::ParseLock, Self::ParseSequence, Self::PointVerify1, @@ -788,6 +839,7 @@ impl Bitcoin { Self::Sha256Ctx8Finalize, Self::Sha256Ctx8Init, Self::Sha256Iv, + Self::SigAllHash, Self::Some1, Self::Some16, Self::Some32, @@ -798,11 +850,16 @@ impl Bitcoin { Self::Subtract64, Self::Subtract8, Self::Swu, + Self::TapEnvHash, Self::TapdataInit, + Self::TapleafHash, Self::TapleafVersion, Self::Tappath, + Self::TappathHash, Self::TotalInputValue, Self::TotalOutputValue, + Self::TransactionId, + Self::TxHash, Self::TxIsFinal, Self::TxLockDistance, Self::TxLockDuration, @@ -824,12 +881,18 @@ impl Bitcoin { } impl Jet for Bitcoin { + type Transaction = bitcoin::Transaction; + type Environment + = BitcoinEnv + where + T: Borrow; + type CJetEnvironment = CTxEnv; - type Environment = BitcoinEnv; - type CJetEnvironment = (); - - fn c_jet_env(_env: &Self::Environment) -> &Self::CJetEnvironment { - unimplemented!("Unspecified CJetEnvironment for Bitcoin jets") + fn c_jet_env(env: &Self::Environment) -> &Self::CJetEnvironment + where + T: Borrow, + { + env.c_tx_env() } fn cmr(&self) -> Cmr { @@ -851,7 +914,11 @@ impl Jet for Bitcoin { Bitcoin::And32 => b"l", Bitcoin::And64 => b"*ll", Bitcoin::And8 => b"****22*22**22*22***22*22**22*22", + Bitcoin::AnnexHash => b"***+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh+1h", Bitcoin::Bip0340Verify => b"**hh*hh", + Bitcoin::BuildTapbranch => b"*hh", + Bitcoin::BuildTapleafSimplicity => b"h", + Bitcoin::BuildTaptweak => b"*hh", Bitcoin::Ch1 => b"*2*22", Bitcoin::Ch16 => b"*****22*22**22*22***22*22**22*22i", Bitcoin::Ch32 => b"*il", @@ -870,6 +937,7 @@ impl Jet for Bitcoin { Bitcoin::CurrentAnnexHash => b"1", Bitcoin::CurrentIndex => b"1", Bitcoin::CurrentPrevOutpoint => b"1", + Bitcoin::CurrentScriptHash => b"1", Bitcoin::CurrentScriptSigHash => b"1", Bitcoin::CurrentSequence => b"1", Bitcoin::CurrentValue => b"1", @@ -907,6 +975,7 @@ impl Jet for Bitcoin { Bitcoin::FeNormalize => b"h", Bitcoin::FeSquare => b"h", Bitcoin::FeSquareRoot => b"h", + Bitcoin::Fee => b"1", Bitcoin::FullAdd16 => b"*2i", Bitcoin::FullAdd32 => b"*2l", Bitcoin::FullAdd64 => b"*2*ll", @@ -991,10 +1060,21 @@ impl Jet for Bitcoin { Bitcoin::Increment64 => b"l", Bitcoin::Increment8 => b"***22*22**22*22", Bitcoin::InputAnnexHash => b"i", + Bitcoin::InputAnnexesHash => b"1", + Bitcoin::InputHash => b"i", + Bitcoin::InputOutpointsHash => b"1", Bitcoin::InputPrevOutpoint => b"i", + Bitcoin::InputScriptHash => b"i", Bitcoin::InputScriptSigHash => b"i", + Bitcoin::InputScriptSigsHash => b"1", + Bitcoin::InputScriptsHash => b"1", Bitcoin::InputSequence => b"i", + Bitcoin::InputSequencesHash => b"1", + Bitcoin::InputUtxoHash => b"i", + Bitcoin::InputUtxosHash => b"1", Bitcoin::InputValue => b"i", + Bitcoin::InputValuesHash => b"1", + Bitcoin::InputsHash => b"1", Bitcoin::InternalKey => b"1", Bitcoin::IsOne16 => b"****22*22**22*22***22*22**22*22", Bitcoin::IsOne32 => b"i", @@ -1120,8 +1200,13 @@ impl Jet for Bitcoin { Bitcoin::Or32 => b"l", Bitcoin::Or64 => b"*ll", Bitcoin::Or8 => b"****22*22**22*22***22*22**22*22", + Bitcoin::OutpointHash => b"***+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh*hi", + Bitcoin::OutputHash => b"i", Bitcoin::OutputScriptHash => b"i", + Bitcoin::OutputScriptsHash => b"1", Bitcoin::OutputValue => b"i", + Bitcoin::OutputValuesHash => b"1", + Bitcoin::OutputsHash => b"1", Bitcoin::ParseLock => b"i", Bitcoin::ParseSequence => b"i", Bitcoin::PointVerify1 => b"***h*2hh*2h", @@ -1206,6 +1291,7 @@ impl Jet for Bitcoin { Bitcoin::Sha256Ctx8Finalize => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", Bitcoin::Sha256Ctx8Init => b"1", Bitcoin::Sha256Iv => b"1", + Bitcoin::SigAllHash => b"1", Bitcoin::Some1 => b"2", Bitcoin::Some16 => b"****22*22**22*22***22*22**22*22", Bitcoin::Some32 => b"i", @@ -1216,11 +1302,16 @@ impl Jet for Bitcoin { Bitcoin::Subtract64 => b"*ll", Bitcoin::Subtract8 => b"****22*22**22*22***22*22**22*22", Bitcoin::Swu => b"h", + Bitcoin::TapEnvHash => b"1", Bitcoin::TapdataInit => b"1", + Bitcoin::TapleafHash => b"1", Bitcoin::TapleafVersion => b"1", Bitcoin::Tappath => b"***22*22**22*22", + Bitcoin::TappathHash => b"1", Bitcoin::TotalInputValue => b"1", Bitcoin::TotalOutputValue => b"1", + Bitcoin::TransactionId => b"1", + Bitcoin::TxHash => b"1", Bitcoin::TxIsFinal => b"1", Bitcoin::TxLockDistance => b"1", Bitcoin::TxLockDuration => b"1", @@ -1258,7 +1349,13 @@ impl Jet for Bitcoin { Bitcoin::And32 => b"i", Bitcoin::And64 => b"l", Bitcoin::And8 => b"***22*22**22*22", + Bitcoin::AnnexHash => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Bitcoin::Bip0340Verify => b"1", + Bitcoin::BuildTapbranch => b"h", + Bitcoin::BuildTapleafSimplicity => b"h", + Bitcoin::BuildTaptweak => b"h", Bitcoin::Ch1 => b"2", Bitcoin::Ch16 => b"****22*22**22*22***22*22**22*22", Bitcoin::Ch32 => b"i", @@ -1277,6 +1374,7 @@ impl Jet for Bitcoin { Bitcoin::CurrentAnnexHash => b"+1h", Bitcoin::CurrentIndex => b"i", Bitcoin::CurrentPrevOutpoint => b"*hi", + Bitcoin::CurrentScriptHash => b"h", Bitcoin::CurrentScriptSigHash => b"h", Bitcoin::CurrentSequence => b"i", Bitcoin::CurrentValue => b"l", @@ -1314,6 +1412,7 @@ impl Jet for Bitcoin { Bitcoin::FeNormalize => b"h", Bitcoin::FeSquare => b"h", Bitcoin::FeSquareRoot => b"+1h", + Bitcoin::Fee => b"l", Bitcoin::FullAdd16 => b"*2****22*22**22*22***22*22**22*22", Bitcoin::FullAdd32 => b"*2i", Bitcoin::FullAdd64 => b"*2l", @@ -1398,10 +1497,21 @@ impl Jet for Bitcoin { Bitcoin::Increment64 => b"*2l", Bitcoin::Increment8 => b"*2***22*22**22*22", Bitcoin::InputAnnexHash => b"+1+1h", + Bitcoin::InputAnnexesHash => b"h", + Bitcoin::InputHash => b"+1h", + Bitcoin::InputOutpointsHash => b"h", Bitcoin::InputPrevOutpoint => b"+1*hi", + Bitcoin::InputScriptHash => b"+1h", Bitcoin::InputScriptSigHash => b"+1h", + Bitcoin::InputScriptSigsHash => b"h", + Bitcoin::InputScriptsHash => b"h", Bitcoin::InputSequence => b"+1i", + Bitcoin::InputSequencesHash => b"h", + Bitcoin::InputUtxoHash => b"+1h", + Bitcoin::InputUtxosHash => b"h", Bitcoin::InputValue => b"+1l", + Bitcoin::InputValuesHash => b"h", + Bitcoin::InputsHash => b"h", Bitcoin::InternalKey => b"h", Bitcoin::IsOne16 => b"2", Bitcoin::IsOne32 => b"2", @@ -1527,10 +1637,19 @@ impl Jet for Bitcoin { Bitcoin::Or32 => b"i", Bitcoin::Or64 => b"l", Bitcoin::Or8 => b"***22*22**22*22", + Bitcoin::OutpointHash => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::OutputHash => b"+1h", Bitcoin::OutputScriptHash => b"+1h", + Bitcoin::OutputScriptsHash => b"h", Bitcoin::OutputValue => b"+1l", + Bitcoin::OutputValuesHash => b"h", + Bitcoin::OutputsHash => b"h", Bitcoin::ParseLock => b"+ii", - Bitcoin::ParseSequence => b"+1+****22*22**22*22***22*22**22*22****22*22**22*22***22*22**22*22", + Bitcoin::ParseSequence => { + b"+1+****22*22**22*22***22*22**22*22****22*22**22*22***22*22**22*22" + } Bitcoin::PointVerify1 => b"1", Bitcoin::RightExtend16_32 => b"i", Bitcoin::RightExtend16_64 => b"l", @@ -1599,20 +1718,45 @@ impl Jet for Bitcoin { Bitcoin::Scale => b"**hhh", Bitcoin::ScriptCMR => b"h", Bitcoin::Sha256Block => b"h", - Bitcoin::Sha256Ctx8Add1 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8Add128 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8Add16 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8Add2 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8Add256 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8Add32 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8Add4 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8Add512 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8Add64 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8Add8 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Bitcoin::Sha256Ctx8AddBuffer511 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Bitcoin::Sha256Ctx8Add1 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8Add128 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8Add16 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8Add2 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8Add256 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8Add32 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8Add4 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8Add512 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8Add64 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8Add8 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::Sha256Ctx8AddBuffer511 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Bitcoin::Sha256Ctx8Finalize => b"h", - Bitcoin::Sha256Ctx8Init => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Bitcoin::Sha256Ctx8Init => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Bitcoin::Sha256Iv => b"h", + Bitcoin::SigAllHash => b"h", Bitcoin::Some1 => b"2", Bitcoin::Some16 => b"2", Bitcoin::Some32 => b"2", @@ -1623,11 +1767,18 @@ impl Jet for Bitcoin { Bitcoin::Subtract64 => b"*2l", Bitcoin::Subtract8 => b"*2***22*22**22*22", Bitcoin::Swu => b"*hh", - Bitcoin::TapdataInit => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Bitcoin::TapEnvHash => b"h", + Bitcoin::TapdataInit => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Bitcoin::TapleafHash => b"h", Bitcoin::TapleafVersion => b"***22*22**22*22", Bitcoin::Tappath => b"+1h", + Bitcoin::TappathHash => b"h", Bitcoin::TotalInputValue => b"l", Bitcoin::TotalOutputValue => b"l", + Bitcoin::TransactionId => b"h", + Bitcoin::TxHash => b"h", Bitcoin::TxIsFinal => b"2", Bitcoin::TxLockDistance => b"****22*22**22*22***22*22**22*22", Bitcoin::TxLockDuration => b"****22*22**22*22***22*22**22*22", @@ -2020,6 +2171,30 @@ impl Jet for Bitcoin { Bitcoin::ParseLock => (102, 8), Bitcoin::ParseSequence => (412, 10), Bitcoin::TapdataInit => (413, 10), + Bitcoin::SigAllHash => (4, 3), + Bitcoin::TxHash => (20, 5), + Bitcoin::TapEnvHash => (21, 5), + Bitcoin::OutputsHash => (176, 8), + Bitcoin::InputsHash => (177, 8), + Bitcoin::InputUtxosHash => (178, 8), + Bitcoin::OutputHash => (179, 8), + Bitcoin::OutputValuesHash => (360, 9), + Bitcoin::OutputScriptsHash => (361, 9), + Bitcoin::InputHash => (362, 9), + Bitcoin::InputOutpointsHash => (363, 9), + Bitcoin::InputSequencesHash => (364, 9), + Bitcoin::InputAnnexesHash => (365, 9), + Bitcoin::InputScriptSigsHash => (366, 9), + Bitcoin::InputUtxoHash => (367, 9), + Bitcoin::InputValuesHash => (5888, 13), + Bitcoin::InputScriptsHash => (5889, 13), + Bitcoin::TapleafHash => (5890, 13), + Bitcoin::TappathHash => (5891, 13), + Bitcoin::OutpointHash => (5892, 13), + Bitcoin::AnnexHash => (5893, 13), + Bitcoin::BuildTapleafSimplicity => (5894, 13), + Bitcoin::BuildTapbranch => (5895, 13), + Bitcoin::BuildTaptweak => (5896, 13), Bitcoin::CheckLockHeight => (24, 5), Bitcoin::CheckLockTime => (100, 7), Bitcoin::CheckLockDistance => (101, 7), @@ -2035,16 +2210,19 @@ impl Jet for Bitcoin { Bitcoin::NumInputs => (880, 10), Bitcoin::NumOutputs => (881, 10), Bitcoin::LockTime => (882, 10), + Bitcoin::Fee => (883, 10), Bitcoin::OutputValue => (1768, 11), Bitcoin::OutputScriptHash => (1769, 11), Bitcoin::TotalOutputValue => (1770, 11), Bitcoin::CurrentPrevOutpoint => (1771, 11), Bitcoin::CurrentValue => (1772, 11), + Bitcoin::CurrentScriptHash => (1773, 11), Bitcoin::CurrentSequence => (1774, 11), Bitcoin::CurrentAnnexHash => (1775, 11), Bitcoin::CurrentScriptSigHash => (28416, 15), Bitcoin::InputPrevOutpoint => (28417, 15), Bitcoin::InputValue => (28418, 15), + Bitcoin::InputScriptHash => (28419, 15), Bitcoin::InputSequence => (28420, 15), Bitcoin::InputAnnexHash => (28421, 15), Bitcoin::InputScriptSigHash => (28422, 15), @@ -2052,6 +2230,7 @@ impl Jet for Bitcoin { Bitcoin::TapleafVersion => (28424, 15), Bitcoin::Tappath => (28425, 15), Bitcoin::Version => (28426, 15), + Bitcoin::TransactionId => (28427, 15), }; w.write_bits_be(n, len) @@ -4338,7 +4517,97 @@ impl Jet for Bitcoin { } }, 1 => { - 0 => {}, + 0 => { + 0 => {Bitcoin::SigAllHash}, + 1 => { + 0 => { + 0 => {Bitcoin::TxHash}, + 1 => {Bitcoin::TapEnvHash} + }, + 1 => { + 0 => { + 0 => { + 0 => { + 0 => {Bitcoin::OutputsHash}, + 1 => {Bitcoin::InputsHash} + }, + 1 => { + 0 => {Bitcoin::InputUtxosHash}, + 1 => {Bitcoin::OutputHash} + } + }, + 1 => { + 0 => { + 0 => { + 0 => {Bitcoin::OutputValuesHash}, + 1 => {Bitcoin::OutputScriptsHash} + }, + 1 => { + 0 => {Bitcoin::InputHash}, + 1 => {Bitcoin::InputOutpointsHash} + } + }, + 1 => { + 0 => { + 0 => {Bitcoin::InputSequencesHash}, + 1 => {Bitcoin::InputAnnexesHash} + }, + 1 => { + 0 => {Bitcoin::InputScriptSigsHash}, + 1 => {Bitcoin::InputUtxoHash} + } + } + } + }, + 1 => { + 0 => { + 0 => { + 0 => { + 0 => { + 0 => { + 0 => { + 0 => { + 0 => {Bitcoin::InputValuesHash}, + 1 => {Bitcoin::InputScriptsHash} + }, + 1 => { + 0 => {Bitcoin::TapleafHash}, + 1 => {Bitcoin::TappathHash} + } + }, + 1 => { + 0 => { + 0 => {Bitcoin::OutpointHash}, + 1 => {Bitcoin::AnnexHash} + }, + 1 => { + 0 => {Bitcoin::BuildTapleafSimplicity}, + 1 => {Bitcoin::BuildTapbranch} + } + } + }, + 1 => { + 0 => { + 0 => { + 0 => {Bitcoin::BuildTaptweak}, + 1 => {} + }, + 1 => {} + }, + 1 => {} + } + }, + 1 => {} + }, + 1 => {} + }, + 1 => {} + }, + 1 => {} + } + } + } + }, 1 => { 0 => { 0 => { @@ -4391,7 +4660,7 @@ impl Jet for Bitcoin { }, 1 => { 0 => {Bitcoin::LockTime}, - 1 => {} + 1 => {Bitcoin::Fee} } }, 1 => { @@ -4408,7 +4677,7 @@ impl Jet for Bitcoin { 1 => { 0 => { 0 => {Bitcoin::CurrentValue}, - 1 => {} + 1 => {Bitcoin::CurrentScriptHash} }, 1 => { 0 => {Bitcoin::CurrentSequence}, @@ -4430,7 +4699,7 @@ impl Jet for Bitcoin { }, 1 => { 0 => {Bitcoin::InputValue}, - 1 => {} + 1 => {Bitcoin::InputScriptHash} } }, 1 => { @@ -4452,7 +4721,7 @@ impl Jet for Bitcoin { }, 1 => { 0 => {Bitcoin::Version}, - 1 => {} + 1 => {Bitcoin::TransactionId} } }, 1 => {} @@ -4477,7 +4746,584 @@ impl Jet for Bitcoin { } fn c_jet_ptr(&self) -> &dyn Fn(&mut CFrameItem, CFrameItem, &Self::CJetEnvironment) -> bool { - unimplemented!("Bitcoin jets have not yet been implemented.") + match self { + Bitcoin::Add16 => &simplicity_sys::c_jets::jets_wrapper::add_16, + Bitcoin::Add32 => &simplicity_sys::c_jets::jets_wrapper::add_32, + Bitcoin::Add64 => &simplicity_sys::c_jets::jets_wrapper::add_64, + Bitcoin::Add8 => &simplicity_sys::c_jets::jets_wrapper::add_8, + Bitcoin::All16 => &simplicity_sys::c_jets::jets_wrapper::all_16, + Bitcoin::All32 => &simplicity_sys::c_jets::jets_wrapper::all_32, + Bitcoin::All64 => &simplicity_sys::c_jets::jets_wrapper::all_64, + Bitcoin::All8 => &simplicity_sys::c_jets::jets_wrapper::all_8, + Bitcoin::And1 => &simplicity_sys::c_jets::jets_wrapper::and_1, + Bitcoin::And16 => &simplicity_sys::c_jets::jets_wrapper::and_16, + Bitcoin::And32 => &simplicity_sys::c_jets::jets_wrapper::and_32, + Bitcoin::And64 => &simplicity_sys::c_jets::jets_wrapper::and_64, + Bitcoin::And8 => &simplicity_sys::c_jets::jets_wrapper::and_8, + Bitcoin::AnnexHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_annex_hash, + Bitcoin::Bip0340Verify => &simplicity_sys::c_jets::jets_wrapper::bip_0340_verify, + Bitcoin::BuildTapbranch => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_build_tapbranch + } + Bitcoin::BuildTapleafSimplicity => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_build_tapleaf_simplicity + } + Bitcoin::BuildTaptweak => &simplicity_sys::c_jets::jets_wrapper::bitcoin_build_taptweak, + Bitcoin::Ch1 => &simplicity_sys::c_jets::jets_wrapper::ch_1, + Bitcoin::Ch16 => &simplicity_sys::c_jets::jets_wrapper::ch_16, + Bitcoin::Ch32 => &simplicity_sys::c_jets::jets_wrapper::ch_32, + Bitcoin::Ch64 => &simplicity_sys::c_jets::jets_wrapper::ch_64, + Bitcoin::Ch8 => &simplicity_sys::c_jets::jets_wrapper::ch_8, + Bitcoin::CheckLockDistance => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_check_lock_distance + } + Bitcoin::CheckLockDuration => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_check_lock_duration + } + Bitcoin::CheckLockHeight => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_check_lock_height + } + Bitcoin::CheckLockTime => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_check_lock_time + } + Bitcoin::CheckSigVerify => &simplicity_sys::c_jets::jets_wrapper::check_sig_verify, + Bitcoin::Complement1 => &simplicity_sys::c_jets::jets_wrapper::complement_1, + Bitcoin::Complement16 => &simplicity_sys::c_jets::jets_wrapper::complement_16, + Bitcoin::Complement32 => &simplicity_sys::c_jets::jets_wrapper::complement_32, + Bitcoin::Complement64 => &simplicity_sys::c_jets::jets_wrapper::complement_64, + Bitcoin::Complement8 => &simplicity_sys::c_jets::jets_wrapper::complement_8, + Bitcoin::CurrentAnnexHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_current_annex_hash + } + Bitcoin::CurrentIndex => &simplicity_sys::c_jets::jets_wrapper::bitcoin_current_index, + Bitcoin::CurrentPrevOutpoint => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_current_prev_outpoint + } + Bitcoin::CurrentScriptHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_current_script_hash + } + Bitcoin::CurrentScriptSigHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_current_script_sig_hash + } + Bitcoin::CurrentSequence => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_current_sequence + } + Bitcoin::CurrentValue => &simplicity_sys::c_jets::jets_wrapper::bitcoin_current_value, + Bitcoin::Decompress => &simplicity_sys::c_jets::jets_wrapper::decompress, + Bitcoin::Decrement16 => &simplicity_sys::c_jets::jets_wrapper::decrement_16, + Bitcoin::Decrement32 => &simplicity_sys::c_jets::jets_wrapper::decrement_32, + Bitcoin::Decrement64 => &simplicity_sys::c_jets::jets_wrapper::decrement_64, + Bitcoin::Decrement8 => &simplicity_sys::c_jets::jets_wrapper::decrement_8, + Bitcoin::DivMod128_64 => &simplicity_sys::c_jets::jets_wrapper::div_mod_128_64, + Bitcoin::DivMod16 => &simplicity_sys::c_jets::jets_wrapper::div_mod_16, + Bitcoin::DivMod32 => &simplicity_sys::c_jets::jets_wrapper::div_mod_32, + Bitcoin::DivMod64 => &simplicity_sys::c_jets::jets_wrapper::div_mod_64, + Bitcoin::DivMod8 => &simplicity_sys::c_jets::jets_wrapper::div_mod_8, + Bitcoin::Divide16 => &simplicity_sys::c_jets::jets_wrapper::divide_16, + Bitcoin::Divide32 => &simplicity_sys::c_jets::jets_wrapper::divide_32, + Bitcoin::Divide64 => &simplicity_sys::c_jets::jets_wrapper::divide_64, + Bitcoin::Divide8 => &simplicity_sys::c_jets::jets_wrapper::divide_8, + Bitcoin::Divides16 => &simplicity_sys::c_jets::jets_wrapper::divides_16, + Bitcoin::Divides32 => &simplicity_sys::c_jets::jets_wrapper::divides_32, + Bitcoin::Divides64 => &simplicity_sys::c_jets::jets_wrapper::divides_64, + Bitcoin::Divides8 => &simplicity_sys::c_jets::jets_wrapper::divides_8, + Bitcoin::Eq1 => &simplicity_sys::c_jets::jets_wrapper::eq_1, + Bitcoin::Eq16 => &simplicity_sys::c_jets::jets_wrapper::eq_16, + Bitcoin::Eq256 => &simplicity_sys::c_jets::jets_wrapper::eq_256, + Bitcoin::Eq32 => &simplicity_sys::c_jets::jets_wrapper::eq_32, + Bitcoin::Eq64 => &simplicity_sys::c_jets::jets_wrapper::eq_64, + Bitcoin::Eq8 => &simplicity_sys::c_jets::jets_wrapper::eq_8, + Bitcoin::FeAdd => &simplicity_sys::c_jets::jets_wrapper::fe_add, + Bitcoin::FeInvert => &simplicity_sys::c_jets::jets_wrapper::fe_invert, + Bitcoin::FeIsOdd => &simplicity_sys::c_jets::jets_wrapper::fe_is_odd, + Bitcoin::FeIsZero => &simplicity_sys::c_jets::jets_wrapper::fe_is_zero, + Bitcoin::FeMultiply => &simplicity_sys::c_jets::jets_wrapper::fe_multiply, + Bitcoin::FeMultiplyBeta => &simplicity_sys::c_jets::jets_wrapper::fe_multiply_beta, + Bitcoin::FeNegate => &simplicity_sys::c_jets::jets_wrapper::fe_negate, + Bitcoin::FeNormalize => &simplicity_sys::c_jets::jets_wrapper::fe_normalize, + Bitcoin::FeSquare => &simplicity_sys::c_jets::jets_wrapper::fe_square, + Bitcoin::FeSquareRoot => &simplicity_sys::c_jets::jets_wrapper::fe_square_root, + Bitcoin::Fee => &simplicity_sys::c_jets::jets_wrapper::bitcoin_fee, + Bitcoin::FullAdd16 => &simplicity_sys::c_jets::jets_wrapper::full_add_16, + Bitcoin::FullAdd32 => &simplicity_sys::c_jets::jets_wrapper::full_add_32, + Bitcoin::FullAdd64 => &simplicity_sys::c_jets::jets_wrapper::full_add_64, + Bitcoin::FullAdd8 => &simplicity_sys::c_jets::jets_wrapper::full_add_8, + Bitcoin::FullDecrement16 => &simplicity_sys::c_jets::jets_wrapper::full_decrement_16, + Bitcoin::FullDecrement32 => &simplicity_sys::c_jets::jets_wrapper::full_decrement_32, + Bitcoin::FullDecrement64 => &simplicity_sys::c_jets::jets_wrapper::full_decrement_64, + Bitcoin::FullDecrement8 => &simplicity_sys::c_jets::jets_wrapper::full_decrement_8, + Bitcoin::FullIncrement16 => &simplicity_sys::c_jets::jets_wrapper::full_increment_16, + Bitcoin::FullIncrement32 => &simplicity_sys::c_jets::jets_wrapper::full_increment_32, + Bitcoin::FullIncrement64 => &simplicity_sys::c_jets::jets_wrapper::full_increment_64, + Bitcoin::FullIncrement8 => &simplicity_sys::c_jets::jets_wrapper::full_increment_8, + Bitcoin::FullLeftShift16_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_1 + } + Bitcoin::FullLeftShift16_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_2 + } + Bitcoin::FullLeftShift16_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_4 + } + Bitcoin::FullLeftShift16_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_8 + } + Bitcoin::FullLeftShift32_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_1 + } + Bitcoin::FullLeftShift32_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_16 + } + Bitcoin::FullLeftShift32_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_2 + } + Bitcoin::FullLeftShift32_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_4 + } + Bitcoin::FullLeftShift32_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_8 + } + Bitcoin::FullLeftShift64_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_1 + } + Bitcoin::FullLeftShift64_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_16 + } + Bitcoin::FullLeftShift64_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_2 + } + Bitcoin::FullLeftShift64_32 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_32 + } + Bitcoin::FullLeftShift64_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_4 + } + Bitcoin::FullLeftShift64_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_8 + } + Bitcoin::FullLeftShift8_1 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_1, + Bitcoin::FullLeftShift8_2 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_2, + Bitcoin::FullLeftShift8_4 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_4, + Bitcoin::FullMultiply16 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_16, + Bitcoin::FullMultiply32 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_32, + Bitcoin::FullMultiply64 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_64, + Bitcoin::FullMultiply8 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_8, + Bitcoin::FullRightShift16_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_1 + } + Bitcoin::FullRightShift16_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_2 + } + Bitcoin::FullRightShift16_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_4 + } + Bitcoin::FullRightShift16_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_8 + } + Bitcoin::FullRightShift32_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_1 + } + Bitcoin::FullRightShift32_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_16 + } + Bitcoin::FullRightShift32_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_2 + } + Bitcoin::FullRightShift32_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_4 + } + Bitcoin::FullRightShift32_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_8 + } + Bitcoin::FullRightShift64_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_1 + } + Bitcoin::FullRightShift64_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_16 + } + Bitcoin::FullRightShift64_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_2 + } + Bitcoin::FullRightShift64_32 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_32 + } + Bitcoin::FullRightShift64_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_4 + } + Bitcoin::FullRightShift64_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_8 + } + Bitcoin::FullRightShift8_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_1 + } + Bitcoin::FullRightShift8_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_2 + } + Bitcoin::FullRightShift8_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_4 + } + Bitcoin::FullSubtract16 => &simplicity_sys::c_jets::jets_wrapper::full_subtract_16, + Bitcoin::FullSubtract32 => &simplicity_sys::c_jets::jets_wrapper::full_subtract_32, + Bitcoin::FullSubtract64 => &simplicity_sys::c_jets::jets_wrapper::full_subtract_64, + Bitcoin::FullSubtract8 => &simplicity_sys::c_jets::jets_wrapper::full_subtract_8, + Bitcoin::GeIsOnCurve => &simplicity_sys::c_jets::jets_wrapper::ge_is_on_curve, + Bitcoin::GeNegate => &simplicity_sys::c_jets::jets_wrapper::ge_negate, + Bitcoin::GejAdd => &simplicity_sys::c_jets::jets_wrapper::gej_add, + Bitcoin::GejDouble => &simplicity_sys::c_jets::jets_wrapper::gej_double, + Bitcoin::GejEquiv => &simplicity_sys::c_jets::jets_wrapper::gej_equiv, + Bitcoin::GejGeAdd => &simplicity_sys::c_jets::jets_wrapper::gej_ge_add, + Bitcoin::GejGeAddEx => &simplicity_sys::c_jets::jets_wrapper::gej_ge_add_ex, + Bitcoin::GejGeEquiv => &simplicity_sys::c_jets::jets_wrapper::gej_ge_equiv, + Bitcoin::GejInfinity => &simplicity_sys::c_jets::jets_wrapper::gej_infinity, + Bitcoin::GejIsInfinity => &simplicity_sys::c_jets::jets_wrapper::gej_is_infinity, + Bitcoin::GejIsOnCurve => &simplicity_sys::c_jets::jets_wrapper::gej_is_on_curve, + Bitcoin::GejNegate => &simplicity_sys::c_jets::jets_wrapper::gej_negate, + Bitcoin::GejNormalize => &simplicity_sys::c_jets::jets_wrapper::gej_normalize, + Bitcoin::GejRescale => &simplicity_sys::c_jets::jets_wrapper::gej_rescale, + Bitcoin::GejXEquiv => &simplicity_sys::c_jets::jets_wrapper::gej_x_equiv, + Bitcoin::GejYIsOdd => &simplicity_sys::c_jets::jets_wrapper::gej_y_is_odd, + Bitcoin::Generate => &simplicity_sys::c_jets::jets_wrapper::generate, + Bitcoin::HashToCurve => &simplicity_sys::c_jets::jets_wrapper::hash_to_curve, + Bitcoin::High1 => &simplicity_sys::c_jets::jets_wrapper::high_1, + Bitcoin::High16 => &simplicity_sys::c_jets::jets_wrapper::high_16, + Bitcoin::High32 => &simplicity_sys::c_jets::jets_wrapper::high_32, + Bitcoin::High64 => &simplicity_sys::c_jets::jets_wrapper::high_64, + Bitcoin::High8 => &simplicity_sys::c_jets::jets_wrapper::high_8, + Bitcoin::Increment16 => &simplicity_sys::c_jets::jets_wrapper::increment_16, + Bitcoin::Increment32 => &simplicity_sys::c_jets::jets_wrapper::increment_32, + Bitcoin::Increment64 => &simplicity_sys::c_jets::jets_wrapper::increment_64, + Bitcoin::Increment8 => &simplicity_sys::c_jets::jets_wrapper::increment_8, + Bitcoin::InputAnnexHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_annex_hash + } + Bitcoin::InputAnnexesHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_annexes_hash + } + Bitcoin::InputHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_hash, + Bitcoin::InputOutpointsHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_outpoints_hash + } + Bitcoin::InputPrevOutpoint => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_prev_outpoint + } + Bitcoin::InputScriptHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_script_hash + } + Bitcoin::InputScriptSigHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_script_sig_hash + } + Bitcoin::InputScriptSigsHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_script_sigs_hash + } + Bitcoin::InputScriptsHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_scripts_hash + } + Bitcoin::InputSequence => &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_sequence, + Bitcoin::InputSequencesHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_sequences_hash + } + Bitcoin::InputUtxoHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_utxo_hash + } + Bitcoin::InputUtxosHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_utxos_hash + } + Bitcoin::InputValue => &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_value, + Bitcoin::InputValuesHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_input_values_hash + } + Bitcoin::InputsHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_inputs_hash, + Bitcoin::InternalKey => &simplicity_sys::c_jets::jets_wrapper::bitcoin_internal_key, + Bitcoin::IsOne16 => &simplicity_sys::c_jets::jets_wrapper::is_one_16, + Bitcoin::IsOne32 => &simplicity_sys::c_jets::jets_wrapper::is_one_32, + Bitcoin::IsOne64 => &simplicity_sys::c_jets::jets_wrapper::is_one_64, + Bitcoin::IsOne8 => &simplicity_sys::c_jets::jets_wrapper::is_one_8, + Bitcoin::IsZero16 => &simplicity_sys::c_jets::jets_wrapper::is_zero_16, + Bitcoin::IsZero32 => &simplicity_sys::c_jets::jets_wrapper::is_zero_32, + Bitcoin::IsZero64 => &simplicity_sys::c_jets::jets_wrapper::is_zero_64, + Bitcoin::IsZero8 => &simplicity_sys::c_jets::jets_wrapper::is_zero_8, + Bitcoin::Le16 => &simplicity_sys::c_jets::jets_wrapper::le_16, + Bitcoin::Le32 => &simplicity_sys::c_jets::jets_wrapper::le_32, + Bitcoin::Le64 => &simplicity_sys::c_jets::jets_wrapper::le_64, + Bitcoin::Le8 => &simplicity_sys::c_jets::jets_wrapper::le_8, + Bitcoin::LeftExtend16_32 => &simplicity_sys::c_jets::jets_wrapper::left_extend_16_32, + Bitcoin::LeftExtend16_64 => &simplicity_sys::c_jets::jets_wrapper::left_extend_16_64, + Bitcoin::LeftExtend1_16 => &simplicity_sys::c_jets::jets_wrapper::left_extend_1_16, + Bitcoin::LeftExtend1_32 => &simplicity_sys::c_jets::jets_wrapper::left_extend_1_32, + Bitcoin::LeftExtend1_64 => &simplicity_sys::c_jets::jets_wrapper::left_extend_1_64, + Bitcoin::LeftExtend1_8 => &simplicity_sys::c_jets::jets_wrapper::left_extend_1_8, + Bitcoin::LeftExtend32_64 => &simplicity_sys::c_jets::jets_wrapper::left_extend_32_64, + Bitcoin::LeftExtend8_16 => &simplicity_sys::c_jets::jets_wrapper::left_extend_8_16, + Bitcoin::LeftExtend8_32 => &simplicity_sys::c_jets::jets_wrapper::left_extend_8_32, + Bitcoin::LeftExtend8_64 => &simplicity_sys::c_jets::jets_wrapper::left_extend_8_64, + Bitcoin::LeftPadHigh16_32 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_16_32, + Bitcoin::LeftPadHigh16_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_16_64, + Bitcoin::LeftPadHigh1_16 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_16, + Bitcoin::LeftPadHigh1_32 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_32, + Bitcoin::LeftPadHigh1_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_64, + Bitcoin::LeftPadHigh1_8 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_8, + Bitcoin::LeftPadHigh32_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_32_64, + Bitcoin::LeftPadHigh8_16 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_8_16, + Bitcoin::LeftPadHigh8_32 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_8_32, + Bitcoin::LeftPadHigh8_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_8_64, + Bitcoin::LeftPadLow16_32 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_16_32, + Bitcoin::LeftPadLow16_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_16_64, + Bitcoin::LeftPadLow1_16 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_1_16, + Bitcoin::LeftPadLow1_32 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_1_32, + Bitcoin::LeftPadLow1_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_1_64, + Bitcoin::LeftPadLow1_8 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_1_8, + Bitcoin::LeftPadLow32_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_32_64, + Bitcoin::LeftPadLow8_16 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_8_16, + Bitcoin::LeftPadLow8_32 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_8_32, + Bitcoin::LeftPadLow8_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_low_8_64, + Bitcoin::LeftRotate16 => &simplicity_sys::c_jets::jets_wrapper::left_rotate_16, + Bitcoin::LeftRotate32 => &simplicity_sys::c_jets::jets_wrapper::left_rotate_32, + Bitcoin::LeftRotate64 => &simplicity_sys::c_jets::jets_wrapper::left_rotate_64, + Bitcoin::LeftRotate8 => &simplicity_sys::c_jets::jets_wrapper::left_rotate_8, + Bitcoin::LeftShift16 => &simplicity_sys::c_jets::jets_wrapper::left_shift_16, + Bitcoin::LeftShift32 => &simplicity_sys::c_jets::jets_wrapper::left_shift_32, + Bitcoin::LeftShift64 => &simplicity_sys::c_jets::jets_wrapper::left_shift_64, + Bitcoin::LeftShift8 => &simplicity_sys::c_jets::jets_wrapper::left_shift_8, + Bitcoin::LeftShiftWith16 => &simplicity_sys::c_jets::jets_wrapper::left_shift_with_16, + Bitcoin::LeftShiftWith32 => &simplicity_sys::c_jets::jets_wrapper::left_shift_with_32, + Bitcoin::LeftShiftWith64 => &simplicity_sys::c_jets::jets_wrapper::left_shift_with_64, + Bitcoin::LeftShiftWith8 => &simplicity_sys::c_jets::jets_wrapper::left_shift_with_8, + Bitcoin::Leftmost16_1 => &simplicity_sys::c_jets::jets_wrapper::leftmost_16_1, + Bitcoin::Leftmost16_2 => &simplicity_sys::c_jets::jets_wrapper::leftmost_16_2, + Bitcoin::Leftmost16_4 => &simplicity_sys::c_jets::jets_wrapper::leftmost_16_4, + Bitcoin::Leftmost16_8 => &simplicity_sys::c_jets::jets_wrapper::leftmost_16_8, + Bitcoin::Leftmost32_1 => &simplicity_sys::c_jets::jets_wrapper::leftmost_32_1, + Bitcoin::Leftmost32_16 => &simplicity_sys::c_jets::jets_wrapper::leftmost_32_16, + Bitcoin::Leftmost32_2 => &simplicity_sys::c_jets::jets_wrapper::leftmost_32_2, + Bitcoin::Leftmost32_4 => &simplicity_sys::c_jets::jets_wrapper::leftmost_32_4, + Bitcoin::Leftmost32_8 => &simplicity_sys::c_jets::jets_wrapper::leftmost_32_8, + Bitcoin::Leftmost64_1 => &simplicity_sys::c_jets::jets_wrapper::leftmost_64_1, + Bitcoin::Leftmost64_16 => &simplicity_sys::c_jets::jets_wrapper::leftmost_64_16, + Bitcoin::Leftmost64_2 => &simplicity_sys::c_jets::jets_wrapper::leftmost_64_2, + Bitcoin::Leftmost64_32 => &simplicity_sys::c_jets::jets_wrapper::leftmost_64_32, + Bitcoin::Leftmost64_4 => &simplicity_sys::c_jets::jets_wrapper::leftmost_64_4, + Bitcoin::Leftmost64_8 => &simplicity_sys::c_jets::jets_wrapper::leftmost_64_8, + Bitcoin::Leftmost8_1 => &simplicity_sys::c_jets::jets_wrapper::leftmost_8_1, + Bitcoin::Leftmost8_2 => &simplicity_sys::c_jets::jets_wrapper::leftmost_8_2, + Bitcoin::Leftmost8_4 => &simplicity_sys::c_jets::jets_wrapper::leftmost_8_4, + Bitcoin::LinearCombination1 => { + &simplicity_sys::c_jets::jets_wrapper::linear_combination_1 + } + Bitcoin::LinearVerify1 => &simplicity_sys::c_jets::jets_wrapper::linear_verify_1, + Bitcoin::LockTime => &simplicity_sys::c_jets::jets_wrapper::bitcoin_lock_time, + Bitcoin::Low1 => &simplicity_sys::c_jets::jets_wrapper::low_1, + Bitcoin::Low16 => &simplicity_sys::c_jets::jets_wrapper::low_16, + Bitcoin::Low32 => &simplicity_sys::c_jets::jets_wrapper::low_32, + Bitcoin::Low64 => &simplicity_sys::c_jets::jets_wrapper::low_64, + Bitcoin::Low8 => &simplicity_sys::c_jets::jets_wrapper::low_8, + Bitcoin::Lt16 => &simplicity_sys::c_jets::jets_wrapper::lt_16, + Bitcoin::Lt32 => &simplicity_sys::c_jets::jets_wrapper::lt_32, + Bitcoin::Lt64 => &simplicity_sys::c_jets::jets_wrapper::lt_64, + Bitcoin::Lt8 => &simplicity_sys::c_jets::jets_wrapper::lt_8, + Bitcoin::Maj1 => &simplicity_sys::c_jets::jets_wrapper::maj_1, + Bitcoin::Maj16 => &simplicity_sys::c_jets::jets_wrapper::maj_16, + Bitcoin::Maj32 => &simplicity_sys::c_jets::jets_wrapper::maj_32, + Bitcoin::Maj64 => &simplicity_sys::c_jets::jets_wrapper::maj_64, + Bitcoin::Maj8 => &simplicity_sys::c_jets::jets_wrapper::maj_8, + Bitcoin::Max16 => &simplicity_sys::c_jets::jets_wrapper::max_16, + Bitcoin::Max32 => &simplicity_sys::c_jets::jets_wrapper::max_32, + Bitcoin::Max64 => &simplicity_sys::c_jets::jets_wrapper::max_64, + Bitcoin::Max8 => &simplicity_sys::c_jets::jets_wrapper::max_8, + Bitcoin::Median16 => &simplicity_sys::c_jets::jets_wrapper::median_16, + Bitcoin::Median32 => &simplicity_sys::c_jets::jets_wrapper::median_32, + Bitcoin::Median64 => &simplicity_sys::c_jets::jets_wrapper::median_64, + Bitcoin::Median8 => &simplicity_sys::c_jets::jets_wrapper::median_8, + Bitcoin::Min16 => &simplicity_sys::c_jets::jets_wrapper::min_16, + Bitcoin::Min32 => &simplicity_sys::c_jets::jets_wrapper::min_32, + Bitcoin::Min64 => &simplicity_sys::c_jets::jets_wrapper::min_64, + Bitcoin::Min8 => &simplicity_sys::c_jets::jets_wrapper::min_8, + Bitcoin::Modulo16 => &simplicity_sys::c_jets::jets_wrapper::modulo_16, + Bitcoin::Modulo32 => &simplicity_sys::c_jets::jets_wrapper::modulo_32, + Bitcoin::Modulo64 => &simplicity_sys::c_jets::jets_wrapper::modulo_64, + Bitcoin::Modulo8 => &simplicity_sys::c_jets::jets_wrapper::modulo_8, + Bitcoin::Multiply16 => &simplicity_sys::c_jets::jets_wrapper::multiply_16, + Bitcoin::Multiply32 => &simplicity_sys::c_jets::jets_wrapper::multiply_32, + Bitcoin::Multiply64 => &simplicity_sys::c_jets::jets_wrapper::multiply_64, + Bitcoin::Multiply8 => &simplicity_sys::c_jets::jets_wrapper::multiply_8, + Bitcoin::Negate16 => &simplicity_sys::c_jets::jets_wrapper::negate_16, + Bitcoin::Negate32 => &simplicity_sys::c_jets::jets_wrapper::negate_32, + Bitcoin::Negate64 => &simplicity_sys::c_jets::jets_wrapper::negate_64, + Bitcoin::Negate8 => &simplicity_sys::c_jets::jets_wrapper::negate_8, + Bitcoin::NumInputs => &simplicity_sys::c_jets::jets_wrapper::bitcoin_num_inputs, + Bitcoin::NumOutputs => &simplicity_sys::c_jets::jets_wrapper::bitcoin_num_outputs, + Bitcoin::One16 => &simplicity_sys::c_jets::jets_wrapper::one_16, + Bitcoin::One32 => &simplicity_sys::c_jets::jets_wrapper::one_32, + Bitcoin::One64 => &simplicity_sys::c_jets::jets_wrapper::one_64, + Bitcoin::One8 => &simplicity_sys::c_jets::jets_wrapper::one_8, + Bitcoin::Or1 => &simplicity_sys::c_jets::jets_wrapper::or_1, + Bitcoin::Or16 => &simplicity_sys::c_jets::jets_wrapper::or_16, + Bitcoin::Or32 => &simplicity_sys::c_jets::jets_wrapper::or_32, + Bitcoin::Or64 => &simplicity_sys::c_jets::jets_wrapper::or_64, + Bitcoin::Or8 => &simplicity_sys::c_jets::jets_wrapper::or_8, + Bitcoin::OutpointHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_outpoint_hash, + Bitcoin::OutputHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_output_hash, + Bitcoin::OutputScriptHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_output_script_hash + } + Bitcoin::OutputScriptsHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_output_scripts_hash + } + Bitcoin::OutputValue => &simplicity_sys::c_jets::jets_wrapper::bitcoin_output_value, + Bitcoin::OutputValuesHash => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_output_values_hash + } + Bitcoin::OutputsHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_outputs_hash, + Bitcoin::ParseLock => &simplicity_sys::c_jets::jets_wrapper::parse_lock, + Bitcoin::ParseSequence => &simplicity_sys::c_jets::jets_wrapper::parse_sequence, + Bitcoin::PointVerify1 => &simplicity_sys::c_jets::jets_wrapper::point_verify_1, + Bitcoin::RightExtend16_32 => &simplicity_sys::c_jets::jets_wrapper::right_extend_16_32, + Bitcoin::RightExtend16_64 => &simplicity_sys::c_jets::jets_wrapper::right_extend_16_64, + Bitcoin::RightExtend32_64 => &simplicity_sys::c_jets::jets_wrapper::right_extend_32_64, + Bitcoin::RightExtend8_16 => &simplicity_sys::c_jets::jets_wrapper::right_extend_8_16, + Bitcoin::RightExtend8_32 => &simplicity_sys::c_jets::jets_wrapper::right_extend_8_32, + Bitcoin::RightExtend8_64 => &simplicity_sys::c_jets::jets_wrapper::right_extend_8_64, + Bitcoin::RightPadHigh16_32 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_16_32 + } + Bitcoin::RightPadHigh16_64 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_16_64 + } + Bitcoin::RightPadHigh1_16 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_16, + Bitcoin::RightPadHigh1_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_32, + Bitcoin::RightPadHigh1_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_64, + Bitcoin::RightPadHigh1_8 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_8, + Bitcoin::RightPadHigh32_64 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_32_64 + } + Bitcoin::RightPadHigh8_16 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_16, + Bitcoin::RightPadHigh8_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_32, + Bitcoin::RightPadHigh8_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_64, + Bitcoin::RightPadLow16_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_16_32, + Bitcoin::RightPadLow16_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_16_64, + Bitcoin::RightPadLow1_16 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_16, + Bitcoin::RightPadLow1_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_32, + Bitcoin::RightPadLow1_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_64, + Bitcoin::RightPadLow1_8 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_8, + Bitcoin::RightPadLow32_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_32_64, + Bitcoin::RightPadLow8_16 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_8_16, + Bitcoin::RightPadLow8_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_8_32, + Bitcoin::RightPadLow8_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_8_64, + Bitcoin::RightRotate16 => &simplicity_sys::c_jets::jets_wrapper::right_rotate_16, + Bitcoin::RightRotate32 => &simplicity_sys::c_jets::jets_wrapper::right_rotate_32, + Bitcoin::RightRotate64 => &simplicity_sys::c_jets::jets_wrapper::right_rotate_64, + Bitcoin::RightRotate8 => &simplicity_sys::c_jets::jets_wrapper::right_rotate_8, + Bitcoin::RightShift16 => &simplicity_sys::c_jets::jets_wrapper::right_shift_16, + Bitcoin::RightShift32 => &simplicity_sys::c_jets::jets_wrapper::right_shift_32, + Bitcoin::RightShift64 => &simplicity_sys::c_jets::jets_wrapper::right_shift_64, + Bitcoin::RightShift8 => &simplicity_sys::c_jets::jets_wrapper::right_shift_8, + Bitcoin::RightShiftWith16 => &simplicity_sys::c_jets::jets_wrapper::right_shift_with_16, + Bitcoin::RightShiftWith32 => &simplicity_sys::c_jets::jets_wrapper::right_shift_with_32, + Bitcoin::RightShiftWith64 => &simplicity_sys::c_jets::jets_wrapper::right_shift_with_64, + Bitcoin::RightShiftWith8 => &simplicity_sys::c_jets::jets_wrapper::right_shift_with_8, + Bitcoin::Rightmost16_1 => &simplicity_sys::c_jets::jets_wrapper::rightmost_16_1, + Bitcoin::Rightmost16_2 => &simplicity_sys::c_jets::jets_wrapper::rightmost_16_2, + Bitcoin::Rightmost16_4 => &simplicity_sys::c_jets::jets_wrapper::rightmost_16_4, + Bitcoin::Rightmost16_8 => &simplicity_sys::c_jets::jets_wrapper::rightmost_16_8, + Bitcoin::Rightmost32_1 => &simplicity_sys::c_jets::jets_wrapper::rightmost_32_1, + Bitcoin::Rightmost32_16 => &simplicity_sys::c_jets::jets_wrapper::rightmost_32_16, + Bitcoin::Rightmost32_2 => &simplicity_sys::c_jets::jets_wrapper::rightmost_32_2, + Bitcoin::Rightmost32_4 => &simplicity_sys::c_jets::jets_wrapper::rightmost_32_4, + Bitcoin::Rightmost32_8 => &simplicity_sys::c_jets::jets_wrapper::rightmost_32_8, + Bitcoin::Rightmost64_1 => &simplicity_sys::c_jets::jets_wrapper::rightmost_64_1, + Bitcoin::Rightmost64_16 => &simplicity_sys::c_jets::jets_wrapper::rightmost_64_16, + Bitcoin::Rightmost64_2 => &simplicity_sys::c_jets::jets_wrapper::rightmost_64_2, + Bitcoin::Rightmost64_32 => &simplicity_sys::c_jets::jets_wrapper::rightmost_64_32, + Bitcoin::Rightmost64_4 => &simplicity_sys::c_jets::jets_wrapper::rightmost_64_4, + Bitcoin::Rightmost64_8 => &simplicity_sys::c_jets::jets_wrapper::rightmost_64_8, + Bitcoin::Rightmost8_1 => &simplicity_sys::c_jets::jets_wrapper::rightmost_8_1, + Bitcoin::Rightmost8_2 => &simplicity_sys::c_jets::jets_wrapper::rightmost_8_2, + Bitcoin::Rightmost8_4 => &simplicity_sys::c_jets::jets_wrapper::rightmost_8_4, + Bitcoin::ScalarAdd => &simplicity_sys::c_jets::jets_wrapper::scalar_add, + Bitcoin::ScalarInvert => &simplicity_sys::c_jets::jets_wrapper::scalar_invert, + Bitcoin::ScalarIsZero => &simplicity_sys::c_jets::jets_wrapper::scalar_is_zero, + Bitcoin::ScalarMultiply => &simplicity_sys::c_jets::jets_wrapper::scalar_multiply, + Bitcoin::ScalarMultiplyLambda => { + &simplicity_sys::c_jets::jets_wrapper::scalar_multiply_lambda + } + Bitcoin::ScalarNegate => &simplicity_sys::c_jets::jets_wrapper::scalar_negate, + Bitcoin::ScalarNormalize => &simplicity_sys::c_jets::jets_wrapper::scalar_normalize, + Bitcoin::ScalarSquare => &simplicity_sys::c_jets::jets_wrapper::scalar_square, + Bitcoin::Scale => &simplicity_sys::c_jets::jets_wrapper::scale, + Bitcoin::ScriptCMR => &simplicity_sys::c_jets::jets_wrapper::bitcoin_script_cmr, + Bitcoin::Sha256Block => &simplicity_sys::c_jets::jets_wrapper::sha_256_block, + Bitcoin::Sha256Ctx8Add1 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_1, + Bitcoin::Sha256Ctx8Add128 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_128 + } + Bitcoin::Sha256Ctx8Add16 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_16, + Bitcoin::Sha256Ctx8Add2 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_2, + Bitcoin::Sha256Ctx8Add256 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_256 + } + Bitcoin::Sha256Ctx8Add32 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_32, + Bitcoin::Sha256Ctx8Add4 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_4, + Bitcoin::Sha256Ctx8Add512 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_512 + } + Bitcoin::Sha256Ctx8Add64 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_64, + Bitcoin::Sha256Ctx8Add8 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_8, + Bitcoin::Sha256Ctx8AddBuffer511 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_buffer_511 + } + Bitcoin::Sha256Ctx8Finalize => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_finalize + } + Bitcoin::Sha256Ctx8Init => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_init, + Bitcoin::Sha256Iv => &simplicity_sys::c_jets::jets_wrapper::sha_256_iv, + Bitcoin::SigAllHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_sig_all_hash, + Bitcoin::Some1 => &simplicity_sys::c_jets::jets_wrapper::some_1, + Bitcoin::Some16 => &simplicity_sys::c_jets::jets_wrapper::some_16, + Bitcoin::Some32 => &simplicity_sys::c_jets::jets_wrapper::some_32, + Bitcoin::Some64 => &simplicity_sys::c_jets::jets_wrapper::some_64, + Bitcoin::Some8 => &simplicity_sys::c_jets::jets_wrapper::some_8, + Bitcoin::Subtract16 => &simplicity_sys::c_jets::jets_wrapper::subtract_16, + Bitcoin::Subtract32 => &simplicity_sys::c_jets::jets_wrapper::subtract_32, + Bitcoin::Subtract64 => &simplicity_sys::c_jets::jets_wrapper::subtract_64, + Bitcoin::Subtract8 => &simplicity_sys::c_jets::jets_wrapper::subtract_8, + Bitcoin::Swu => &simplicity_sys::c_jets::jets_wrapper::swu, + Bitcoin::TapEnvHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_tap_env_hash, + Bitcoin::TapdataInit => &simplicity_sys::c_jets::jets_wrapper::tapdata_init, + Bitcoin::TapleafHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_tapleaf_hash, + Bitcoin::TapleafVersion => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_tapleaf_version + } + Bitcoin::Tappath => &simplicity_sys::c_jets::jets_wrapper::bitcoin_tappath, + Bitcoin::TappathHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_tappath_hash, + Bitcoin::TotalInputValue => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_total_input_value + } + Bitcoin::TotalOutputValue => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_total_output_value + } + Bitcoin::TransactionId => &simplicity_sys::c_jets::jets_wrapper::bitcoin_transaction_id, + Bitcoin::TxHash => &simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_hash, + Bitcoin::TxIsFinal => &simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_is_final, + Bitcoin::TxLockDistance => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_lock_distance + } + Bitcoin::TxLockDuration => { + &simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_lock_duration + } + Bitcoin::TxLockHeight => &simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_lock_height, + Bitcoin::TxLockTime => &simplicity_sys::c_jets::jets_wrapper::bitcoin_tx_lock_time, + Bitcoin::Verify => &simplicity_sys::c_jets::jets_wrapper::verify, + Bitcoin::Version => &simplicity_sys::c_jets::jets_wrapper::bitcoin_version, + Bitcoin::Xor1 => &simplicity_sys::c_jets::jets_wrapper::xor_1, + Bitcoin::Xor16 => &simplicity_sys::c_jets::jets_wrapper::xor_16, + Bitcoin::Xor32 => &simplicity_sys::c_jets::jets_wrapper::xor_32, + Bitcoin::Xor64 => &simplicity_sys::c_jets::jets_wrapper::xor_64, + Bitcoin::Xor8 => &simplicity_sys::c_jets::jets_wrapper::xor_8, + Bitcoin::XorXor1 => &simplicity_sys::c_jets::jets_wrapper::xor_xor_1, + Bitcoin::XorXor16 => &simplicity_sys::c_jets::jets_wrapper::xor_xor_16, + Bitcoin::XorXor32 => &simplicity_sys::c_jets::jets_wrapper::xor_xor_32, + Bitcoin::XorXor64 => &simplicity_sys::c_jets::jets_wrapper::xor_xor_64, + Bitcoin::XorXor8 => &simplicity_sys::c_jets::jets_wrapper::xor_xor_8, + } } fn cost(&self) -> Cost { @@ -4501,7 +5347,11 @@ impl fmt::Display for Bitcoin { Bitcoin::And32 => f.write_str("and_32"), Bitcoin::And64 => f.write_str("and_64"), Bitcoin::And8 => f.write_str("and_8"), + Bitcoin::AnnexHash => f.write_str("annex_hash"), Bitcoin::Bip0340Verify => f.write_str("bip_0340_verify"), + Bitcoin::BuildTapbranch => f.write_str("build_tapbranch"), + Bitcoin::BuildTapleafSimplicity => f.write_str("build_tapleaf_simplicity"), + Bitcoin::BuildTaptweak => f.write_str("build_taptweak"), Bitcoin::Ch1 => f.write_str("ch_1"), Bitcoin::Ch16 => f.write_str("ch_16"), Bitcoin::Ch32 => f.write_str("ch_32"), @@ -4520,6 +5370,7 @@ impl fmt::Display for Bitcoin { Bitcoin::CurrentAnnexHash => f.write_str("current_annex_hash"), Bitcoin::CurrentIndex => f.write_str("current_index"), Bitcoin::CurrentPrevOutpoint => f.write_str("current_prev_outpoint"), + Bitcoin::CurrentScriptHash => f.write_str("current_script_hash"), Bitcoin::CurrentScriptSigHash => f.write_str("current_script_sig_hash"), Bitcoin::CurrentSequence => f.write_str("current_sequence"), Bitcoin::CurrentValue => f.write_str("current_value"), @@ -4557,6 +5408,7 @@ impl fmt::Display for Bitcoin { Bitcoin::FeNormalize => f.write_str("fe_normalize"), Bitcoin::FeSquare => f.write_str("fe_square"), Bitcoin::FeSquareRoot => f.write_str("fe_square_root"), + Bitcoin::Fee => f.write_str("fee"), Bitcoin::FullAdd16 => f.write_str("full_add_16"), Bitcoin::FullAdd32 => f.write_str("full_add_32"), Bitcoin::FullAdd64 => f.write_str("full_add_64"), @@ -4641,10 +5493,21 @@ impl fmt::Display for Bitcoin { Bitcoin::Increment64 => f.write_str("increment_64"), Bitcoin::Increment8 => f.write_str("increment_8"), Bitcoin::InputAnnexHash => f.write_str("input_annex_hash"), + Bitcoin::InputAnnexesHash => f.write_str("input_annexes_hash"), + Bitcoin::InputHash => f.write_str("input_hash"), + Bitcoin::InputOutpointsHash => f.write_str("input_outpoints_hash"), Bitcoin::InputPrevOutpoint => f.write_str("input_prev_outpoint"), + Bitcoin::InputScriptHash => f.write_str("input_script_hash"), Bitcoin::InputScriptSigHash => f.write_str("input_script_sig_hash"), + Bitcoin::InputScriptSigsHash => f.write_str("input_script_sigs_hash"), + Bitcoin::InputScriptsHash => f.write_str("input_scripts_hash"), Bitcoin::InputSequence => f.write_str("input_sequence"), + Bitcoin::InputSequencesHash => f.write_str("input_sequences_hash"), + Bitcoin::InputUtxoHash => f.write_str("input_utxo_hash"), + Bitcoin::InputUtxosHash => f.write_str("input_utxos_hash"), Bitcoin::InputValue => f.write_str("input_value"), + Bitcoin::InputValuesHash => f.write_str("input_values_hash"), + Bitcoin::InputsHash => f.write_str("inputs_hash"), Bitcoin::InternalKey => f.write_str("internal_key"), Bitcoin::IsOne16 => f.write_str("is_one_16"), Bitcoin::IsOne32 => f.write_str("is_one_32"), @@ -4770,8 +5633,13 @@ impl fmt::Display for Bitcoin { Bitcoin::Or32 => f.write_str("or_32"), Bitcoin::Or64 => f.write_str("or_64"), Bitcoin::Or8 => f.write_str("or_8"), + Bitcoin::OutpointHash => f.write_str("outpoint_hash"), + Bitcoin::OutputHash => f.write_str("output_hash"), Bitcoin::OutputScriptHash => f.write_str("output_script_hash"), + Bitcoin::OutputScriptsHash => f.write_str("output_scripts_hash"), Bitcoin::OutputValue => f.write_str("output_value"), + Bitcoin::OutputValuesHash => f.write_str("output_values_hash"), + Bitcoin::OutputsHash => f.write_str("outputs_hash"), Bitcoin::ParseLock => f.write_str("parse_lock"), Bitcoin::ParseSequence => f.write_str("parse_sequence"), Bitcoin::PointVerify1 => f.write_str("point_verify_1"), @@ -4856,6 +5724,7 @@ impl fmt::Display for Bitcoin { Bitcoin::Sha256Ctx8Finalize => f.write_str("sha_256_ctx_8_finalize"), Bitcoin::Sha256Ctx8Init => f.write_str("sha_256_ctx_8_init"), Bitcoin::Sha256Iv => f.write_str("sha_256_iv"), + Bitcoin::SigAllHash => f.write_str("sig_all_hash"), Bitcoin::Some1 => f.write_str("some_1"), Bitcoin::Some16 => f.write_str("some_16"), Bitcoin::Some32 => f.write_str("some_32"), @@ -4866,11 +5735,16 @@ impl fmt::Display for Bitcoin { Bitcoin::Subtract64 => f.write_str("subtract_64"), Bitcoin::Subtract8 => f.write_str("subtract_8"), Bitcoin::Swu => f.write_str("swu"), + Bitcoin::TapEnvHash => f.write_str("tap_env_hash"), Bitcoin::TapdataInit => f.write_str("tapdata_init"), + Bitcoin::TapleafHash => f.write_str("tapleaf_hash"), Bitcoin::TapleafVersion => f.write_str("tapleaf_version"), Bitcoin::Tappath => f.write_str("tappath"), + Bitcoin::TappathHash => f.write_str("tappath_hash"), Bitcoin::TotalInputValue => f.write_str("total_input_value"), Bitcoin::TotalOutputValue => f.write_str("total_output_value"), + Bitcoin::TransactionId => f.write_str("transaction_id"), + Bitcoin::TxHash => f.write_str("tx_hash"), Bitcoin::TxIsFinal => f.write_str("tx_is_final"), Bitcoin::TxLockDistance => f.write_str("tx_lock_distance"), Bitcoin::TxLockDuration => f.write_str("tx_lock_duration"), @@ -4910,7 +5784,11 @@ impl str::FromStr for Bitcoin { "and_32" => Ok(Bitcoin::And32), "and_64" => Ok(Bitcoin::And64), "and_8" => Ok(Bitcoin::And8), + "annex_hash" => Ok(Bitcoin::AnnexHash), "bip_0340_verify" => Ok(Bitcoin::Bip0340Verify), + "build_tapbranch" => Ok(Bitcoin::BuildTapbranch), + "build_tapleaf_simplicity" => Ok(Bitcoin::BuildTapleafSimplicity), + "build_taptweak" => Ok(Bitcoin::BuildTaptweak), "ch_1" => Ok(Bitcoin::Ch1), "ch_16" => Ok(Bitcoin::Ch16), "ch_32" => Ok(Bitcoin::Ch32), @@ -4929,6 +5807,7 @@ impl str::FromStr for Bitcoin { "current_annex_hash" => Ok(Bitcoin::CurrentAnnexHash), "current_index" => Ok(Bitcoin::CurrentIndex), "current_prev_outpoint" => Ok(Bitcoin::CurrentPrevOutpoint), + "current_script_hash" => Ok(Bitcoin::CurrentScriptHash), "current_script_sig_hash" => Ok(Bitcoin::CurrentScriptSigHash), "current_sequence" => Ok(Bitcoin::CurrentSequence), "current_value" => Ok(Bitcoin::CurrentValue), @@ -4966,6 +5845,7 @@ impl str::FromStr for Bitcoin { "fe_normalize" => Ok(Bitcoin::FeNormalize), "fe_square" => Ok(Bitcoin::FeSquare), "fe_square_root" => Ok(Bitcoin::FeSquareRoot), + "fee" => Ok(Bitcoin::Fee), "full_add_16" => Ok(Bitcoin::FullAdd16), "full_add_32" => Ok(Bitcoin::FullAdd32), "full_add_64" => Ok(Bitcoin::FullAdd64), @@ -5050,10 +5930,21 @@ impl str::FromStr for Bitcoin { "increment_64" => Ok(Bitcoin::Increment64), "increment_8" => Ok(Bitcoin::Increment8), "input_annex_hash" => Ok(Bitcoin::InputAnnexHash), + "input_annexes_hash" => Ok(Bitcoin::InputAnnexesHash), + "input_hash" => Ok(Bitcoin::InputHash), + "input_outpoints_hash" => Ok(Bitcoin::InputOutpointsHash), "input_prev_outpoint" => Ok(Bitcoin::InputPrevOutpoint), + "input_script_hash" => Ok(Bitcoin::InputScriptHash), "input_script_sig_hash" => Ok(Bitcoin::InputScriptSigHash), + "input_script_sigs_hash" => Ok(Bitcoin::InputScriptSigsHash), + "input_scripts_hash" => Ok(Bitcoin::InputScriptsHash), "input_sequence" => Ok(Bitcoin::InputSequence), + "input_sequences_hash" => Ok(Bitcoin::InputSequencesHash), + "input_utxo_hash" => Ok(Bitcoin::InputUtxoHash), + "input_utxos_hash" => Ok(Bitcoin::InputUtxosHash), "input_value" => Ok(Bitcoin::InputValue), + "input_values_hash" => Ok(Bitcoin::InputValuesHash), + "inputs_hash" => Ok(Bitcoin::InputsHash), "internal_key" => Ok(Bitcoin::InternalKey), "is_one_16" => Ok(Bitcoin::IsOne16), "is_one_32" => Ok(Bitcoin::IsOne32), @@ -5179,8 +6070,13 @@ impl str::FromStr for Bitcoin { "or_32" => Ok(Bitcoin::Or32), "or_64" => Ok(Bitcoin::Or64), "or_8" => Ok(Bitcoin::Or8), + "outpoint_hash" => Ok(Bitcoin::OutpointHash), + "output_hash" => Ok(Bitcoin::OutputHash), "output_script_hash" => Ok(Bitcoin::OutputScriptHash), + "output_scripts_hash" => Ok(Bitcoin::OutputScriptsHash), "output_value" => Ok(Bitcoin::OutputValue), + "output_values_hash" => Ok(Bitcoin::OutputValuesHash), + "outputs_hash" => Ok(Bitcoin::OutputsHash), "parse_lock" => Ok(Bitcoin::ParseLock), "parse_sequence" => Ok(Bitcoin::ParseSequence), "point_verify_1" => Ok(Bitcoin::PointVerify1), @@ -5265,6 +6161,7 @@ impl str::FromStr for Bitcoin { "sha_256_ctx_8_finalize" => Ok(Bitcoin::Sha256Ctx8Finalize), "sha_256_ctx_8_init" => Ok(Bitcoin::Sha256Ctx8Init), "sha_256_iv" => Ok(Bitcoin::Sha256Iv), + "sig_all_hash" => Ok(Bitcoin::SigAllHash), "some_1" => Ok(Bitcoin::Some1), "some_16" => Ok(Bitcoin::Some16), "some_32" => Ok(Bitcoin::Some32), @@ -5275,11 +6172,16 @@ impl str::FromStr for Bitcoin { "subtract_64" => Ok(Bitcoin::Subtract64), "subtract_8" => Ok(Bitcoin::Subtract8), "swu" => Ok(Bitcoin::Swu), + "tap_env_hash" => Ok(Bitcoin::TapEnvHash), "tapdata_init" => Ok(Bitcoin::TapdataInit), + "tapleaf_hash" => Ok(Bitcoin::TapleafHash), "tapleaf_version" => Ok(Bitcoin::TapleafVersion), "tappath" => Ok(Bitcoin::Tappath), + "tappath_hash" => Ok(Bitcoin::TappathHash), "total_input_value" => Ok(Bitcoin::TotalInputValue), "total_output_value" => Ok(Bitcoin::TotalOutputValue), + "transaction_id" => Ok(Bitcoin::TransactionId), + "tx_hash" => Ok(Bitcoin::TxHash), "tx_is_final" => Ok(Bitcoin::TxIsFinal), "tx_lock_distance" => Ok(Bitcoin::TxLockDistance), "tx_lock_duration" => Ok(Bitcoin::TxLockDuration), diff --git a/src/jet/init/core.rs b/src/jet/init/core.rs index c5123c20..8fa658f8 100644 --- a/src/jet/init/core.rs +++ b/src/jet/init/core.rs @@ -1,15 +1,16 @@ /* This file has been automatically generated. */ +use crate::analysis::Cost; +use crate::decode_bits; +use crate::jet::core::CoreEnv; use crate::jet::type_name::TypeName; use crate::jet::Jet; use crate::merkle::cmr::Cmr; -use crate::decode_bits; use crate::{decode, BitIter, BitWriter}; -use crate::analysis::Cost; use hashes::sha256::Midstate; use simplicity_sys::CFrameItem; use std::io::Write; -use std::{fmt, str}; +use std::{borrow::Borrow, fmt, str}; /// The Core jet family. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] @@ -759,110 +760,116 @@ impl Core { } impl Jet for Core { + type Transaction = core::convert::Infallible; + type Environment + = CoreEnv + where + T: Borrow; + type CJetEnvironment = CoreEnv; - type Environment = (); - type CJetEnvironment = (); - - fn c_jet_env(env: &Self::Environment) -> &Self::CJetEnvironment { - env + fn c_jet_env(_: &Self::Environment) -> &Self::CJetEnvironment + where + T: Borrow, + { + &CoreEnv::EMPTY } fn cmr(&self) -> Cmr { let bytes = match self { Core::Add16 => [ - 0x26, 0xae, 0x09, 0x94, 0xce, 0x8b, 0x77, 0x1a, 0xf7, 0xad, 0x28, 0x51, 0xb8, 0x3b, - 0x49, 0xa5, 0x95, 0x05, 0x36, 0x58, 0x9f, 0x67, 0xbd, 0x85, 0x59, 0x47, 0x04, 0x60, - 0x29, 0x75, 0x1c, 0x0d, + 0x49, 0x42, 0x5a, 0x86, 0xe2, 0x0a, 0x67, 0x6d, 0x8b, 0x87, 0xe3, 0xc1, 0xa9, 0xb8, + 0xea, 0x6e, 0xc7, 0x5d, 0x85, 0x9c, 0x12, 0xc5, 0x1b, 0xcb, 0x7f, 0xa9, 0xf9, 0x69, + 0x12, 0xc3, 0x49, 0xcf, ], Core::Add32 => [ - 0x3d, 0x76, 0x74, 0x46, 0x6e, 0xd6, 0x9e, 0x1d, 0xbe, 0xdc, 0xd4, 0x80, 0x57, 0xa9, - 0xe6, 0x28, 0x8c, 0x22, 0x25, 0x32, 0xfb, 0xc5, 0x04, 0x80, 0x49, 0x92, 0x8c, 0xfb, - 0x77, 0xf8, 0x29, 0xd9, + 0x46, 0x68, 0xcd, 0x55, 0xe8, 0xd1, 0x59, 0x19, 0x53, 0x32, 0x70, 0x14, 0xec, 0x64, + 0xc8, 0xe7, 0xd5, 0x2b, 0x86, 0xb5, 0x3e, 0x11, 0xc0, 0x14, 0x57, 0xea, 0xf2, 0xc3, + 0xd3, 0xce, 0xbf, 0x9f, ], Core::Add64 => [ - 0x9b, 0x56, 0xe6, 0x1e, 0xef, 0xe2, 0x80, 0x5c, 0xa8, 0x73, 0x96, 0xbd, 0xfb, 0x03, - 0xf5, 0xe1, 0xb1, 0x38, 0x5f, 0x7a, 0xc4, 0xbf, 0xf7, 0x68, 0x40, 0x26, 0xa0, 0x7c, - 0xf9, 0x7f, 0xb6, 0xf6, + 0xbe, 0x2b, 0x75, 0x19, 0x30, 0x3a, 0x67, 0xee, 0xa6, 0xb4, 0x82, 0x95, 0x0e, 0xda, + 0x83, 0x43, 0x5e, 0x1d, 0xe8, 0x55, 0x9c, 0x39, 0x4a, 0x23, 0x62, 0x22, 0xff, 0x5b, + 0xf0, 0x89, 0xd3, 0x46, ], Core::Add8 => [ - 0xd7, 0x32, 0x8c, 0x09, 0x14, 0xee, 0x99, 0x9e, 0xfa, 0x0a, 0x6c, 0xb2, 0x6e, 0xb4, - 0x09, 0x12, 0xc2, 0x15, 0xc0, 0x62, 0xe5, 0x8a, 0x98, 0x1a, 0xe6, 0xb2, 0xe4, 0xa8, - 0x04, 0x74, 0xa1, 0xda, + 0xdf, 0xa1, 0x79, 0xad, 0xf4, 0x55, 0x0b, 0x28, 0x48, 0x73, 0xbf, 0x30, 0x12, 0x3e, + 0x0d, 0x4e, 0x54, 0x06, 0x9b, 0x08, 0x58, 0x34, 0xce, 0x56, 0x58, 0x15, 0xef, 0x7e, + 0x45, 0x78, 0x4a, 0xcb, ], Core::All16 => [ - 0x16, 0xf0, 0xc9, 0x30, 0x7e, 0xb8, 0xf4, 0xc1, 0xfd, 0xd1, 0xba, 0xfa, 0xef, 0x28, - 0x79, 0x24, 0x29, 0x58, 0x49, 0x8e, 0x8f, 0x5b, 0x2e, 0x0d, 0x29, 0xf0, 0x65, 0x53, - 0xdc, 0x06, 0xa0, 0xbd, + 0x24, 0xf4, 0x82, 0xa5, 0x13, 0xd3, 0x33, 0x62, 0x01, 0x5d, 0x28, 0xdf, 0x4b, 0xb6, + 0xc3, 0xee, 0x08, 0xab, 0x8a, 0xfb, 0xbd, 0x25, 0x57, 0x1f, 0x0e, 0xa8, 0x9d, 0x8c, + 0xab, 0xa3, 0x14, 0x04, ], Core::All32 => [ - 0x0e, 0xb8, 0xb4, 0x0d, 0x29, 0x02, 0x17, 0x47, 0xee, 0xc4, 0x51, 0xd4, 0xe6, 0x63, - 0x58, 0x6a, 0x43, 0x6c, 0x2d, 0xb0, 0x93, 0x26, 0x75, 0xda, 0xf2, 0x16, 0x61, 0x23, - 0xbf, 0xe4, 0x52, 0xa6, + 0xa7, 0x16, 0x52, 0x2d, 0x0f, 0x37, 0x87, 0xc8, 0xb4, 0xd5, 0x07, 0x64, 0x7f, 0x1f, + 0x80, 0x7b, 0x67, 0xf3, 0x20, 0xd6, 0xeb, 0x67, 0xb8, 0x4b, 0x60, 0x9c, 0xec, 0x1d, + 0x2f, 0x12, 0x21, 0x8a, ], Core::All64 => [ - 0xa6, 0x5c, 0x82, 0xd5, 0x3d, 0x38, 0x2e, 0xe2, 0x9a, 0xa8, 0x8b, 0x77, 0x18, 0xa9, - 0x7f, 0xbb, 0xce, 0x64, 0x75, 0xec, 0x32, 0xc4, 0xb4, 0xcd, 0x69, 0x08, 0xfd, 0xe4, - 0x5d, 0x81, 0xb6, 0x24, + 0x7a, 0xee, 0xfe, 0x2e, 0xce, 0x24, 0xba, 0xb3, 0x7c, 0x6e, 0x54, 0x30, 0xee, 0xd4, + 0x19, 0xfc, 0xd5, 0xf0, 0x37, 0x91, 0x2d, 0x17, 0x70, 0xcb, 0x7d, 0x65, 0x20, 0xdc, + 0xe5, 0x25, 0x29, 0x1a, ], Core::All8 => [ - 0x1d, 0x3e, 0xc7, 0xfb, 0x6a, 0x07, 0x84, 0x7c, 0x92, 0xb8, 0xa9, 0x98, 0xe1, 0xf6, - 0xb4, 0x78, 0x31, 0x9d, 0x05, 0x0a, 0x38, 0x76, 0x42, 0xf4, 0x03, 0x2d, 0x2f, 0x7d, - 0x2e, 0x02, 0x7f, 0xcd, + 0x46, 0x37, 0xf4, 0x0e, 0x5f, 0x47, 0x26, 0xb0, 0x05, 0x70, 0x76, 0x5a, 0xc7, 0x94, + 0xe2, 0x9e, 0xd1, 0xbb, 0x26, 0x55, 0xff, 0xc4, 0x12, 0xb2, 0xdc, 0x41, 0x25, 0x8e, + 0x41, 0xaa, 0xc6, 0x24, ], Core::And1 => [ - 0xb7, 0x73, 0xce, 0xfa, 0x41, 0x89, 0x57, 0xfe, 0xa7, 0xdf, 0xb4, 0x9c, 0x6c, 0x43, - 0xb3, 0xdb, 0xfa, 0x35, 0xfa, 0x3d, 0x80, 0xde, 0x8c, 0xfd, 0x4d, 0x70, 0xc0, 0x8d, - 0x94, 0x5f, 0x5f, 0xba, + 0x10, 0x68, 0x4d, 0x0d, 0xd7, 0x2c, 0xb0, 0xa8, 0x26, 0xa8, 0x63, 0x83, 0x4e, 0x01, + 0x1f, 0x50, 0xfa, 0x0d, 0x55, 0x8b, 0xa7, 0x7d, 0x6b, 0x9f, 0x49, 0xa1, 0xac, 0x22, + 0x90, 0x2a, 0x6a, 0xd0, ], Core::And16 => [ - 0x57, 0xdd, 0x73, 0x0b, 0x1c, 0x8d, 0xdf, 0xf1, 0x3c, 0xae, 0x27, 0x69, 0x56, 0x2b, - 0xe0, 0xab, 0xc6, 0xca, 0x3b, 0xc8, 0x02, 0xda, 0x0a, 0xbb, 0xb7, 0xfc, 0x13, 0x8c, - 0xa4, 0x63, 0xda, 0x59, + 0x37, 0x3c, 0x73, 0x0f, 0xad, 0x3e, 0x88, 0x47, 0x99, 0x1a, 0xa4, 0x17, 0xd9, 0xf0, + 0x80, 0xee, 0x1c, 0xb8, 0x8a, 0x7f, 0x72, 0x06, 0xf3, 0xfa, 0x84, 0x0b, 0x19, 0x50, + 0x77, 0x61, 0xfb, 0x23, ], Core::And32 => [ - 0x75, 0x3e, 0x33, 0x2d, 0xdf, 0xa0, 0x96, 0xf0, 0x83, 0x99, 0xff, 0xaa, 0x7e, 0xc4, - 0xda, 0x40, 0x35, 0xbc, 0xba, 0xa1, 0x42, 0xe6, 0xe3, 0x8d, 0x4c, 0xb6, 0x07, 0xce, - 0x1f, 0x0b, 0x05, 0x1d, + 0x13, 0xb0, 0x2c, 0x4c, 0x60, 0xae, 0x6e, 0xa4, 0x91, 0x16, 0x16, 0x49, 0xac, 0xf9, + 0xa4, 0x7a, 0x70, 0x25, 0xaf, 0x84, 0x7d, 0x5f, 0x58, 0x1e, 0x6f, 0x1c, 0xcc, 0xfb, + 0x21, 0xd3, 0x00, 0x1d, ], Core::And64 => [ - 0xf1, 0xad, 0x5e, 0x6c, 0x63, 0xee, 0x5c, 0x89, 0x0b, 0x0f, 0x2e, 0x71, 0x15, 0x61, - 0xb9, 0x05, 0x31, 0x64, 0x87, 0xac, 0x40, 0x44, 0xdd, 0x23, 0x0c, 0xf6, 0xa7, 0x36, - 0xf8, 0x1b, 0xd4, 0xf3, + 0x92, 0x18, 0x55, 0x35, 0xd4, 0x50, 0x54, 0x07, 0xde, 0xa3, 0xc8, 0xa6, 0x08, 0x26, + 0xed, 0xe6, 0x4a, 0x8f, 0xbb, 0x3d, 0xb4, 0x86, 0xd5, 0x6f, 0x64, 0x2d, 0x21, 0x7c, + 0x29, 0xcb, 0xd7, 0x95, ], Core::And8 => [ - 0xac, 0x82, 0x8b, 0x72, 0x4c, 0x5f, 0x53, 0x40, 0xb5, 0x1e, 0x76, 0xe7, 0xb6, 0xe8, - 0xb2, 0x3a, 0xea, 0xb7, 0x53, 0x3f, 0xd8, 0xc0, 0x91, 0xae, 0x2a, 0x51, 0x55, 0x30, - 0xae, 0x7a, 0xb2, 0x00, + 0x26, 0x9a, 0x1b, 0x44, 0x62, 0x66, 0xf8, 0xf4, 0xa4, 0xa3, 0x8f, 0xa7, 0xe7, 0xe3, + 0x91, 0x82, 0xf1, 0x52, 0x14, 0x36, 0x14, 0x2b, 0xad, 0xed, 0xf3, 0xaa, 0x63, 0xfb, + 0x2f, 0x17, 0x2d, 0x2f, ], Core::Bip0340Verify => [ - 0xc9, 0xc4, 0x5a, 0x8a, 0xec, 0x86, 0x59, 0x14, 0x3b, 0xfe, 0x2a, 0xf6, 0xea, 0xd4, - 0x8d, 0x4e, 0x05, 0x42, 0x45, 0x3a, 0xca, 0xe8, 0x4b, 0x9b, 0xbb, 0x97, 0x65, 0x6b, - 0x67, 0x0b, 0xdf, 0xdd, + 0x49, 0x15, 0x65, 0xfe, 0x23, 0xa7, 0xbd, 0xc1, 0x84, 0x2b, 0xe7, 0x49, 0x50, 0x93, + 0x37, 0xf9, 0x68, 0x90, 0xd5, 0xb3, 0x58, 0xb3, 0x65, 0x20, 0x90, 0xda, 0x55, 0x66, + 0x54, 0xe2, 0x95, 0x49, ], Core::Ch1 => [ - 0xb8, 0x41, 0xb8, 0x57, 0xa4, 0xaa, 0x50, 0xea, 0xca, 0x27, 0xa2, 0x6f, 0x74, 0x42, - 0xfc, 0xbf, 0xe9, 0x54, 0x67, 0x7a, 0xe6, 0xd4, 0x55, 0xf6, 0x05, 0x65, 0x49, 0x89, - 0xe3, 0x5a, 0xeb, 0x13, + 0x73, 0xb2, 0xa9, 0x81, 0xd7, 0x21, 0x98, 0x6f, 0x8c, 0xde, 0xd6, 0x97, 0xe0, 0x63, + 0x05, 0xd4, 0x58, 0x54, 0x10, 0x2d, 0xff, 0x20, 0xc0, 0xe5, 0xb9, 0x8a, 0xe1, 0x76, + 0x23, 0x2f, 0xf2, 0x5b, ], Core::Ch16 => [ - 0x9c, 0xff, 0x11, 0xa0, 0x9b, 0x60, 0x41, 0xe5, 0xf2, 0x63, 0x9a, 0xe4, 0xc0, 0x65, - 0xa1, 0x8f, 0xc6, 0x75, 0xdb, 0x2f, 0xbd, 0x98, 0x54, 0x08, 0xe2, 0x8f, 0x02, 0x7a, - 0x99, 0x11, 0x0e, 0x11, + 0x78, 0xde, 0x46, 0x5e, 0x61, 0xd9, 0xa5, 0x0f, 0x78, 0x25, 0x2f, 0xf4, 0xab, 0x23, + 0xc9, 0xe6, 0x3a, 0xe6, 0x8c, 0x76, 0x9d, 0x36, 0x66, 0x12, 0x71, 0x20, 0x7d, 0xc6, + 0x93, 0xf4, 0x69, 0xb4, ], Core::Ch32 => [ - 0x07, 0x1c, 0xef, 0x80, 0x39, 0xc7, 0x9f, 0x71, 0x31, 0xcd, 0x6a, 0x5f, 0xe4, 0x93, - 0xdc, 0x26, 0x8f, 0x9d, 0xb5, 0x8f, 0x7b, 0x20, 0xa8, 0x55, 0x55, 0xe2, 0x97, 0xbd, - 0xd2, 0x16, 0xcf, 0x40, + 0xed, 0x93, 0xbe, 0xf1, 0xf6, 0x6e, 0x3a, 0x75, 0xe6, 0x12, 0x06, 0x02, 0xec, 0xee, + 0x67, 0x40, 0x65, 0x3e, 0x7b, 0xd4, 0x6e, 0x07, 0xeb, 0x77, 0x14, 0x4e, 0xf1, 0xbb, + 0x2c, 0x9d, 0xe5, 0x3d, ], Core::Ch64 => [ - 0xd5, 0x55, 0xd2, 0x19, 0x63, 0xb0, 0x19, 0x2f, 0xc9, 0x72, 0x14, 0xb6, 0x3d, 0xc1, - 0xc3, 0xaf, 0x75, 0x8b, 0x29, 0x11, 0x58, 0xf0, 0xe1, 0xa3, 0xbc, 0xfd, 0xea, 0x67, - 0x9c, 0x66, 0x6d, 0xa6, + 0xce, 0xd0, 0x07, 0x9b, 0x0b, 0xd1, 0xcc, 0x00, 0x20, 0x9a, 0x7c, 0xbc, 0x23, 0xf1, + 0x3d, 0xfd, 0x20, 0x28, 0x08, 0xf0, 0xf5, 0x25, 0x7d, 0x8a, 0x50, 0xac, 0x54, 0x3e, + 0x64, 0xee, 0x3a, 0x05, ], Core::Ch8 => [ - 0x35, 0x3f, 0x63, 0xb0, 0xf8, 0xcb, 0x54, 0xf5, 0xae, 0x65, 0x75, 0xaf, 0x8c, 0xa2, - 0x24, 0x2c, 0xee, 0xe9, 0xf2, 0x7a, 0x84, 0x18, 0x6e, 0xb8, 0x0e, 0x62, 0x0d, 0x5e, - 0x2e, 0x85, 0x48, 0xec, + 0xc7, 0x07, 0xca, 0x72, 0x3e, 0x24, 0xf6, 0xb2, 0x5b, 0xf3, 0x94, 0xa9, 0x9a, 0x4d, + 0x75, 0xe8, 0x13, 0x79, 0xb4, 0x67, 0x84, 0x38, 0xac, 0x78, 0x9d, 0xee, 0x18, 0x8e, + 0xdc, 0xce, 0x75, 0xfa, ], Core::CheckSigVerify => [ 0xb5, 0x80, 0x15, 0x54, 0x6d, 0x28, 0x52, 0x66, 0x5d, 0xd2, 0x1b, 0xf1, 0x12, 0x66, @@ -870,429 +877,429 @@ impl Jet for Core { 0x25, 0x95, 0x2e, 0x68, ], Core::Complement1 => [ - 0xed, 0x74, 0xee, 0xb8, 0x3a, 0x00, 0xc7, 0x13, 0xcc, 0x14, 0xf3, 0x3e, 0xfe, 0x55, - 0x33, 0x83, 0xcd, 0x04, 0x11, 0xcc, 0x30, 0x20, 0xfd, 0x89, 0x27, 0x93, 0x16, 0x67, - 0x5d, 0x91, 0x0e, 0x66, + 0x1b, 0xcf, 0xae, 0x13, 0xd5, 0xd2, 0x37, 0xa0, 0xbb, 0x9b, 0x1d, 0x75, 0x32, 0x04, + 0x74, 0x62, 0xb2, 0x76, 0x90, 0xde, 0x5c, 0xac, 0x0e, 0x20, 0x19, 0x29, 0x89, 0x64, + 0x57, 0x93, 0x40, 0x60, ], Core::Complement16 => [ - 0x61, 0xfd, 0xd9, 0x04, 0xa4, 0xae, 0xb7, 0xeb, 0x76, 0x84, 0xaf, 0x61, 0x8e, 0x25, - 0xaa, 0xe9, 0x07, 0xcd, 0x1d, 0xb0, 0xf6, 0x2d, 0x97, 0x03, 0xc5, 0xb8, 0x54, 0xe1, - 0x66, 0x3c, 0xac, 0x9f, + 0x81, 0xad, 0x4d, 0x2c, 0x3d, 0x16, 0xbf, 0x34, 0x0a, 0xf3, 0x88, 0x6d, 0x35, 0x5c, + 0xc5, 0xbd, 0x1d, 0x59, 0x67, 0xe1, 0x6a, 0xce, 0x92, 0x4f, 0x19, 0xec, 0xf7, 0xd4, + 0x86, 0xd6, 0xc7, 0xe9, ], Core::Complement32 => [ - 0xfe, 0xb0, 0x2c, 0xc3, 0x6e, 0x19, 0x5b, 0x46, 0x2a, 0xe5, 0x04, 0xa9, 0x12, 0xda, - 0xdf, 0xe6, 0x6a, 0xd4, 0x7f, 0x23, 0xa0, 0xcb, 0x3b, 0xae, 0xa2, 0x1d, 0x31, 0xaa, - 0xa0, 0xce, 0x10, 0x1d, + 0x13, 0x74, 0x2c, 0x18, 0x04, 0xa9, 0x6e, 0x6c, 0x03, 0x95, 0x28, 0xbf, 0xd0, 0x3b, + 0x8c, 0xf2, 0xb4, 0x62, 0x52, 0x6b, 0xb1, 0x81, 0xa3, 0xd8, 0xb4, 0x32, 0xf9, 0x9a, + 0xc4, 0xf5, 0xa7, 0xef, ], Core::Complement64 => [ - 0x45, 0x07, 0x2d, 0x5a, 0xa0, 0xe5, 0xc3, 0x7c, 0x9e, 0x52, 0x1d, 0xcc, 0x92, 0xe8, - 0xf3, 0x9a, 0x5f, 0x75, 0xe7, 0xd9, 0x28, 0x67, 0x0a, 0xca, 0xb7, 0x9c, 0xd8, 0xc8, - 0xb5, 0xb5, 0x9e, 0x1a, + 0x65, 0xb7, 0xbd, 0x09, 0x36, 0x39, 0xc5, 0x6d, 0xa2, 0x85, 0xce, 0xfa, 0x2d, 0x04, + 0x64, 0x64, 0x5e, 0x14, 0xdd, 0x13, 0x64, 0x2f, 0x34, 0x95, 0x7d, 0x47, 0x37, 0xbd, + 0x52, 0xfa, 0xc5, 0x88, ], Core::Complement8 => [ - 0x69, 0x16, 0xb2, 0x8f, 0xb5, 0x74, 0xd9, 0xc9, 0x08, 0xa3, 0xf3, 0x3f, 0x74, 0xbf, - 0x06, 0xf7, 0xed, 0x93, 0x72, 0x54, 0x24, 0x7f, 0x9e, 0xfc, 0x26, 0x03, 0xd7, 0x17, - 0x1d, 0xd4, 0x97, 0xbe, + 0x95, 0x4b, 0x70, 0xdc, 0xec, 0x53, 0x9e, 0x6b, 0x67, 0xdf, 0xfe, 0xc5, 0x3c, 0xf2, + 0x4a, 0x66, 0x99, 0x39, 0x60, 0x8b, 0x22, 0x3f, 0x5f, 0x8b, 0x6d, 0x12, 0x9d, 0xaa, + 0x48, 0xca, 0x1c, 0xf0, ], Core::Decompress => [ - 0x13, 0x97, 0x33, 0x17, 0xd5, 0x87, 0x41, 0x8e, 0xf3, 0x06, 0x36, 0x31, 0xa6, 0xed, - 0xb0, 0xac, 0xfa, 0x1c, 0xbe, 0x49, 0x83, 0xd7, 0x57, 0x4b, 0x1b, 0x30, 0x5f, 0x96, - 0x61, 0xc0, 0x48, 0xcb, + 0x89, 0x00, 0x56, 0xdf, 0x82, 0x8a, 0x76, 0x6e, 0xe9, 0xf6, 0x56, 0x07, 0x22, 0x1e, + 0x89, 0x46, 0xfa, 0x77, 0xc2, 0x56, 0xbb, 0x96, 0xe2, 0x31, 0xe1, 0x94, 0xd3, 0x00, + 0x8c, 0xf3, 0x56, 0xf6, ], Core::Decrement16 => [ - 0xe3, 0x4d, 0xb1, 0x18, 0x79, 0x27, 0x2b, 0x32, 0x7a, 0x3b, 0xd0, 0x34, 0xc0, 0xf6, - 0x1e, 0xf6, 0x0a, 0x2b, 0xe9, 0x6f, 0xdf, 0xe0, 0xb2, 0xd5, 0x7f, 0xfe, 0x39, 0xce, - 0x71, 0x4c, 0x78, 0xfb, + 0x35, 0xfd, 0xa3, 0x8b, 0x67, 0x2c, 0x38, 0x31, 0xd8, 0xca, 0x11, 0xa4, 0xf3, 0xa9, + 0x59, 0x62, 0x22, 0x52, 0x9e, 0xb1, 0xc1, 0x5f, 0x8c, 0x70, 0x50, 0x13, 0x97, 0x7d, + 0x7d, 0xfb, 0x5d, 0x8b, ], Core::Decrement32 => [ - 0x01, 0x9e, 0xad, 0x5a, 0x73, 0x05, 0x60, 0x6d, 0xc9, 0x50, 0xfb, 0x55, 0x47, 0x6d, - 0x09, 0xc1, 0x7d, 0x66, 0xf5, 0x70, 0xda, 0xb5, 0x10, 0xb9, 0x0d, 0x2a, 0x27, 0xe2, - 0x26, 0x65, 0x99, 0xcf, + 0x3b, 0x2b, 0x19, 0x39, 0x55, 0x22, 0x84, 0xf6, 0x14, 0x69, 0x4b, 0xa1, 0x8d, 0xce, + 0x70, 0xce, 0xe4, 0x76, 0xff, 0x42, 0xdc, 0xd0, 0x89, 0xe1, 0xa3, 0xc0, 0xa4, 0x2b, + 0xeb, 0xd1, 0x08, 0xf6, ], Core::Decrement64 => [ - 0x34, 0x75, 0x2c, 0xf4, 0xe1, 0xd0, 0xa4, 0x31, 0xf0, 0x17, 0xa6, 0x8b, 0xeb, 0xfa, - 0xb7, 0x41, 0xbb, 0xc8, 0x8a, 0xff, 0xb5, 0x7c, 0xc0, 0xb3, 0x02, 0x5c, 0xcf, 0xdd, - 0x67, 0x62, 0x2f, 0x35, + 0x7e, 0xf7, 0xbd, 0xd3, 0x5d, 0xb6, 0x85, 0xae, 0x99, 0x05, 0x53, 0x37, 0x35, 0xa2, + 0xc7, 0xa7, 0xcc, 0xbc, 0x17, 0x08, 0xae, 0x63, 0x6f, 0x93, 0x1b, 0x5c, 0xe0, 0x26, + 0xe5, 0xa1, 0x7f, 0xed, ], Core::Decrement8 => [ - 0x28, 0x92, 0xce, 0xb3, 0xb6, 0xec, 0x53, 0x25, 0xd0, 0xc1, 0xb9, 0xf5, 0x20, 0x42, - 0x5e, 0x4b, 0x05, 0xc2, 0xe1, 0xf4, 0x37, 0xe0, 0xb3, 0xf5, 0x81, 0xf4, 0x1b, 0x9d, - 0x0f, 0x7d, 0xff, 0x4d, + 0xe3, 0x64, 0xf2, 0xe5, 0xc0, 0x8a, 0xe0, 0x11, 0x8e, 0xbe, 0x99, 0x3e, 0x8b, 0x3c, + 0x95, 0x8c, 0x2b, 0xcc, 0x60, 0x62, 0xa3, 0x3b, 0xaa, 0xb9, 0x28, 0xc0, 0x4b, 0x3e, + 0xc9, 0x32, 0xf5, 0x1b, ], Core::DivMod128_64 => [ - 0x22, 0x96, 0xb7, 0x0f, 0x60, 0x0e, 0x8a, 0x21, 0x4a, 0xd0, 0x70, 0xb2, 0x19, 0x4a, - 0x67, 0x7d, 0x30, 0x51, 0xbc, 0x1c, 0x49, 0x01, 0x83, 0x97, 0x5f, 0x2a, 0x1d, 0x3e, - 0x0c, 0xad, 0xe3, 0x78, + 0x9a, 0x94, 0x43, 0xa2, 0xb5, 0x41, 0xe2, 0x9f, 0x27, 0x2f, 0xfd, 0x56, 0x7d, 0x1b, + 0xf7, 0x42, 0xd6, 0x8c, 0xcb, 0xe9, 0x53, 0x8a, 0x87, 0x29, 0x1b, 0x0c, 0xa6, 0x38, + 0x15, 0x63, 0xac, 0x2c, ], Core::DivMod16 => [ - 0x64, 0x8f, 0xab, 0x86, 0x43, 0x74, 0x84, 0x6a, 0xbf, 0x4f, 0x9d, 0x9d, 0xef, 0xe2, - 0x75, 0x61, 0x4d, 0x33, 0xf4, 0x82, 0x9c, 0x36, 0xa4, 0x7e, 0xcb, 0x53, 0xd7, 0xbf, - 0xb6, 0x05, 0x48, 0x5f, + 0x39, 0xbc, 0xb5, 0xc0, 0x1d, 0xc1, 0x80, 0x5c, 0x49, 0x19, 0x89, 0x5c, 0xb5, 0x9e, + 0x8f, 0x3b, 0x41, 0x44, 0x67, 0x17, 0xf7, 0xff, 0x48, 0xfd, 0xc9, 0x37, 0xdd, 0x03, + 0x80, 0x24, 0xa0, 0x8a, ], Core::DivMod32 => [ - 0xbd, 0x3d, 0x4d, 0x55, 0x2d, 0x7b, 0x34, 0x7b, 0xd8, 0xa4, 0x4e, 0x3e, 0xe2, 0x24, - 0xc8, 0x46, 0xbe, 0x23, 0x0f, 0xf6, 0xe2, 0x04, 0x4d, 0xdb, 0x97, 0xf4, 0x8e, 0x27, - 0xd2, 0x0c, 0x42, 0x25, + 0xfb, 0x12, 0x02, 0xf4, 0xe8, 0x66, 0x3a, 0x87, 0xf5, 0x68, 0x99, 0x2a, 0x18, 0x50, + 0x24, 0xc7, 0x0b, 0x4f, 0x07, 0x9f, 0xbe, 0x95, 0x30, 0x01, 0x0f, 0x6d, 0xb2, 0x84, + 0x21, 0x8a, 0xf6, 0xcd, ], Core::DivMod64 => [ - 0xfa, 0x6b, 0xad, 0x6a, 0x95, 0xe2, 0xab, 0xa4, 0x30, 0x5b, 0xfe, 0x91, 0xcc, 0x47, - 0xac, 0xc3, 0xd9, 0x9b, 0x92, 0xe6, 0x75, 0xe6, 0x9d, 0x3b, 0x37, 0xbb, 0x09, 0x13, - 0x3d, 0x39, 0x0d, 0x0f, + 0x67, 0x64, 0xdf, 0x5e, 0x2a, 0xa0, 0x30, 0x32, 0x6e, 0xe5, 0x44, 0xc6, 0xe5, 0x3f, + 0xf3, 0x8e, 0xf0, 0xb2, 0x85, 0x17, 0x91, 0x5e, 0xec, 0x65, 0xc7, 0x2e, 0xa5, 0x7a, + 0x12, 0x98, 0x28, 0xeb, ], Core::DivMod8 => [ - 0x48, 0xcd, 0x50, 0x1b, 0xb2, 0xaa, 0x2a, 0xca, 0xe0, 0x14, 0xfe, 0x20, 0x8b, 0xb9, - 0x94, 0x1d, 0x07, 0xa9, 0xbf, 0xfe, 0x1a, 0xd6, 0xcd, 0x3d, 0x36, 0xfc, 0x6b, 0x08, - 0x60, 0xf6, 0xeb, 0xa7, + 0xd3, 0x00, 0x24, 0x4e, 0x48, 0x0d, 0xd9, 0x74, 0x12, 0x13, 0xe4, 0xcb, 0x0e, 0xba, + 0x83, 0x6d, 0x30, 0x59, 0xe7, 0x78, 0xb8, 0x12, 0x2f, 0x78, 0x90, 0x03, 0x26, 0x73, + 0x73, 0x9c, 0x6a, 0x2c, ], Core::Divide16 => [ - 0x47, 0x0b, 0x01, 0xa5, 0x7c, 0x4f, 0x9d, 0x8f, 0x99, 0x7f, 0xcd, 0xe0, 0x06, 0x19, - 0x16, 0x11, 0xdd, 0xa4, 0xc9, 0x8b, 0xa2, 0xa5, 0xf1, 0xda, 0x13, 0x4a, 0xe4, 0xc2, - 0x2d, 0x52, 0xe9, 0x20, + 0x52, 0xab, 0xfe, 0xf1, 0x79, 0x75, 0x4c, 0x90, 0xf9, 0xa4, 0x26, 0x0f, 0x32, 0x3a, + 0x8c, 0xa4, 0x95, 0x15, 0x92, 0x90, 0x2b, 0x8e, 0xcb, 0xd6, 0x4b, 0xa4, 0x26, 0x56, + 0xfa, 0xc0, 0x59, 0x68, ], Core::Divide32 => [ - 0xab, 0x03, 0xac, 0xd8, 0x93, 0x61, 0x0c, 0x3c, 0x65, 0x82, 0xe7, 0xf7, 0xfb, 0xe5, - 0xe7, 0x56, 0x25, 0x74, 0xa7, 0xb2, 0x66, 0x46, 0xf1, 0xc2, 0xfd, 0xc6, 0xe7, 0x6e, - 0x44, 0x5a, 0x77, 0xa1, + 0x4a, 0x8a, 0xe5, 0x35, 0x44, 0xe1, 0x47, 0xed, 0x02, 0x25, 0x04, 0x23, 0x79, 0x34, + 0xcc, 0x25, 0x44, 0x79, 0xbc, 0xf9, 0x3d, 0xe1, 0xe1, 0x97, 0x4d, 0xda, 0xb3, 0xbb, + 0x51, 0x6e, 0x60, 0x6c, ], Core::Divide64 => [ - 0xeb, 0xfc, 0x56, 0xfb, 0xb8, 0xa4, 0x7e, 0x73, 0xff, 0xab, 0xb7, 0xea, 0x22, 0x8a, - 0xc7, 0x84, 0x37, 0xbe, 0x82, 0x0e, 0xdd, 0xfa, 0x47, 0x81, 0x4c, 0xce, 0xbd, 0x26, - 0x1b, 0xd8, 0xcf, 0xff, + 0xd7, 0x02, 0x5d, 0x05, 0xad, 0xfa, 0xe6, 0x6b, 0x47, 0x10, 0xd0, 0xff, 0x1e, 0x87, + 0xe8, 0x28, 0x15, 0x57, 0x3e, 0x9c, 0xb6, 0x31, 0xb4, 0xc7, 0xd1, 0x3d, 0x2f, 0x1b, + 0xe4, 0xdd, 0x26, 0xd2, ], Core::Divide8 => [ - 0x2c, 0xcf, 0xbc, 0x7c, 0x02, 0xbf, 0x4d, 0x53, 0x04, 0x93, 0xbb, 0x22, 0x86, 0x7a, - 0x95, 0x1d, 0x8a, 0xe9, 0x13, 0x12, 0x66, 0x87, 0x59, 0x72, 0x84, 0xe9, 0xbb, 0xb3, - 0xe1, 0xe7, 0xe3, 0x49, + 0x40, 0xcd, 0x1d, 0xac, 0xea, 0x24, 0x66, 0x9b, 0x6a, 0x58, 0x9b, 0x61, 0x47, 0x54, + 0x74, 0xaf, 0x31, 0xd1, 0x4f, 0x8d, 0x46, 0x87, 0x70, 0x84, 0x52, 0xd3, 0xdf, 0x37, + 0x30, 0x25, 0x31, 0x26, ], Core::Divides16 => [ - 0x5f, 0xc3, 0xac, 0x38, 0x4d, 0x5f, 0x45, 0x40, 0x41, 0x56, 0x97, 0x1a, 0x76, 0x8d, - 0x93, 0xbc, 0x06, 0x4b, 0xc1, 0x7c, 0x15, 0xa3, 0x7c, 0x27, 0x01, 0x9d, 0xde, 0xef, - 0x17, 0x04, 0x6d, 0xd4, + 0x10, 0xbb, 0x18, 0x18, 0x0e, 0xab, 0x5b, 0xad, 0xdc, 0x16, 0x5d, 0x03, 0x37, 0xc4, + 0xad, 0xa0, 0x88, 0xe1, 0x57, 0xb1, 0xaa, 0x67, 0x83, 0x34, 0x2a, 0x45, 0x20, 0xa3, + 0x24, 0xdd, 0x9d, 0x2b, ], Core::Divides32 => [ - 0xcc, 0x45, 0xb4, 0x05, 0x24, 0x64, 0x38, 0xf7, 0x65, 0x74, 0x0b, 0x4f, 0xb0, 0xa3, - 0x4d, 0xc8, 0x1b, 0x34, 0x78, 0x01, 0x98, 0x86, 0x3b, 0x0f, 0xb1, 0x86, 0x44, 0x6a, - 0xdf, 0xbb, 0x09, 0xde, + 0xf5, 0xe8, 0xe7, 0x8c, 0x82, 0x76, 0x9a, 0x48, 0xc9, 0x10, 0x3e, 0x44, 0xdd, 0xb4, + 0x7f, 0x84, 0x1d, 0x76, 0x93, 0xb0, 0x41, 0x9e, 0x5e, 0x7d, 0xa4, 0xe6, 0x8b, 0x78, + 0xb2, 0x37, 0xa5, 0x72, ], Core::Divides64 => [ - 0xdc, 0x47, 0x3b, 0xfd, 0xec, 0x30, 0xab, 0x98, 0xd4, 0x8c, 0xd0, 0x88, 0x84, 0xef, - 0x4f, 0xff, 0xef, 0x3d, 0x4b, 0x16, 0xad, 0x5c, 0x37, 0x11, 0x2a, 0x20, 0x35, 0xb9, - 0x9b, 0xb7, 0x74, 0x58, + 0x9e, 0xbd, 0x55, 0xfa, 0xe4, 0x18, 0x88, 0x5e, 0xea, 0x04, 0xc3, 0xcd, 0xff, 0xf5, + 0x31, 0xb7, 0xd7, 0x14, 0xd0, 0x59, 0x4f, 0xa7, 0xda, 0x87, 0xeb, 0x65, 0x55, 0xd3, + 0x6b, 0x95, 0x3d, 0xb2, ], Core::Divides8 => [ - 0x0b, 0x55, 0x02, 0xac, 0x4f, 0x21, 0xf2, 0x30, 0xa0, 0x9c, 0xcf, 0xaf, 0xfa, 0xac, - 0x77, 0xa7, 0xc4, 0x1b, 0x2b, 0xf3, 0x0b, 0x14, 0x68, 0x48, 0x1e, 0x4d, 0xfb, 0x98, - 0xb6, 0x18, 0x7a, 0x0d, + 0xa2, 0x36, 0xbc, 0x3e, 0x5c, 0xf4, 0xd2, 0x56, 0x40, 0x8b, 0xa3, 0x8c, 0x1e, 0xae, + 0xe7, 0x36, 0x9a, 0x9c, 0x40, 0x2f, 0x74, 0xbc, 0xd1, 0xc8, 0x02, 0xf9, 0x09, 0x4f, + 0xbf, 0x36, 0x80, 0x3d, ], Core::Eq1 => [ - 0x60, 0x7f, 0x6b, 0x8f, 0x5d, 0x25, 0xb8, 0x0e, 0x05, 0xa2, 0xbf, 0x79, 0xd6, 0x2e, - 0x87, 0x07, 0x99, 0x52, 0x2c, 0xc3, 0xe3, 0x9c, 0xe9, 0x62, 0x57, 0x45, 0x52, 0x93, - 0xf9, 0xb2, 0xb2, 0xed, + 0x65, 0x49, 0xf9, 0x86, 0x20, 0x3a, 0x64, 0x97, 0x35, 0x6e, 0x43, 0x2b, 0x2a, 0xa1, + 0x60, 0xd6, 0xee, 0x87, 0x0b, 0x11, 0x19, 0x08, 0x65, 0xbd, 0x36, 0xa4, 0x7c, 0xb0, + 0x47, 0x04, 0x33, 0xa5, ], Core::Eq16 => [ - 0xc9, 0x96, 0xe4, 0x2b, 0x97, 0x9a, 0xbc, 0x53, 0x0c, 0xc2, 0x71, 0x63, 0x66, 0x71, - 0xe9, 0x20, 0x54, 0x87, 0x6a, 0x1e, 0xca, 0xed, 0x14, 0x33, 0xfd, 0x61, 0x9a, 0x25, - 0xfe, 0x6d, 0x03, 0xad, + 0x0c, 0x54, 0x02, 0xb0, 0xad, 0xc8, 0xfc, 0x65, 0x70, 0x1b, 0xb7, 0x5b, 0x32, 0x54, + 0xc8, 0x35, 0xf8, 0xfe, 0xc1, 0x30, 0x81, 0xcd, 0x35, 0xe1, 0x32, 0x8f, 0x2b, 0xd7, + 0xdb, 0xd2, 0x3f, 0xa6, ], Core::Eq256 => [ - 0x77, 0x8d, 0x15, 0x06, 0xc7, 0x35, 0xd2, 0x77, 0x6b, 0x95, 0x0f, 0xac, 0xef, 0xc1, - 0x59, 0xb6, 0x78, 0xde, 0xc0, 0x38, 0x28, 0xcf, 0x02, 0x73, 0xee, 0xea, 0x64, 0xa9, - 0xda, 0x98, 0xc1, 0x2c, + 0x26, 0x0e, 0x1d, 0x13, 0x6d, 0xd7, 0x44, 0xfc, 0xb0, 0x50, 0x7a, 0x2d, 0x27, 0x70, + 0x27, 0xa7, 0x72, 0x43, 0x54, 0xeb, 0x17, 0x6b, 0x2f, 0xbf, 0x31, 0xc6, 0xc7, 0xd7, + 0xfb, 0x3e, 0xcd, 0x6f, ], Core::Eq32 => [ - 0x66, 0xd3, 0x89, 0x03, 0xe7, 0x3b, 0x1a, 0x13, 0x20, 0xc6, 0x8a, 0x4a, 0x39, 0x70, - 0xd7, 0x1f, 0x94, 0xba, 0x9e, 0x2b, 0x15, 0x16, 0x83, 0x99, 0x43, 0xfb, 0x15, 0xe4, - 0x4e, 0xbf, 0x57, 0xfb, + 0xf5, 0xd6, 0xed, 0xc8, 0xb6, 0x16, 0x4e, 0x12, 0x5b, 0xbb, 0xef, 0x08, 0xc9, 0xe0, + 0x8a, 0x1e, 0x6f, 0xd4, 0x92, 0xf5, 0xbd, 0xca, 0x6f, 0xdc, 0x8b, 0x5f, 0x5a, 0x6f, + 0x05, 0xc5, 0xab, 0x96, ], Core::Eq64 => [ - 0xd6, 0xa6, 0x66, 0xb4, 0xe0, 0xf9, 0xf5, 0x75, 0x50, 0x8d, 0xbf, 0x3b, 0x31, 0xce, - 0xea, 0x68, 0x39, 0x3c, 0x7d, 0xb2, 0xe9, 0x8b, 0xc5, 0x92, 0xfd, 0xd2, 0x6f, 0xae, - 0x83, 0x7a, 0x0b, 0x87, + 0x1f, 0x93, 0xac, 0xb8, 0x09, 0x2f, 0xa0, 0x6d, 0xea, 0xf3, 0xc3, 0x87, 0xf5, 0x4a, + 0x18, 0xff, 0xea, 0xa6, 0x9a, 0x47, 0xa6, 0xf5, 0xca, 0xf4, 0xae, 0x49, 0x7e, 0x5c, + 0xc2, 0xb3, 0x6c, 0x43, ], Core::Eq8 => [ - 0x99, 0x78, 0x7b, 0xa2, 0x67, 0x2d, 0xd0, 0xeb, 0x4d, 0x7d, 0x2e, 0xa9, 0x94, 0x49, - 0xde, 0x8f, 0x79, 0x8e, 0x7c, 0xb1, 0x81, 0xa5, 0xe1, 0x66, 0xe1, 0xa5, 0x3f, 0x98, - 0x02, 0xb6, 0x20, 0x64, + 0xd7, 0x52, 0xfa, 0x7f, 0x51, 0x47, 0x30, 0x14, 0xeb, 0xb6, 0x9e, 0x1e, 0x1d, 0x2c, + 0x86, 0xd5, 0x11, 0x48, 0xb6, 0xba, 0xa0, 0x21, 0x37, 0xa4, 0x8f, 0x62, 0xd5, 0x7e, + 0xaf, 0x8d, 0xf1, 0xcd, ], Core::FeAdd => [ - 0xb0, 0x59, 0x3e, 0x18, 0x7e, 0xe7, 0x33, 0x3c, 0x47, 0xa0, 0x54, 0x67, 0xdf, 0x66, - 0xd5, 0x82, 0x0a, 0x6f, 0x5b, 0xef, 0x91, 0x4a, 0x4b, 0x76, 0xe5, 0xd1, 0x63, 0x31, - 0x4b, 0x5e, 0xf2, 0x0e, + 0xa6, 0xc9, 0x0e, 0x02, 0xfd, 0xe4, 0xee, 0x6e, 0xef, 0x66, 0x67, 0x37, 0x49, 0x2e, + 0x14, 0xaf, 0xc8, 0x76, 0x25, 0x04, 0x97, 0x4a, 0xf5, 0xd5, 0x47, 0x2b, 0xb9, 0x43, + 0x3a, 0xd2, 0xd2, 0x94, ], Core::FeInvert => [ - 0x34, 0x3e, 0x9c, 0x90, 0xf1, 0x28, 0x50, 0x60, 0x56, 0xb5, 0x48, 0xd2, 0xed, 0x5e, - 0x22, 0x3c, 0x81, 0xf5, 0xb0, 0x6a, 0x1e, 0xd8, 0x6b, 0x7c, 0xd9, 0x35, 0x40, 0x57, - 0xaa, 0x59, 0x51, 0x02, + 0x7c, 0x4a, 0xba, 0xce, 0x33, 0xc7, 0x2b, 0x3b, 0xe1, 0xfd, 0x0e, 0xe3, 0x9f, 0xc6, + 0xcb, 0x3e, 0xe5, 0xc8, 0xf1, 0x1e, 0xf2, 0x19, 0x98, 0xc0, 0x60, 0x2b, 0x52, 0x15, + 0xaa, 0x2a, 0x75, 0xc2, ], Core::FeIsOdd => [ - 0xdc, 0xf0, 0x37, 0x5d, 0x20, 0x81, 0x8a, 0x99, 0xf7, 0x23, 0xf8, 0x12, 0x3c, 0xbd, - 0x05, 0x1a, 0x38, 0x78, 0xa4, 0x28, 0x24, 0xb3, 0x74, 0x0f, 0x68, 0x21, 0xa5, 0xfa, - 0x12, 0x3f, 0x14, 0xc7, + 0x30, 0xf5, 0x17, 0x1f, 0x58, 0xf1, 0x08, 0x9d, 0x5d, 0xcf, 0xb6, 0xe6, 0x68, 0x3f, + 0x5a, 0xde, 0x98, 0x4c, 0x07, 0x99, 0x76, 0x3c, 0xa7, 0x38, 0x3f, 0x75, 0xdf, 0x1c, + 0xa0, 0x81, 0x3e, 0xfe, ], Core::FeIsZero => [ - 0x28, 0xff, 0x41, 0x69, 0x9a, 0x88, 0x1a, 0xaf, 0xb7, 0xa9, 0x76, 0xc0, 0xc5, 0x76, - 0x35, 0x3f, 0x7f, 0xe5, 0x44, 0x63, 0xb6, 0xaa, 0x75, 0x4c, 0xf2, 0xc6, 0x32, 0x9a, - 0xf2, 0x65, 0x0e, 0x3b, + 0xb0, 0xb7, 0x4d, 0x86, 0x51, 0xff, 0x55, 0x7c, 0xa9, 0x60, 0x44, 0xdd, 0x97, 0x28, + 0x13, 0x38, 0xa8, 0xf7, 0xd3, 0xac, 0xb3, 0x84, 0x7d, 0x03, 0xac, 0xbf, 0x3d, 0x32, + 0xd9, 0x6f, 0xae, 0x55, ], Core::FeMultiply => [ - 0x56, 0x69, 0x92, 0x9b, 0x5f, 0x31, 0xfa, 0x3d, 0x02, 0xc5, 0x83, 0x9d, 0xd0, 0x63, - 0x54, 0xcd, 0x17, 0x16, 0x35, 0xf3, 0xa0, 0x72, 0x7f, 0x32, 0x2a, 0xbf, 0xc9, 0x94, - 0xba, 0x62, 0x90, 0xde, + 0x50, 0x6b, 0x93, 0x19, 0xc1, 0x7a, 0x14, 0xa9, 0x46, 0x9d, 0x46, 0x27, 0x61, 0xa3, + 0x30, 0x3a, 0xb4, 0x7d, 0xdb, 0x3a, 0x30, 0x79, 0xfb, 0xa3, 0x40, 0x73, 0xaa, 0x55, + 0x42, 0x16, 0xa3, 0x88, ], Core::FeMultiplyBeta => [ - 0x7a, 0x78, 0x13, 0x45, 0x0d, 0x82, 0xe9, 0x35, 0x69, 0x0f, 0x43, 0x3e, 0x65, 0xdf, - 0x70, 0x7a, 0x4d, 0xd1, 0x75, 0x34, 0xa0, 0x0d, 0xdd, 0x40, 0xdd, 0x85, 0xe3, 0xe3, - 0xf7, 0x84, 0x02, 0xc3, + 0x6e, 0x18, 0x0e, 0xea, 0xbe, 0x84, 0x22, 0xb7, 0x99, 0x68, 0xe7, 0x11, 0xdd, 0x00, + 0xa4, 0xb6, 0x57, 0x8b, 0xb2, 0x75, 0xbe, 0xf4, 0x7f, 0xe5, 0xff, 0x96, 0x8f, 0x14, + 0x72, 0xd7, 0x6f, 0x2a, ], Core::FeNegate => [ - 0x3b, 0x0d, 0x7b, 0x5c, 0x2e, 0x6c, 0x3a, 0xeb, 0x5e, 0x00, 0x08, 0x5b, 0x9d, 0x30, - 0x58, 0x5a, 0xff, 0x05, 0x4e, 0x32, 0x5a, 0x99, 0x83, 0x61, 0x11, 0x3b, 0xfd, 0x23, - 0x28, 0xc0, 0x08, 0xf6, + 0xd4, 0x37, 0xea, 0x00, 0x33, 0x98, 0x80, 0xb3, 0x83, 0xd8, 0x5f, 0xb2, 0xae, 0xaf, + 0x20, 0x1b, 0xbe, 0x8f, 0xfc, 0x83, 0x70, 0x50, 0x62, 0xf9, 0xc9, 0x68, 0x59, 0x0d, + 0x5d, 0xb3, 0x37, 0xf6, ], Core::FeNormalize => [ - 0xc5, 0x1b, 0xef, 0xfa, 0x21, 0x5e, 0x9c, 0xde, 0x8e, 0x93, 0x3b, 0xb9, 0x46, 0x80, - 0xba, 0xe0, 0x12, 0xc4, 0xda, 0xab, 0x3d, 0x04, 0xb6, 0xcb, 0xf0, 0x73, 0x3f, 0xd7, - 0x35, 0x73, 0x35, 0x38, + 0xec, 0x0c, 0x3d, 0xd9, 0xc5, 0x28, 0x63, 0x64, 0x78, 0xbe, 0xc0, 0xe1, 0x60, 0xe5, + 0x0a, 0xd9, 0xbf, 0x45, 0x2c, 0x5b, 0x6f, 0x84, 0xe9, 0x40, 0xe1, 0x65, 0x84, 0xeb, + 0x08, 0x5a, 0xce, 0x38, ], Core::FeSquare => [ - 0x5a, 0x6e, 0x7b, 0x2e, 0xac, 0x73, 0xf4, 0xe4, 0x4d, 0xfa, 0x28, 0xfb, 0x86, 0xbb, - 0x11, 0x7b, 0x65, 0x60, 0x6f, 0x28, 0x74, 0xd5, 0x65, 0xc9, 0x79, 0x9c, 0x63, 0xe0, - 0xfe, 0x69, 0x2b, 0x1a, + 0xb9, 0x04, 0x77, 0x2d, 0x74, 0xa1, 0x85, 0xb8, 0x28, 0xeb, 0x15, 0x47, 0x28, 0xd2, + 0x49, 0xc5, 0x08, 0x47, 0x11, 0xe9, 0xa1, 0x83, 0x2b, 0x89, 0xca, 0xf2, 0xaf, 0x59, + 0xf9, 0x60, 0xe1, 0x18, ], Core::FeSquareRoot => [ - 0xe0, 0x01, 0x42, 0xea, 0x03, 0x09, 0x4a, 0x30, 0x4a, 0xc8, 0x2b, 0xc1, 0xe2, 0xd2, - 0xdc, 0x71, 0xfb, 0x06, 0x4e, 0xd0, 0x82, 0x85, 0x67, 0x35, 0xb1, 0x4f, 0xf2, 0xc7, - 0xfa, 0xf0, 0x36, 0xf0, + 0x16, 0xfb, 0x9a, 0xce, 0xbe, 0x8b, 0x5b, 0x87, 0xf2, 0xea, 0x7d, 0xb6, 0xaa, 0x3a, + 0x2a, 0xf8, 0x8c, 0xa2, 0xb5, 0x8f, 0x02, 0xcd, 0xc8, 0x7e, 0x7c, 0xe6, 0xbe, 0x0c, + 0x1f, 0xfc, 0xe0, 0x14, ], Core::FullAdd16 => [ - 0xfc, 0x9e, 0x5d, 0xf8, 0x3b, 0xfd, 0xb9, 0x02, 0x8c, 0x87, 0xd1, 0x39, 0xf8, 0x58, - 0x39, 0x03, 0xcb, 0x2a, 0x07, 0x04, 0x2a, 0x73, 0xe5, 0x34, 0x81, 0xde, 0xb5, 0x2f, - 0xf1, 0xf1, 0xf8, 0x84, + 0xc5, 0x03, 0xb0, 0x78, 0xdd, 0xe3, 0x99, 0xc6, 0x3a, 0xc4, 0xa2, 0x32, 0xbd, 0x2a, + 0x32, 0x9b, 0x04, 0x30, 0x8c, 0x75, 0xea, 0xec, 0x53, 0xa2, 0xf8, 0x89, 0xb8, 0xdf, + 0x0d, 0x03, 0x34, 0x72, ], Core::FullAdd32 => [ - 0xa7, 0xd9, 0x8d, 0x50, 0xd0, 0x45, 0xcb, 0x90, 0x6b, 0x19, 0x5e, 0x65, 0x11, 0x87, - 0x94, 0x95, 0xc8, 0x51, 0x09, 0x59, 0x49, 0xa9, 0xc0, 0x1e, 0x60, 0x39, 0xa8, 0x4b, - 0x2a, 0x5e, 0xc9, 0x09, + 0xa7, 0xaf, 0xd0, 0x40, 0xfc, 0xb0, 0xb2, 0xf2, 0x71, 0x90, 0x78, 0x1a, 0xe5, 0x3a, + 0x6c, 0xca, 0x00, 0xe9, 0xfe, 0x59, 0x53, 0x11, 0x15, 0xc2, 0x58, 0xcc, 0xb6, 0x9d, + 0x3b, 0xe5, 0xa2, 0x13, ], Core::FullAdd64 => [ - 0x7a, 0xec, 0xc8, 0xc9, 0x05, 0x3b, 0xb2, 0xfb, 0x17, 0x0c, 0x1c, 0x97, 0x2f, 0xd4, - 0x00, 0x25, 0x64, 0xe1, 0x52, 0xa0, 0x6d, 0x9f, 0x45, 0x80, 0x75, 0xe3, 0x8c, 0x7a, - 0x06, 0x98, 0xa7, 0xf4, + 0x80, 0xa3, 0xef, 0x6c, 0xdb, 0x84, 0xae, 0x7c, 0x8d, 0xbc, 0xf3, 0xa1, 0x84, 0x24, + 0x84, 0xc0, 0x98, 0xdf, 0x6f, 0x19, 0x42, 0x7a, 0x5a, 0x4a, 0xdf, 0xe7, 0x6c, 0xd5, + 0xff, 0x28, 0x36, 0xca, ], Core::FullAdd8 => [ - 0xed, 0x3b, 0xa5, 0xb7, 0x9e, 0xa4, 0x5b, 0x18, 0x7a, 0x2d, 0x43, 0xe8, 0xed, 0x80, - 0x2d, 0xe1, 0xed, 0x44, 0x26, 0x59, 0x6c, 0xbe, 0x32, 0xe7, 0x57, 0xc8, 0x51, 0x19, - 0x15, 0xff, 0xa5, 0xcf, + 0x4b, 0x90, 0x76, 0xb8, 0xc1, 0xad, 0x56, 0xc9, 0xdb, 0x6b, 0xb3, 0xba, 0xf5, 0x93, + 0x89, 0x54, 0x46, 0xce, 0x61, 0xc7, 0x4f, 0x79, 0x7e, 0xb8, 0xb2, 0x30, 0xd2, 0x05, + 0x42, 0x1c, 0x96, 0x17, ], Core::FullDecrement16 => [ - 0xd4, 0xc2, 0xed, 0xda, 0x87, 0x2c, 0x05, 0x50, 0x6f, 0x79, 0x2c, 0xf5, 0x46, 0xa8, - 0x9d, 0x4d, 0x7c, 0xff, 0xcb, 0x1e, 0x17, 0xf5, 0xda, 0x61, 0x03, 0x10, 0x0e, 0x7e, - 0x73, 0xa7, 0x73, 0x7d, + 0xfb, 0xa3, 0xc9, 0x78, 0x6e, 0xa3, 0x07, 0xf6, 0xd8, 0x54, 0x34, 0xfd, 0xa2, 0x56, + 0x24, 0x82, 0x43, 0xa0, 0x0b, 0xac, 0x9a, 0x53, 0x53, 0xb6, 0x1e, 0xd3, 0x9c, 0x60, + 0x55, 0xb6, 0x93, 0xb0, ], Core::FullDecrement32 => [ - 0x7c, 0xc2, 0x30, 0x4d, 0x17, 0x43, 0x12, 0x10, 0x2e, 0x9b, 0x73, 0x63, 0x45, 0xc7, - 0x7f, 0x77, 0x1d, 0x1f, 0x6a, 0x9c, 0x9e, 0x1d, 0x1c, 0xd8, 0xdb, 0x8c, 0xb4, 0x61, - 0x39, 0x80, 0xc8, 0xc2, + 0x62, 0x3d, 0x21, 0xd0, 0x46, 0x79, 0x22, 0xc0, 0x01, 0xc5, 0x65, 0x68, 0x61, 0xd0, + 0xdd, 0xb8, 0x60, 0xc0, 0xc9, 0xa8, 0x6b, 0xd4, 0xcf, 0xdc, 0x37, 0xa1, 0x4c, 0x14, + 0x06, 0xe3, 0x44, 0x6e, ], Core::FullDecrement64 => [ - 0x15, 0xc1, 0x63, 0x45, 0x4b, 0xcd, 0x75, 0x44, 0x30, 0xda, 0x55, 0x79, 0xbb, 0xca, - 0xad, 0x26, 0xe5, 0x7e, 0x95, 0xc7, 0x72, 0x22, 0x4b, 0x7b, 0x83, 0xc7, 0x05, 0xf7, - 0xde, 0xb6, 0x4a, 0xa6, + 0x14, 0x8b, 0x3e, 0xe1, 0xf7, 0x49, 0xea, 0x0b, 0xfb, 0xa7, 0x63, 0xbe, 0xe9, 0x99, + 0xa2, 0x96, 0x77, 0x45, 0x6e, 0xae, 0x9e, 0xf5, 0x3a, 0xd8, 0x78, 0xf8, 0xb6, 0x14, + 0x94, 0xf0, 0x8f, 0x00, ], Core::FullDecrement8 => [ - 0x7c, 0x5e, 0x94, 0xa9, 0x98, 0x02, 0x81, 0x82, 0x17, 0x37, 0xb1, 0xce, 0x73, 0xbf, - 0xda, 0x4c, 0x79, 0xef, 0x64, 0x9b, 0x3d, 0x05, 0xcc, 0x1c, 0x00, 0xc4, 0xa8, 0xb6, - 0x4b, 0x94, 0x9b, 0xbe, + 0xb4, 0x1a, 0xfe, 0x97, 0x4e, 0xaa, 0x11, 0x82, 0xac, 0x46, 0x10, 0x52, 0x1e, 0x28, + 0x27, 0x81, 0x31, 0x8c, 0xe2, 0x95, 0xa3, 0xf2, 0x3f, 0x0b, 0x87, 0x6a, 0xe2, 0x69, + 0x67, 0x3f, 0xb1, 0xdf, ], Core::FullIncrement16 => [ - 0x81, 0x38, 0x0a, 0xda, 0xa3, 0xa5, 0x47, 0xf1, 0xbc, 0x4b, 0xbb, 0x64, 0x6b, 0xda, - 0x9d, 0x9f, 0xb7, 0xbd, 0x4d, 0xc1, 0xb3, 0xa9, 0xf3, 0xdd, 0x22, 0x0b, 0x56, 0xa4, - 0x7c, 0x27, 0x98, 0xfb, + 0xa6, 0x8e, 0xcc, 0xdb, 0x9e, 0xad, 0x29, 0x26, 0xc3, 0xe4, 0x5b, 0x4b, 0xae, 0x43, + 0x1c, 0xc4, 0x66, 0xd5, 0x8b, 0x8f, 0xac, 0xc9, 0x5a, 0x1b, 0x48, 0x44, 0xb9, 0x12, + 0xdf, 0x56, 0x76, 0xdf, ], Core::FullIncrement32 => [ - 0xa7, 0x60, 0xa8, 0x44, 0x9a, 0x2a, 0xb5, 0xde, 0xdb, 0x4e, 0xe5, 0x1b, 0xf5, 0xc2, - 0x5a, 0x8f, 0x06, 0xaf, 0x06, 0x66, 0xdf, 0x7f, 0xc4, 0x19, 0xb4, 0x98, 0xb9, 0x09, - 0x76, 0xd6, 0x98, 0xcb, + 0xd0, 0xeb, 0x0e, 0x94, 0xa5, 0xc2, 0x57, 0x13, 0xeb, 0x94, 0x4c, 0xad, 0x4d, 0x70, + 0x1c, 0x6a, 0x96, 0x88, 0x09, 0xbc, 0x1a, 0xf9, 0x03, 0xfd, 0xb1, 0x1e, 0x6f, 0xad, + 0x0b, 0xb3, 0x1b, 0x10, ], Core::FullIncrement64 => [ - 0xc6, 0xaf, 0x30, 0xdd, 0x28, 0x6d, 0x6e, 0x21, 0xc3, 0x88, 0x60, 0xed, 0x1e, 0x2f, - 0x21, 0x2a, 0x21, 0xb2, 0xfd, 0x1e, 0xde, 0xad, 0xb5, 0xe0, 0xfc, 0xe2, 0xe3, 0xfd, - 0x75, 0xb7, 0xf3, 0xc2, + 0xc0, 0x03, 0xd2, 0xe9, 0xb0, 0xa5, 0x10, 0xc2, 0xdd, 0x78, 0x3e, 0x7d, 0x64, 0xeb, + 0x87, 0xb3, 0x38, 0x55, 0xd3, 0x29, 0x90, 0xdf, 0xc2, 0x86, 0x26, 0x6e, 0x47, 0x8d, + 0xa4, 0xe7, 0x47, 0x91, ], Core::FullIncrement8 => [ - 0xd3, 0x04, 0xea, 0x28, 0xa9, 0x5d, 0x49, 0x6d, 0x14, 0xb4, 0xf2, 0xfb, 0x5c, 0x86, - 0x03, 0x72, 0xec, 0xf2, 0x47, 0xbe, 0xfd, 0xe3, 0xea, 0x3b, 0x2a, 0xd6, 0x7b, 0xce, - 0x99, 0x03, 0x9d, 0xbc, + 0x0b, 0xea, 0x24, 0x29, 0x18, 0xf2, 0xdd, 0x17, 0x64, 0x77, 0x78, 0x11, 0xe4, 0x44, + 0x28, 0x63, 0x93, 0x52, 0x25, 0xb0, 0xf8, 0xb2, 0x39, 0xc2, 0x37, 0x52, 0xf9, 0xd8, + 0x53, 0x92, 0xa1, 0x39, ], Core::FullLeftShift16_1 => [ - 0x14, 0xdc, 0xc3, 0x46, 0x6f, 0xa8, 0x28, 0xa3, 0xf0, 0x74, 0x04, 0x51, 0xb8, 0x03, - 0x7d, 0x7a, 0xd6, 0x03, 0xea, 0xdc, 0x80, 0xaa, 0xea, 0xdc, 0x66, 0x44, 0x34, 0xac, - 0x2a, 0xd7, 0xfd, 0x9c, + 0xb3, 0x66, 0xa8, 0x16, 0x92, 0x2f, 0xc4, 0x55, 0x01, 0x0f, 0xe8, 0x8a, 0x5f, 0x6a, + 0x5c, 0xf2, 0xce, 0xa9, 0x17, 0xe1, 0x2b, 0xd1, 0x40, 0xae, 0x6d, 0x43, 0xb6, 0x41, + 0xe5, 0x7f, 0x42, 0xb3, ], Core::FullLeftShift16_2 => [ - 0xaf, 0xb7, 0xe9, 0x28, 0xb0, 0x52, 0xc2, 0x28, 0x79, 0x21, 0x66, 0x2c, 0xd8, 0xab, - 0x12, 0x2f, 0xe0, 0x74, 0xef, 0xd2, 0x51, 0xa5, 0xc9, 0xcf, 0xbc, 0xaa, 0x36, 0x9d, - 0x06, 0x33, 0x73, 0x92, + 0x27, 0x96, 0x0d, 0x0d, 0xf2, 0xfb, 0xbc, 0x38, 0x99, 0x3d, 0x86, 0xfb, 0x8f, 0x0c, + 0xd2, 0xc3, 0x43, 0x4e, 0xdb, 0x11, 0x04, 0x82, 0x13, 0xc1, 0x41, 0x18, 0x93, 0xca, + 0x99, 0x33, 0xb2, 0xee, ], Core::FullLeftShift16_4 => [ - 0x16, 0x6f, 0x34, 0x8c, 0x59, 0xe2, 0x6f, 0x89, 0xa8, 0x3a, 0x99, 0x1f, 0x67, 0xe5, - 0xdb, 0xf7, 0x10, 0xcf, 0xae, 0x3d, 0x6d, 0x96, 0x93, 0x82, 0x82, 0xbb, 0x44, 0xc1, - 0xaf, 0xa7, 0x10, 0x9b, + 0x65, 0x51, 0x37, 0xbe, 0xc5, 0xc0, 0x36, 0x8f, 0x29, 0xbc, 0x99, 0x2c, 0x88, 0x42, + 0x1a, 0x15, 0x98, 0x56, 0x40, 0x39, 0x7b, 0x61, 0x7f, 0xc4, 0x8d, 0x33, 0x21, 0x0f, + 0xc0, 0x05, 0x3a, 0xd1, ], Core::FullLeftShift16_8 => [ - 0xc0, 0xcd, 0x01, 0x5d, 0xe8, 0xac, 0x4f, 0xcc, 0xd8, 0xdb, 0x89, 0xf4, 0xe5, 0x14, - 0x2f, 0xde, 0x27, 0x97, 0x55, 0xb5, 0x42, 0xa2, 0x4f, 0x57, 0xa2, 0xa3, 0xc7, 0xc1, - 0xf5, 0x0d, 0x1d, 0xb5, + 0x16, 0x8f, 0x57, 0x6a, 0xa5, 0x6e, 0xa4, 0x7e, 0x07, 0x06, 0x46, 0xe7, 0x88, 0x96, + 0xbe, 0xb2, 0x49, 0x8b, 0x1a, 0xe6, 0xb1, 0xff, 0x9c, 0x78, 0x62, 0x70, 0xe9, 0x55, + 0x65, 0x84, 0x19, 0x29, ], Core::FullLeftShift32_1 => [ - 0xce, 0x33, 0xb5, 0xd0, 0xc5, 0x8d, 0x2d, 0x0b, 0x9b, 0x5a, 0x99, 0x44, 0xd3, 0xda, - 0xbd, 0xa0, 0x23, 0xcd, 0x44, 0x64, 0x7b, 0xe6, 0x7c, 0xf4, 0x08, 0x28, 0x30, 0xbb, - 0x20, 0x5f, 0x8f, 0xbb, + 0xd7, 0xcd, 0x52, 0x24, 0x49, 0x11, 0x8e, 0x81, 0x00, 0xa7, 0x66, 0x2f, 0x4d, 0xf0, + 0x39, 0xf8, 0xca, 0xeb, 0xf4, 0x33, 0xeb, 0x03, 0x9e, 0xdc, 0x42, 0xe8, 0x82, 0x37, + 0x92, 0xcc, 0xea, 0x8a, ], Core::FullLeftShift32_16 => [ - 0x1c, 0xb3, 0x6e, 0x6f, 0x99, 0x30, 0x85, 0x15, 0xd4, 0xb7, 0x11, 0x90, 0x9c, 0x57, - 0x4b, 0x21, 0x24, 0xc1, 0xff, 0x42, 0x2d, 0x8d, 0x7d, 0x94, 0x82, 0xe2, 0x5d, 0x87, - 0x88, 0xb3, 0xb9, 0x57, + 0x8b, 0xd8, 0x0d, 0x4d, 0x2f, 0x8b, 0x22, 0x46, 0xc1, 0x23, 0x15, 0xc4, 0x28, 0x41, + 0xb4, 0xe4, 0x0a, 0x71, 0xae, 0x76, 0x96, 0x6a, 0x08, 0x95, 0x4d, 0x66, 0x6b, 0x86, + 0x32, 0x86, 0x74, 0x37, ], Core::FullLeftShift32_2 => [ - 0x3f, 0xae, 0xa9, 0xb5, 0x73, 0xfc, 0x06, 0x9d, 0x8f, 0x43, 0x0f, 0xac, 0xa8, 0x97, - 0xb6, 0x87, 0x1e, 0xa0, 0x95, 0x73, 0xc7, 0x15, 0x09, 0x4b, 0x1f, 0x1b, 0xe0, 0x81, - 0x84, 0x88, 0xa7, 0x16, + 0x13, 0x06, 0x3d, 0x62, 0x93, 0x83, 0x29, 0x31, 0x1f, 0xb7, 0xda, 0xbb, 0x15, 0xc3, + 0xfe, 0x58, 0xc2, 0x88, 0x76, 0x83, 0x00, 0x97, 0xec, 0xc6, 0xbf, 0xdd, 0x48, 0x0b, + 0xe1, 0x98, 0x81, 0x46, ], Core::FullLeftShift32_4 => [ - 0xcd, 0xbb, 0x0d, 0x23, 0x31, 0x05, 0x90, 0x11, 0x3c, 0x93, 0x4f, 0xe6, 0x60, 0x04, - 0xd2, 0xa1, 0x1d, 0xa9, 0xcb, 0xf8, 0x87, 0x3d, 0x00, 0xde, 0xe7, 0xf0, 0x22, 0x96, - 0xff, 0x0a, 0x2f, 0x12, + 0x25, 0xa1, 0xb5, 0xdd, 0xe5, 0xdb, 0x28, 0x4e, 0x8a, 0x88, 0x21, 0x26, 0x7c, 0x26, + 0x53, 0x01, 0x14, 0xbb, 0xe6, 0x71, 0xcf, 0xaf, 0xb4, 0x4a, 0x60, 0xd7, 0x50, 0x27, + 0x67, 0xdb, 0x78, 0x2e, ], Core::FullLeftShift32_8 => [ - 0xcc, 0xd9, 0x24, 0xe1, 0xa6, 0x18, 0x49, 0x42, 0x0f, 0xf6, 0x2e, 0xd8, 0xb2, 0x45, - 0xa3, 0xaa, 0x18, 0xc9, 0x8c, 0x41, 0xf9, 0xc5, 0xa3, 0xc0, 0xb8, 0x85, 0x86, 0x3c, - 0x44, 0x9b, 0x7d, 0x14, + 0xce, 0x54, 0x70, 0xaf, 0xbf, 0xad, 0xbf, 0xba, 0x68, 0xf9, 0xb2, 0xd5, 0xb0, 0x64, + 0x5a, 0x44, 0x08, 0xbe, 0x6f, 0x85, 0xa6, 0x9c, 0x7f, 0x09, 0xd0, 0x96, 0x45, 0x53, + 0x68, 0x04, 0x87, 0x64, ], Core::FullLeftShift64_1 => [ - 0xd4, 0x63, 0xcc, 0xdc, 0x7f, 0xd1, 0x4e, 0x5e, 0x89, 0x41, 0x62, 0xb2, 0xae, 0x71, - 0x41, 0x28, 0xa1, 0x0d, 0xc9, 0x20, 0x00, 0xb5, 0x4c, 0x84, 0x3b, 0x64, 0x9c, 0xcb, - 0x77, 0x56, 0x26, 0xe5, + 0x05, 0x1f, 0x36, 0x05, 0x86, 0xc3, 0x79, 0xac, 0x2c, 0xe3, 0x99, 0xcb, 0xeb, 0x68, + 0x7e, 0x77, 0x53, 0xb1, 0x5d, 0x73, 0x03, 0xdd, 0x31, 0x6c, 0xbd, 0x12, 0x30, 0x12, + 0x08, 0x7c, 0xc6, 0x6f, ], Core::FullLeftShift64_16 => [ - 0x88, 0x2d, 0xce, 0x21, 0x2a, 0x0e, 0x61, 0xf8, 0xf9, 0x4c, 0xb5, 0xe3, 0x2e, 0x00, - 0xa5, 0x28, 0x7c, 0xf6, 0x4f, 0x20, 0xc2, 0x1f, 0xca, 0x84, 0xf1, 0xe3, 0xdf, 0x7f, - 0x4a, 0x62, 0x91, 0xcd, + 0xb2, 0x48, 0xbe, 0x4d, 0xfc, 0xb8, 0x8c, 0x5d, 0x89, 0xb1, 0xca, 0x61, 0x86, 0xa0, + 0x41, 0xe9, 0x02, 0xb4, 0xc8, 0xa6, 0x2b, 0xb1, 0x6e, 0x09, 0xfe, 0x15, 0x61, 0x6e, + 0x0e, 0x3a, 0xbd, 0x6d, ], Core::FullLeftShift64_2 => [ - 0x48, 0xc8, 0x9b, 0x19, 0x1a, 0x51, 0xb6, 0xab, 0x03, 0x4c, 0x80, 0xea, 0xff, 0x34, - 0x82, 0x38, 0xd9, 0x3f, 0xb3, 0x1c, 0x1e, 0x92, 0xe7, 0xf2, 0xae, 0x49, 0x31, 0x7e, - 0x0e, 0x33, 0xf8, 0x2d, + 0x34, 0xbb, 0x51, 0x62, 0x6b, 0x1d, 0x6b, 0x89, 0x7a, 0xbc, 0x15, 0x5d, 0x03, 0x4f, + 0xe0, 0x66, 0x3a, 0x0e, 0xc0, 0xfd, 0x8f, 0x64, 0x0e, 0x5f, 0xe1, 0xbf, 0x3c, 0xb7, + 0x67, 0x0a, 0x29, 0x25, ], Core::FullLeftShift64_32 => [ - 0x39, 0x75, 0x90, 0x73, 0x33, 0xe1, 0x27, 0x30, 0x62, 0x55, 0xb7, 0xf8, 0x89, 0x39, - 0xe2, 0x85, 0x7f, 0x42, 0xae, 0x1b, 0xf0, 0xc6, 0x62, 0x40, 0xa8, 0x22, 0x4c, 0x8d, - 0xa3, 0x8b, 0xb1, 0xbe, + 0x9d, 0xac, 0x8c, 0xd7, 0xfd, 0x8b, 0x48, 0x88, 0x9e, 0x55, 0xc5, 0xaa, 0x12, 0xfe, + 0x97, 0xb7, 0x29, 0xfe, 0xbc, 0x04, 0x1a, 0x9f, 0xff, 0x44, 0xc4, 0xd9, 0xb6, 0xf1, + 0xe0, 0x7e, 0xb4, 0x42, ], Core::FullLeftShift64_4 => [ - 0x29, 0x31, 0x32, 0xeb, 0x15, 0xdd, 0xf4, 0x17, 0x74, 0xb0, 0x00, 0x5a, 0x3b, 0x5c, - 0x50, 0x95, 0x9f, 0xa8, 0x98, 0x2b, 0x75, 0x9e, 0x83, 0x28, 0x27, 0xc7, 0x4f, 0xa8, - 0x28, 0x50, 0x66, 0x6c, + 0x94, 0xb7, 0x3d, 0xad, 0xc3, 0xee, 0xeb, 0x2e, 0xe4, 0xa4, 0xd4, 0x44, 0xdd, 0x0f, + 0x72, 0xac, 0x30, 0x62, 0x01, 0xf2, 0xff, 0xcf, 0x71, 0x4b, 0x8e, 0xbe, 0x79, 0x82, + 0x74, 0x4c, 0x0c, 0x7e, ], Core::FullLeftShift64_8 => [ - 0xe6, 0xab, 0xde, 0xd8, 0xbe, 0x58, 0x5e, 0xb0, 0xb6, 0xd4, 0x6e, 0x0c, 0x5e, 0xb2, - 0x8a, 0x74, 0x5f, 0x4e, 0x5c, 0x56, 0xfd, 0x65, 0x21, 0xf8, 0xf3, 0x96, 0xcb, 0x21, - 0xa7, 0x58, 0xf7, 0x4c, + 0x0e, 0xf7, 0x14, 0x75, 0x7e, 0xcf, 0x11, 0xca, 0x3c, 0x73, 0xce, 0x25, 0xef, 0x24, + 0xee, 0x72, 0x95, 0xdd, 0x41, 0x71, 0xcc, 0x16, 0x28, 0x7f, 0xe6, 0x97, 0x1b, 0xd6, + 0x7b, 0x47, 0x8b, 0x46, ], Core::FullLeftShift8_1 => [ - 0x73, 0x3f, 0xed, 0x08, 0x47, 0xa2, 0xff, 0xac, 0x9a, 0xab, 0xf5, 0x0a, 0x2f, 0xeb, - 0x50, 0x59, 0x89, 0x84, 0xf1, 0x6d, 0x8b, 0x73, 0x24, 0x68, 0xb3, 0xd3, 0x15, 0xc0, - 0x1e, 0xa4, 0x29, 0x9b, + 0x9b, 0xfa, 0x48, 0xb7, 0xad, 0x51, 0x00, 0x91, 0xba, 0x60, 0x85, 0x44, 0x62, 0xd8, + 0x59, 0xef, 0xd1, 0xa2, 0xaa, 0x18, 0x73, 0x1b, 0x5f, 0x0c, 0x9e, 0x2b, 0xa4, 0xd8, + 0x9d, 0x3a, 0xa8, 0x43, ], Core::FullLeftShift8_2 => [ - 0xb4, 0x47, 0x4d, 0x0b, 0xa1, 0xcf, 0x4f, 0xa2, 0xd6, 0x4c, 0xd4, 0xfe, 0x67, 0xbd, - 0xc9, 0x2c, 0xb8, 0x9e, 0xfa, 0x70, 0xcb, 0x99, 0xaf, 0x77, 0x91, 0xbf, 0x7e, 0xf6, - 0xe9, 0x09, 0xd2, 0xc7, + 0x79, 0x7c, 0x20, 0x87, 0x01, 0xb2, 0xa4, 0xe1, 0x04, 0x9e, 0x83, 0xd6, 0x95, 0xf5, + 0x54, 0xb9, 0x84, 0xf5, 0xdb, 0x28, 0x21, 0x52, 0x55, 0x58, 0x7c, 0x37, 0x34, 0x21, + 0x51, 0xb7, 0x24, 0x1d, ], Core::FullLeftShift8_4 => [ - 0x8e, 0xb5, 0x22, 0xb9, 0x97, 0x04, 0x74, 0xad, 0xbb, 0x7a, 0xb0, 0xde, 0x37, 0xc4, - 0xe7, 0xa0, 0x56, 0xa1, 0xcb, 0x21, 0x2e, 0x41, 0x03, 0xe4, 0xa8, 0xcb, 0xbb, 0xb6, - 0x3d, 0x97, 0x56, 0x06, + 0x37, 0xbd, 0xac, 0x91, 0x53, 0x8f, 0x22, 0x19, 0xcb, 0x89, 0xdf, 0x0e, 0xf9, 0xf1, + 0x97, 0xcd, 0x68, 0x03, 0x1f, 0x27, 0x67, 0xe8, 0x94, 0xf0, 0x01, 0xc2, 0x6f, 0xff, + 0x5e, 0xeb, 0x58, 0xcd, ], Core::FullMultiply16 => [ - 0x88, 0x47, 0x0c, 0xbf, 0x9b, 0x4d, 0xec, 0x37, 0xea, 0x05, 0xd7, 0xb6, 0x30, 0xf2, - 0xf1, 0x12, 0x54, 0x75, 0x67, 0xd3, 0x4f, 0x33, 0xd9, 0x6e, 0x5f, 0x61, 0x1b, 0xd9, - 0xda, 0x97, 0xab, 0xb5, + 0x09, 0xba, 0xff, 0x92, 0x1e, 0x9f, 0x14, 0xd1, 0x20, 0x8d, 0x1d, 0xd8, 0x26, 0x4c, + 0xf1, 0xf3, 0xb8, 0x54, 0xc9, 0xaf, 0x21, 0xf7, 0x78, 0xb2, 0xb5, 0x5a, 0x8a, 0x42, + 0x6d, 0xfe, 0x89, 0x28, ], Core::FullMultiply32 => [ - 0x28, 0x04, 0x06, 0x00, 0xa6, 0x6e, 0x1a, 0x0c, 0x52, 0x25, 0x85, 0x20, 0x48, 0x8b, - 0x94, 0xc8, 0x20, 0xc6, 0xcf, 0x86, 0xca, 0x27, 0xae, 0x39, 0x03, 0x4d, 0xdd, 0xca, - 0xb9, 0x04, 0xd1, 0xd5, + 0x10, 0xc4, 0xb8, 0xc4, 0xc0, 0xac, 0xd9, 0x73, 0x90, 0xf8, 0x5c, 0xb3, 0xf5, 0xff, + 0xe3, 0x6a, 0x29, 0x20, 0x37, 0xc1, 0x90, 0xee, 0xba, 0xb3, 0xe9, 0x89, 0x34, 0xfe, + 0x93, 0xb2, 0xed, 0x90, ], Core::FullMultiply64 => [ - 0x53, 0x01, 0x4f, 0x35, 0xa8, 0xdf, 0x20, 0x91, 0xaf, 0x3e, 0xf9, 0xb8, 0xd1, 0x6b, - 0x38, 0xb9, 0xbc, 0x96, 0x61, 0xbf, 0xdb, 0xc9, 0x57, 0x33, 0x3f, 0xba, 0x2a, 0x94, - 0x8c, 0x1e, 0x8c, 0x25, + 0x2d, 0xb1, 0x9d, 0xba, 0x90, 0xef, 0x86, 0x7b, 0x5a, 0x3e, 0x91, 0x4b, 0x89, 0xfd, + 0xa2, 0xda, 0x63, 0x7c, 0xa8, 0x0c, 0x42, 0x67, 0xe1, 0x98, 0x18, 0x37, 0xee, 0x3c, + 0x6f, 0xe3, 0xda, 0xf5, ], Core::FullMultiply8 => [ - 0xd3, 0xd2, 0x45, 0x54, 0xc4, 0x66, 0xdd, 0x60, 0x37, 0x54, 0x52, 0x47, 0x36, 0xa7, - 0x1e, 0xb2, 0x35, 0xde, 0xf9, 0xb5, 0x06, 0x96, 0x5e, 0x32, 0xd5, 0x68, 0x26, 0xe1, - 0x9f, 0xba, 0xd6, 0xc1, + 0x7f, 0x46, 0xee, 0x72, 0x84, 0xf3, 0x9e, 0x73, 0x42, 0x75, 0xa2, 0x50, 0x9a, 0x0b, + 0x73, 0x7e, 0xd9, 0x39, 0x11, 0x5f, 0x02, 0x19, 0xa5, 0x74, 0xd4, 0x69, 0xcd, 0x30, + 0xb8, 0x19, 0xef, 0xe3, ], Core::FullRightShift16_1 => [ - 0xb3, 0x79, 0xe2, 0x96, 0xe9, 0xa9, 0x8f, 0xb3, 0xb5, 0x66, 0x2b, 0x8b, 0xa0, 0x4e, - 0x3c, 0xc1, 0xa4, 0x3c, 0x74, 0x42, 0x9e, 0x93, 0x12, 0x33, 0xfd, 0xd7, 0xfc, 0x8f, - 0xe6, 0xb7, 0xa2, 0xe0, + 0x7e, 0xbe, 0x0c, 0x66, 0xc3, 0xc7, 0xdc, 0x16, 0xa5, 0x46, 0x9e, 0x91, 0x79, 0x09, + 0x84, 0x17, 0xac, 0x5f, 0x20, 0xa3, 0x9c, 0xc4, 0x1a, 0xc3, 0x82, 0xfb, 0x1d, 0xbd, + 0x98, 0xe8, 0xe3, 0x0f, ], Core::FullRightShift16_2 => [ - 0xae, 0xb8, 0xc6, 0x08, 0x06, 0xa4, 0x79, 0x20, 0x77, 0x58, 0xe3, 0x90, 0x83, 0xb4, - 0xa9, 0xa7, 0xa1, 0x4d, 0xa4, 0xee, 0x9b, 0xc1, 0x09, 0x7f, 0xc5, 0xcb, 0x4b, 0x75, - 0x54, 0x0d, 0x75, 0x78, + 0x8d, 0xb0, 0xc2, 0x16, 0x19, 0xc6, 0x2d, 0x63, 0xd4, 0xc2, 0x7b, 0xfc, 0xf6, 0x47, + 0xd7, 0x09, 0xce, 0x37, 0xbe, 0xd0, 0x57, 0x18, 0xe9, 0x3e, 0x45, 0x15, 0xe2, 0x9e, + 0xf3, 0x73, 0x0c, 0xf4, ], Core::FullRightShift16_4 => [ - 0x60, 0xb7, 0xf0, 0x84, 0x75, 0xcc, 0x0c, 0xce, 0x64, 0xdc, 0xa1, 0x2d, 0x9f, 0x6a, - 0x91, 0x9c, 0x30, 0x61, 0x81, 0x10, 0xed, 0xa1, 0x40, 0x65, 0x92, 0x9c, 0x00, 0x4e, - 0x7f, 0xc1, 0xb0, 0xfb, + 0x5c, 0x74, 0xb1, 0x32, 0x06, 0x31, 0x79, 0x17, 0xe0, 0x70, 0xe5, 0xfc, 0x1c, 0x82, + 0xf4, 0xc5, 0xc2, 0xfb, 0xe9, 0xf3, 0x1b, 0x81, 0x29, 0x46, 0xba, 0x23, 0x0d, 0x8c, + 0x94, 0xd4, 0x06, 0x16, ], Core::FullRightShift16_8 => [ - 0xf7, 0x9d, 0xba, 0x3e, 0x0a, 0xf3, 0xd6, 0xa5, 0x59, 0xa9, 0xe9, 0xdf, 0xfe, 0xa7, - 0x10, 0xaf, 0x62, 0x3f, 0xe6, 0xe6, 0x64, 0x4b, 0x89, 0x79, 0x95, 0xd7, 0x1b, 0x8a, - 0x41, 0x67, 0xdd, 0xb0, + 0x11, 0x05, 0x81, 0x8a, 0xc9, 0x48, 0xd7, 0xbb, 0x63, 0x47, 0x07, 0xe6, 0x9d, 0xbf, + 0x1f, 0x67, 0x90, 0x58, 0xa1, 0x3d, 0x35, 0xfa, 0xc2, 0xa6, 0x4d, 0xf9, 0x72, 0x62, + 0xf2, 0x42, 0xb6, 0x3b, ], Core::FullRightShift32_1 => [ - 0xad, 0x0d, 0x5c, 0x75, 0xea, 0x68, 0x43, 0x71, 0x91, 0x77, 0x0d, 0x7f, 0xdf, 0x80, - 0x4b, 0xbc, 0x9d, 0x57, 0x3d, 0x5f, 0x10, 0x19, 0x98, 0x23, 0xd8, 0x09, 0xc9, 0xc4, - 0x6c, 0xd2, 0x75, 0xad, + 0x9b, 0x42, 0xc8, 0xf3, 0x3b, 0xc5, 0x75, 0x0e, 0x2a, 0x83, 0xaa, 0xdb, 0xf2, 0x9c, + 0xc7, 0xfc, 0xb9, 0x50, 0xfe, 0x5a, 0x40, 0xaa, 0x0e, 0xc5, 0x24, 0x52, 0xe5, 0x33, + 0xf8, 0x25, 0xa1, 0x15, ], Core::FullRightShift32_16 => [ - 0x45, 0x52, 0x99, 0xfd, 0x6f, 0x42, 0xab, 0x49, 0xdb, 0xb7, 0x09, 0xe6, 0x5a, 0x3b, - 0x53, 0x66, 0x25, 0x0b, 0xdc, 0x54, 0x5d, 0x62, 0x29, 0xe8, 0xe2, 0x36, 0x05, 0x6d, - 0xdd, 0x19, 0x77, 0xfd, + 0x0a, 0xe5, 0x65, 0x9c, 0x2f, 0xa7, 0x57, 0x94, 0x78, 0xeb, 0xd5, 0x7c, 0x4c, 0x98, + 0xae, 0xe7, 0x77, 0x01, 0x56, 0x45, 0xb2, 0x84, 0x31, 0x81, 0x64, 0xfc, 0xbd, 0x30, + 0x65, 0xfc, 0x87, 0x3c, ], Core::FullRightShift32_2 => [ - 0x44, 0x38, 0x4b, 0x15, 0x06, 0xd4, 0x43, 0xd2, 0xf8, 0xa2, 0x88, 0x2b, 0x45, 0x63, - 0xd7, 0x93, 0x1a, 0x7e, 0xbc, 0xe6, 0x4a, 0xcf, 0x0d, 0x02, 0xee, 0x59, 0xec, 0x69, - 0xd3, 0x06, 0x52, 0x39, + 0x57, 0xfb, 0x1c, 0x03, 0xc2, 0xeb, 0x17, 0xf6, 0x23, 0x47, 0x87, 0x34, 0xfd, 0x69, + 0x37, 0xf9, 0xe3, 0xef, 0x02, 0x7c, 0x15, 0x60, 0x03, 0x8f, 0xa6, 0x06, 0x69, 0x05, + 0x17, 0x89, 0xe3, 0x68, ], Core::FullRightShift32_4 => [ - 0x2e, 0x9a, 0x8a, 0xb5, 0xa1, 0x81, 0x7b, 0xd0, 0xb8, 0xa4, 0x66, 0x26, 0x99, 0x49, - 0x17, 0xa0, 0xde, 0x1a, 0x74, 0x5e, 0x99, 0x52, 0x0c, 0xe6, 0xeb, 0xcc, 0x67, 0xd4, - 0x63, 0x65, 0x51, 0xb7, + 0x85, 0x82, 0xcd, 0xfa, 0x74, 0xef, 0x46, 0x6b, 0x81, 0x27, 0xb1, 0x97, 0x88, 0x13, + 0x45, 0x93, 0x99, 0x8e, 0x49, 0x69, 0x00, 0xb3, 0x8f, 0x0f, 0x3d, 0x37, 0x58, 0x18, + 0xd6, 0x73, 0x45, 0x1e, ], Core::FullRightShift32_8 => [ - 0xaf, 0x47, 0xd4, 0xf9, 0x6e, 0x7d, 0x80, 0x26, 0xd4, 0x4e, 0x6e, 0xca, 0x1b, 0x80, - 0x7f, 0x73, 0x34, 0x4c, 0xe2, 0xea, 0xf7, 0x00, 0xb2, 0xc8, 0x2b, 0x4b, 0xb0, 0x02, - 0x61, 0xa8, 0x6f, 0x94, + 0xd9, 0x05, 0x93, 0x2e, 0xbf, 0xca, 0x2a, 0x38, 0x61, 0x9d, 0x80, 0x7e, 0x28, 0xff, + 0x2e, 0x0d, 0x3b, 0xe0, 0x8a, 0x26, 0x06, 0x76, 0xd2, 0x57, 0xef, 0xa0, 0x40, 0xc3, + 0x05, 0xaa, 0xdc, 0x33, ], Core::FullRightShift64_1 => [ - 0x03, 0xaf, 0xb5, 0x47, 0xc3, 0x09, 0x13, 0xf1, 0x6f, 0x3e, 0x37, 0x0d, 0x7f, 0x9c, - 0xa0, 0x29, 0x0b, 0x61, 0x5b, 0x42, 0x85, 0x05, 0x1b, 0xb9, 0x3c, 0x3c, 0x1a, 0x9b, - 0x72, 0xee, 0x8d, 0xe4, + 0x3c, 0x15, 0x20, 0x9b, 0x99, 0xd2, 0x84, 0x5e, 0x22, 0x5e, 0x14, 0xe1, 0xe9, 0xe5, + 0xe6, 0xa4, 0x87, 0x8b, 0xc8, 0xce, 0xa3, 0xf9, 0xf3, 0x6b, 0x8b, 0x53, 0x5a, 0xc6, + 0x83, 0xe2, 0x9d, 0x00, ], Core::FullRightShift64_16 => [ - 0x1f, 0xb0, 0x56, 0xfc, 0xb6, 0x90, 0xce, 0xe3, 0xcf, 0xf7, 0x2c, 0x7d, 0xec, 0xda, - 0x80, 0x6d, 0x21, 0x46, 0xc4, 0x92, 0xae, 0x73, 0x1a, 0x6b, 0x94, 0xb8, 0xbb, 0x4f, - 0x15, 0x99, 0xb0, 0xcc, + 0x02, 0x85, 0x25, 0x7b, 0x09, 0x0d, 0x8d, 0xa1, 0x28, 0xef, 0x64, 0xa8, 0x0c, 0x8d, + 0x16, 0xfd, 0xc3, 0xbf, 0x5c, 0xe5, 0x0f, 0xcd, 0x56, 0xfe, 0xc5, 0xf9, 0x02, 0x55, + 0xd9, 0xc8, 0xdf, 0x47, ], Core::FullRightShift64_2 => [ - 0x06, 0x73, 0xbf, 0xf2, 0x1e, 0x37, 0x5e, 0x5d, 0xbc, 0xaf, 0x38, 0x04, 0x66, 0x48, - 0x25, 0xdd, 0x67, 0x48, 0x44, 0xd2, 0xfd, 0xb7, 0x84, 0xa4, 0xfe, 0xfb, 0xc9, 0x25, - 0xcf, 0x6b, 0x27, 0xad, + 0x7e, 0xc2, 0xdd, 0x65, 0xc9, 0xe0, 0x13, 0xe3, 0xe4, 0xce, 0x90, 0xfb, 0xeb, 0x3f, + 0xb1, 0xc7, 0x8c, 0xcc, 0x5d, 0x2a, 0x7d, 0x26, 0xd8, 0xaf, 0x77, 0xf9, 0x9d, 0xe8, + 0x4c, 0xf7, 0x29, 0x73, ], Core::FullRightShift64_32 => [ 0x35, 0x6f, 0x7d, 0xd4, 0x6b, 0xa3, 0x3f, 0x84, 0xb0, 0x66, 0x72, 0xfd, 0xe9, 0xa2, @@ -1300,159 +1307,159 @@ impl Jet for Core { 0x69, 0xf1, 0x0b, 0x56, ], Core::FullRightShift64_4 => [ - 0x4c, 0x25, 0xf6, 0x01, 0x1f, 0xd3, 0xd1, 0xac, 0x18, 0xe1, 0x1e, 0xb4, 0x30, 0x61, - 0xfa, 0xd6, 0x9f, 0x3c, 0xe3, 0x9f, 0x7a, 0x99, 0xce, 0xde, 0x50, 0xcc, 0x85, 0xbf, - 0x88, 0xbf, 0xba, 0x82, + 0x05, 0x46, 0x4a, 0x33, 0x35, 0xaf, 0xbb, 0x09, 0xd0, 0x46, 0x82, 0x8a, 0x92, 0x2c, + 0x4d, 0xa0, 0xec, 0xee, 0xb1, 0x09, 0x77, 0xe4, 0x68, 0x01, 0xc9, 0x3c, 0xdd, 0x66, + 0x8f, 0x22, 0xee, 0x63, ], Core::FullRightShift64_8 => [ - 0xa5, 0x1d, 0xf9, 0x44, 0x86, 0x02, 0xfa, 0x81, 0x00, 0x1a, 0xa1, 0xb5, 0xb1, 0x3b, - 0xe8, 0x8d, 0x4b, 0x2f, 0x4d, 0x0f, 0x60, 0x74, 0x08, 0x01, 0xce, 0xf9, 0x91, 0x00, - 0x2f, 0xe3, 0x7d, 0x6d, + 0x70, 0x17, 0x2e, 0x1a, 0x69, 0x48, 0xbf, 0x40, 0x12, 0x0e, 0x68, 0xfb, 0x8b, 0x4b, + 0x23, 0xbc, 0x35, 0x5a, 0x12, 0x00, 0x2c, 0xcc, 0x1d, 0xb6, 0x47, 0xc8, 0x9b, 0x12, + 0xd1, 0x0e, 0xc5, 0x06, ], Core::FullRightShift8_1 => [ - 0xd9, 0xd4, 0xb1, 0x6d, 0x37, 0xe4, 0xeb, 0x5c, 0xc5, 0x15, 0x04, 0x26, 0xe3, 0xe8, - 0x6c, 0xf6, 0x0a, 0xbb, 0xdf, 0xa1, 0xd0, 0xec, 0xb4, 0x15, 0x82, 0x96, 0x5e, 0x80, - 0x00, 0xcb, 0xd2, 0x91, + 0x56, 0x69, 0xdb, 0xfc, 0xc6, 0x33, 0xec, 0x0b, 0xdf, 0x59, 0xe2, 0x2f, 0x03, 0xed, + 0x4b, 0x64, 0x19, 0x20, 0x95, 0xf5, 0xdf, 0x20, 0xff, 0xc1, 0x2d, 0xd9, 0x0d, 0x7c, + 0xda, 0x11, 0x37, 0x4f, ], Core::FullRightShift8_2 => [ - 0x07, 0x9a, 0xa1, 0x66, 0x17, 0x19, 0x8a, 0xd5, 0xdf, 0x2c, 0x98, 0xa6, 0x3a, 0xf7, - 0x6c, 0x1b, 0x3e, 0x12, 0x0f, 0xd2, 0x10, 0x6b, 0x22, 0x5f, 0x63, 0xfd, 0x06, 0xac, - 0x57, 0x1d, 0x04, 0xa4, + 0x1f, 0x94, 0x43, 0x61, 0x09, 0xdf, 0x52, 0xb3, 0x45, 0xfa, 0x3a, 0x89, 0xac, 0x2a, + 0x49, 0xed, 0xc9, 0xd2, 0x85, 0xf2, 0x1f, 0x45, 0xed, 0x11, 0xd7, 0x75, 0xf7, 0xf7, + 0xf3, 0x9d, 0x3e, 0x8f, ], Core::FullRightShift8_4 => [ - 0x9d, 0x9d, 0x3f, 0x63, 0x8a, 0x84, 0x63, 0x86, 0xa2, 0x1e, 0x71, 0x5f, 0x39, 0x46, - 0x16, 0x86, 0x4a, 0x2e, 0xf7, 0x98, 0x4a, 0x88, 0xcd, 0x95, 0x50, 0x55, 0x66, 0x29, - 0x7b, 0xe7, 0xe0, 0x6c, + 0x71, 0x46, 0x98, 0xa2, 0x76, 0x84, 0xb5, 0xba, 0xa6, 0xb6, 0x48, 0x0e, 0xe3, 0xb2, + 0x57, 0xcb, 0xb7, 0xcd, 0xab, 0x74, 0x72, 0xf3, 0x71, 0xa6, 0x27, 0x06, 0x18, 0xc0, + 0xab, 0x12, 0x90, 0x8b, ], Core::FullSubtract16 => [ - 0x1f, 0xc8, 0x8e, 0x23, 0x29, 0xf4, 0xaa, 0xf1, 0x2b, 0x30, 0x51, 0x3f, 0x7a, 0x21, - 0xcf, 0x5d, 0x8d, 0xe2, 0x4b, 0x60, 0x0a, 0x19, 0xa2, 0x17, 0x41, 0x28, 0x1b, 0x4d, - 0x61, 0xaa, 0xc6, 0x33, + 0x40, 0x09, 0x61, 0x52, 0xb5, 0x4e, 0x74, 0x25, 0x45, 0x55, 0xa6, 0x5d, 0xcc, 0xc6, + 0x29, 0xdf, 0x57, 0xb9, 0x79, 0xc8, 0x47, 0x00, 0x54, 0x50, 0x36, 0xfe, 0x19, 0x0a, + 0x6a, 0xf3, 0xd3, 0x8a, ], Core::FullSubtract32 => [ - 0x78, 0x27, 0x05, 0xfb, 0x42, 0xe3, 0x6a, 0x7e, 0xf8, 0x31, 0x20, 0x0c, 0x61, 0x77, - 0x38, 0xd3, 0x1e, 0x13, 0xb1, 0xd0, 0xe7, 0xce, 0xed, 0x69, 0x3f, 0x13, 0x33, 0x88, - 0x35, 0xb3, 0x0a, 0xcb, + 0xe7, 0x93, 0x0d, 0x64, 0x35, 0xa9, 0x68, 0x0b, 0xef, 0xb4, 0x9d, 0xb7, 0xd8, 0x7c, + 0x2f, 0x50, 0xaf, 0xd4, 0x6d, 0x98, 0x88, 0x0d, 0xed, 0x50, 0xe5, 0x05, 0x5f, 0xa3, + 0x09, 0xe1, 0xaf, 0xca, ], Core::FullSubtract64 => [ - 0xb2, 0x85, 0x6a, 0x91, 0x80, 0x23, 0x1b, 0xee, 0x3c, 0xb8, 0x92, 0x30, 0xf7, 0x5c, - 0x29, 0x2a, 0xf3, 0xe7, 0x52, 0x39, 0xdb, 0xeb, 0x39, 0x65, 0x48, 0x44, 0x1e, 0x6b, - 0x5a, 0x27, 0xe8, 0x13, + 0xff, 0x28, 0x1d, 0xf8, 0xc4, 0x2a, 0x31, 0x59, 0xd9, 0xff, 0xa9, 0x25, 0x16, 0xca, + 0x89, 0x3e, 0x23, 0xb0, 0xeb, 0x93, 0x8b, 0x4c, 0xb0, 0xb3, 0xf1, 0x34, 0x46, 0x8e, + 0x9f, 0x4e, 0xbc, 0x46, ], Core::FullSubtract8 => [ - 0x68, 0x85, 0xe1, 0x41, 0xae, 0x23, 0x4c, 0x1e, 0x2a, 0x7e, 0x4f, 0x23, 0x52, 0x98, - 0x93, 0x90, 0x36, 0x96, 0x9c, 0x95, 0x0f, 0x2c, 0xef, 0xd4, 0x59, 0xb4, 0x98, 0xac, - 0x3d, 0xd8, 0x92, 0x20, + 0x7e, 0x3d, 0xcf, 0xe4, 0x56, 0xae, 0x3c, 0x5c, 0x87, 0xde, 0xbf, 0x04, 0x71, 0x89, + 0xc2, 0x74, 0x82, 0xa4, 0xff, 0x4e, 0x8c, 0xfd, 0x1f, 0x17, 0x30, 0xc8, 0x7d, 0x2b, + 0x7b, 0xff, 0x73, 0xba, ], Core::GeIsOnCurve => [ - 0x69, 0xf0, 0xe7, 0xa0, 0xc5, 0xff, 0xf8, 0x70, 0x84, 0xed, 0x69, 0x25, 0xf8, 0xdb, - 0x76, 0x2e, 0x41, 0x9e, 0x05, 0x7b, 0x96, 0x83, 0x4d, 0xce, 0x96, 0x99, 0xb0, 0xb0, - 0x09, 0x42, 0x30, 0x59, + 0x7d, 0x44, 0x87, 0x19, 0xf5, 0xf9, 0x57, 0x2b, 0xf5, 0x40, 0x2e, 0x12, 0xd1, 0x93, + 0xaf, 0xf6, 0x77, 0x48, 0x2d, 0x66, 0xff, 0x3d, 0xcf, 0x27, 0x48, 0xf2, 0x5c, 0x6b, + 0x73, 0x77, 0x02, 0x8c, ], Core::GeNegate => [ - 0x1e, 0xd0, 0xce, 0xd8, 0xdd, 0x25, 0x58, 0xe3, 0x48, 0x5f, 0x6f, 0xc3, 0x2d, 0x69, - 0xa2, 0x40, 0x5e, 0xca, 0xee, 0x31, 0x2d, 0xc4, 0xdc, 0x65, 0xe0, 0xfd, 0x34, 0x77, - 0x73, 0xf5, 0x98, 0x3d, + 0x3d, 0x2c, 0x8d, 0xe4, 0xc7, 0x01, 0x5f, 0xd3, 0x13, 0x26, 0x95, 0xfd, 0x66, 0xdf, + 0xcf, 0x0f, 0x17, 0x78, 0xc7, 0x91, 0x85, 0x26, 0x8e, 0x9f, 0xae, 0x77, 0x89, 0xda, + 0x53, 0x8e, 0xca, 0x59, ], Core::GejAdd => [ - 0x5a, 0x1c, 0x31, 0x03, 0x49, 0xe8, 0xff, 0x5c, 0x5a, 0x61, 0xac, 0x3e, 0x10, 0x12, - 0x3f, 0x74, 0xe8, 0x7f, 0xab, 0xa1, 0x4c, 0x78, 0xbc, 0x83, 0xf9, 0xe3, 0x41, 0x36, - 0x87, 0xec, 0xf2, 0x8b, + 0x45, 0xba, 0x7f, 0x3d, 0x1e, 0x1e, 0x6d, 0x34, 0x9f, 0xcf, 0x86, 0x98, 0x7b, 0x0e, + 0x7f, 0x7a, 0xce, 0x66, 0x2e, 0x82, 0x20, 0x1d, 0x35, 0x02, 0x60, 0x45, 0x4e, 0x2f, + 0xfe, 0xec, 0xb5, 0x4d, ], Core::GejDouble => [ - 0x1e, 0xdd, 0x05, 0x82, 0xe2, 0xfc, 0xad, 0x99, 0xb1, 0x2d, 0x50, 0x6d, 0x29, 0xb5, - 0x0a, 0x63, 0x01, 0x7f, 0x67, 0x69, 0x28, 0xbe, 0x51, 0x13, 0x69, 0x00, 0x6e, 0x07, - 0xcb, 0x80, 0xd9, 0x82, + 0x23, 0xe9, 0x78, 0xf3, 0x41, 0x54, 0x11, 0x9b, 0xde, 0xfc, 0x5d, 0x13, 0xfc, 0xfd, + 0x0a, 0x34, 0xa7, 0x5e, 0x37, 0x26, 0xd6, 0xcb, 0x25, 0x81, 0x33, 0x70, 0xad, 0x7d, + 0x9d, 0xe5, 0xe1, 0x33, ], Core::GejEquiv => [ - 0x02, 0x74, 0x71, 0x05, 0x94, 0x87, 0xa1, 0x2c, 0xa2, 0x07, 0xf0, 0x94, 0x05, 0x94, - 0xd6, 0xcd, 0x87, 0xfc, 0x93, 0x0a, 0x8b, 0x5b, 0x31, 0x43, 0x4a, 0x16, 0xa2, 0xd6, - 0x7f, 0x1d, 0x8d, 0xd4, + 0xb9, 0x4b, 0x2a, 0xac, 0x73, 0xa6, 0x7f, 0x44, 0x95, 0x85, 0x99, 0x13, 0x4d, 0xe2, + 0x30, 0x17, 0x9e, 0x9d, 0x6b, 0xb6, 0x47, 0xfd, 0x06, 0x11, 0x15, 0x8a, 0xab, 0xa7, + 0x0b, 0x73, 0xe4, 0x00, ], Core::GejGeAdd => [ - 0x1e, 0xa7, 0x10, 0xd5, 0x6e, 0xaf, 0xee, 0x32, 0x5d, 0x26, 0x07, 0xdd, 0xb4, 0x5f, - 0xf0, 0x17, 0x0a, 0xde, 0xc2, 0xe0, 0xee, 0x9b, 0xcc, 0x68, 0xe4, 0xb9, 0x3e, 0x1d, - 0xe6, 0xad, 0x35, 0x68, + 0xf1, 0x16, 0x0b, 0x6f, 0x5e, 0xe2, 0xc5, 0x82, 0xe4, 0x95, 0x66, 0xe6, 0xc3, 0x86, + 0xb3, 0x80, 0x94, 0xab, 0xc1, 0xa7, 0x18, 0x2d, 0x33, 0xa1, 0x50, 0x1f, 0xa2, 0xaa, + 0xf0, 0x0a, 0xf3, 0xea, ], Core::GejGeAddEx => [ - 0x78, 0xf0, 0x87, 0x1b, 0x81, 0x73, 0xab, 0xde, 0x71, 0x87, 0x11, 0x26, 0x3b, 0x3a, - 0xc1, 0xd9, 0x22, 0x33, 0x7e, 0xd5, 0xed, 0x13, 0x8d, 0x29, 0x49, 0x62, 0xd6, 0x5c, - 0xe5, 0x59, 0xbd, 0x92, + 0xc3, 0xd7, 0x34, 0x7f, 0xfe, 0x2d, 0x9c, 0x83, 0x9a, 0xac, 0x56, 0x7e, 0x29, 0x98, + 0xe0, 0x16, 0xaf, 0x39, 0x4e, 0x2a, 0x19, 0x29, 0x31, 0x4b, 0x52, 0xe3, 0x1e, 0xed, + 0x67, 0x8e, 0x30, 0xbf, ], Core::GejGeEquiv => [ - 0xba, 0x89, 0x9a, 0x00, 0x62, 0x16, 0xd1, 0xc9, 0x3b, 0xd5, 0xec, 0xbe, 0x00, 0x80, - 0xd9, 0x07, 0x8a, 0x50, 0x0a, 0x72, 0x9b, 0xbd, 0x39, 0x6a, 0x00, 0x4a, 0xf5, 0x1d, - 0x4f, 0xf7, 0xd9, 0x3a, + 0x27, 0xc2, 0x99, 0x69, 0x13, 0x9f, 0x8d, 0x57, 0xed, 0xc9, 0x89, 0x5c, 0x30, 0x40, + 0x3d, 0xf0, 0x15, 0xc5, 0x0c, 0xe7, 0x21, 0xc3, 0x81, 0xfb, 0x19, 0x7c, 0x0c, 0x04, + 0x03, 0xf1, 0xdb, 0x0c, ], Core::GejInfinity => [ - 0x88, 0xa9, 0x52, 0xdb, 0x38, 0x16, 0xe9, 0x42, 0x59, 0xa6, 0x75, 0x37, 0xfa, 0x8f, - 0xca, 0x1a, 0x35, 0xa9, 0x07, 0xa8, 0x6f, 0x51, 0xed, 0xe4, 0x51, 0xfd, 0x32, 0xec, - 0x25, 0x3d, 0x9c, 0x62, + 0xaa, 0xfb, 0x93, 0x80, 0xd6, 0x1a, 0x7f, 0x14, 0x78, 0x46, 0x80, 0x6b, 0x2c, 0xc3, + 0x74, 0xfb, 0xe8, 0x2d, 0xd1, 0xae, 0xd4, 0x85, 0xb9, 0x8a, 0x0f, 0x16, 0x4b, 0x3a, + 0x54, 0xc2, 0xc0, 0xb0, ], Core::GejIsInfinity => [ - 0x29, 0x80, 0xa7, 0x35, 0x41, 0x4e, 0x43, 0x21, 0xaf, 0xef, 0xfe, 0xfa, 0x88, 0x37, - 0xed, 0xb0, 0xa3, 0x30, 0x9a, 0x33, 0x7d, 0x59, 0xb7, 0xbd, 0xea, 0x92, 0x1c, 0x13, - 0x05, 0x6b, 0x04, 0x28, + 0xdb, 0x49, 0x5f, 0xd1, 0x31, 0x42, 0xe9, 0xb3, 0x37, 0x63, 0xfc, 0x6d, 0x48, 0xd2, + 0xfb, 0x0e, 0x71, 0xb0, 0xd9, 0xd9, 0x9b, 0xd7, 0x26, 0xf4, 0x7a, 0xd1, 0x3f, 0xc5, + 0x56, 0x06, 0x70, 0xa2, ], Core::GejIsOnCurve => [ - 0x01, 0x87, 0xe1, 0xe5, 0xef, 0x76, 0x34, 0xa5, 0xf0, 0x16, 0x12, 0x4d, 0x4f, 0xeb, - 0x5a, 0x93, 0xdd, 0xe6, 0xaa, 0x78, 0x17, 0x6c, 0xda, 0x48, 0xb1, 0x65, 0xa9, 0xaa, - 0x8e, 0x04, 0x49, 0xf2, + 0xbf, 0x4c, 0xa1, 0x3f, 0xf2, 0x12, 0xe3, 0x4b, 0xf1, 0x7d, 0x90, 0xc1, 0x2e, 0x45, + 0x3d, 0x08, 0xac, 0x7d, 0xaa, 0x4a, 0x47, 0xd5, 0x7e, 0x85, 0xb4, 0x3f, 0x2d, 0x43, + 0x66, 0xd4, 0x3d, 0xda, ], Core::GejNegate => [ - 0xb3, 0x2c, 0x74, 0xca, 0xb2, 0xc7, 0x50, 0x0b, 0x73, 0xf8, 0xec, 0x05, 0x60, 0xfe, - 0x23, 0xfc, 0x4c, 0x21, 0xaa, 0x66, 0x59, 0x6d, 0x7f, 0x2a, 0xcf, 0x49, 0x67, 0x88, - 0x6b, 0x76, 0xd8, 0x56, + 0x01, 0xbd, 0x1a, 0x35, 0x1f, 0xb8, 0x16, 0x4c, 0x81, 0x3d, 0x91, 0x6d, 0x07, 0x77, + 0x49, 0x99, 0x6b, 0x7d, 0xb1, 0x18, 0xd3, 0x15, 0x86, 0xca, 0x9d, 0x75, 0xe7, 0x56, + 0x35, 0x18, 0xf4, 0x54, ], Core::GejNormalize => [ - 0x5d, 0xe0, 0x97, 0x6a, 0xe7, 0xf3, 0x8b, 0x36, 0xf0, 0x02, 0x28, 0x14, 0x96, 0x6d, - 0xb2, 0xba, 0xed, 0x5c, 0x47, 0x67, 0x14, 0x94, 0x4d, 0x74, 0x1a, 0x89, 0x79, 0xc4, - 0xbc, 0xf8, 0xbe, 0x25, + 0xec, 0x59, 0x7d, 0x17, 0xe2, 0xef, 0xb6, 0xd2, 0xa0, 0x02, 0xd5, 0x0e, 0x67, 0x75, + 0x27, 0xd3, 0xd4, 0xa2, 0x90, 0x7a, 0x11, 0x9d, 0x68, 0xf1, 0x22, 0x84, 0xb9, 0xa1, + 0xb0, 0xd2, 0x30, 0x3a, ], Core::GejRescale => [ - 0xdc, 0xfc, 0x72, 0xa7, 0x68, 0xd5, 0xbe, 0x77, 0x0f, 0x8d, 0xb2, 0x78, 0xae, 0xaf, - 0xd1, 0x8e, 0x27, 0x70, 0x4c, 0x64, 0xf8, 0xb4, 0x0f, 0xa6, 0xfe, 0x54, 0xca, 0x94, - 0x72, 0x7a, 0x07, 0x6e, + 0x29, 0x77, 0xd9, 0x53, 0xef, 0x7a, 0x11, 0x56, 0xce, 0xc6, 0xdb, 0x2d, 0xc2, 0x92, + 0x54, 0x12, 0x75, 0xcb, 0xc8, 0x2f, 0xb8, 0x29, 0xfd, 0x67, 0x1b, 0x97, 0x2e, 0x89, + 0xeb, 0xed, 0x0c, 0x24, ], Core::GejXEquiv => [ - 0x52, 0xcc, 0x21, 0x47, 0x09, 0xc0, 0xd9, 0xfc, 0xa9, 0xdb, 0x1d, 0x09, 0xcc, 0x80, - 0x7c, 0x75, 0xcf, 0x5a, 0x63, 0x13, 0xca, 0x54, 0x0a, 0x77, 0x2d, 0x4e, 0xa9, 0x92, - 0x1f, 0x37, 0xe6, 0x24, + 0xf9, 0xf1, 0x89, 0xfc, 0x00, 0xb6, 0x1f, 0x72, 0xf1, 0x0b, 0xaa, 0xa2, 0x1b, 0xcd, + 0x88, 0xe5, 0xd2, 0x2e, 0x0a, 0xa9, 0xb7, 0x50, 0x9a, 0xe1, 0x62, 0xa1, 0x83, 0xa4, + 0xb6, 0x64, 0xa4, 0xaf, ], Core::GejYIsOdd => [ - 0xfe, 0x01, 0x06, 0xaf, 0xb9, 0xd9, 0xe2, 0x4f, 0xd4, 0xdb, 0xe5, 0x45, 0x11, 0xfe, - 0x27, 0x2f, 0x4d, 0xcb, 0x30, 0x7a, 0x0e, 0xa5, 0x6d, 0x59, 0x1c, 0xeb, 0x93, 0xab, - 0x4b, 0xf8, 0x87, 0x45, + 0x9e, 0xb6, 0xe4, 0x53, 0x5f, 0xb6, 0x9b, 0xf6, 0x09, 0x91, 0x65, 0x99, 0xf1, 0x34, + 0x5a, 0xd7, 0x73, 0x5d, 0xa3, 0xf3, 0x94, 0x8d, 0x06, 0x86, 0x90, 0x8e, 0x44, 0xf4, + 0x5b, 0x2f, 0xf6, 0x0c, ], Core::Generate => [ - 0xdf, 0x44, 0xe1, 0x7d, 0x2a, 0x55, 0x9d, 0xd0, 0xa7, 0x03, 0x49, 0x54, 0xab, 0x33, - 0x37, 0x77, 0x78, 0xb1, 0x51, 0xf1, 0xcd, 0x1e, 0x4f, 0x9f, 0xd3, 0x1b, 0x36, 0x1d, - 0x34, 0xa8, 0xd9, 0x73, + 0x14, 0x88, 0x85, 0xac, 0x73, 0x81, 0x31, 0x13, 0xc5, 0x23, 0xe8, 0x09, 0xbe, 0xa4, + 0x7f, 0xfd, 0x8b, 0x1d, 0xaf, 0x37, 0x8d, 0x9d, 0xd5, 0x4b, 0xf9, 0x66, 0xcc, 0xb8, + 0x83, 0xb1, 0xa9, 0x84, ], Core::HashToCurve => [ - 0x76, 0xf7, 0xca, 0x1d, 0xb9, 0x44, 0xee, 0x31, 0x5e, 0xd3, 0x62, 0xfe, 0xe0, 0x67, - 0x3c, 0x58, 0x94, 0xf8, 0x85, 0x3b, 0x44, 0x60, 0x70, 0x90, 0x1b, 0x85, 0x79, 0x01, - 0xf9, 0x49, 0x9d, 0x9b, + 0xef, 0x4f, 0x54, 0x8b, 0x3c, 0x6c, 0x75, 0x17, 0x5f, 0x2c, 0xe2, 0xd1, 0x99, 0x3b, + 0x2d, 0x19, 0x9b, 0xeb, 0x16, 0xc0, 0xa1, 0x40, 0x17, 0x5c, 0x48, 0xa1, 0x27, 0x7e, + 0xfc, 0x43, 0xa9, 0x9b, ], Core::High1 => [ - 0xc3, 0x2d, 0x87, 0x7e, 0x67, 0x0d, 0x6c, 0x03, 0x7c, 0xb3, 0x35, 0x33, 0x28, 0x9e, - 0x19, 0xa7, 0x24, 0xc3, 0x68, 0xaa, 0x75, 0x51, 0xda, 0xa6, 0xd2, 0xda, 0xcc, 0xcd, - 0x8c, 0x95, 0xf4, 0xd0, + 0xb1, 0x09, 0xcf, 0x1c, 0xce, 0x35, 0xf7, 0xe9, 0xb6, 0x49, 0x67, 0x1a, 0x9b, 0x45, + 0xdb, 0xc2, 0x40, 0x99, 0xa7, 0x13, 0xae, 0xb9, 0xa8, 0x9c, 0xc4, 0xcf, 0x6e, 0xf6, + 0xed, 0x8b, 0x30, 0x8b, ], Core::High16 => [ - 0x41, 0x64, 0xab, 0x6e, 0x2f, 0xf8, 0xee, 0xf6, 0x3c, 0x06, 0xc0, 0x80, 0xf1, 0xde, - 0xc6, 0x97, 0x0b, 0x4c, 0x5c, 0x31, 0xc0, 0x23, 0x05, 0xab, 0xcc, 0xd8, 0xed, 0x2c, - 0x5e, 0x1c, 0x45, 0xce, + 0x03, 0x5d, 0xad, 0xd9, 0xd7, 0xbf, 0x74, 0x33, 0x64, 0x45, 0xe7, 0x1d, 0xdc, 0x4d, + 0x82, 0x02, 0x24, 0xff, 0x7e, 0x38, 0xe0, 0xb8, 0xd5, 0x2b, 0xec, 0x97, 0x29, 0xb5, + 0x72, 0xb5, 0x31, 0xf9, ], Core::High32 => [ - 0xd3, 0xa7, 0xce, 0x9c, 0xd5, 0xd5, 0xfb, 0x67, 0x9a, 0x98, 0xef, 0x57, 0xb8, 0x63, - 0x22, 0x77, 0x0c, 0xb6, 0x6f, 0xb6, 0xf0, 0x61, 0x6e, 0x16, 0x34, 0xcf, 0xa8, 0x4c, - 0x8f, 0x68, 0x09, 0xc6, + 0xc5, 0xf1, 0xdf, 0x0d, 0x64, 0xa2, 0x73, 0x7a, 0x63, 0x1b, 0x3a, 0xae, 0x8f, 0x26, + 0x0e, 0x8b, 0x8d, 0xc1, 0x95, 0x7b, 0xd0, 0x92, 0x91, 0x1b, 0x91, 0xd2, 0x07, 0x8a, + 0xd2, 0x1e, 0x41, 0x8a, ], Core::High64 => [ - 0x4a, 0xf9, 0x1f, 0xaf, 0x8e, 0x39, 0xf4, 0xda, 0x7c, 0x28, 0xa8, 0x79, 0x65, 0x94, - 0xa9, 0x22, 0x82, 0x13, 0xd7, 0x32, 0x3e, 0xea, 0x2c, 0xa6, 0x30, 0x75, 0x2c, 0xe4, - 0xc5, 0x7f, 0x16, 0xe1, + 0xa3, 0x12, 0x63, 0x3e, 0x0a, 0x23, 0x05, 0xe6, 0x9b, 0x3f, 0x34, 0x1d, 0x91, 0xd6, + 0x83, 0xdd, 0x94, 0x19, 0x6a, 0x2f, 0x90, 0x05, 0xc9, 0xb1, 0x87, 0x2a, 0x2c, 0x15, + 0xad, 0x46, 0xcf, 0x17, ], Core::High8 => [ 0xcb, 0xd7, 0x8d, 0x50, 0xaf, 0x77, 0x99, 0x85, 0x5a, 0xdc, 0x49, 0x03, 0xdb, 0xbe, @@ -1460,834 +1467,834 @@ impl Jet for Core { 0xa9, 0x7d, 0x4a, 0x14, ], Core::Increment16 => [ - 0xdf, 0x27, 0x48, 0x88, 0xce, 0x4c, 0xeb, 0xdd, 0x57, 0x08, 0xb3, 0x8d, 0xc3, 0xdb, - 0xb1, 0x9c, 0xc2, 0xf0, 0x36, 0x4b, 0x24, 0x63, 0xe9, 0x9c, 0xf5, 0xaa, 0xb4, 0xf8, - 0xa2, 0x3e, 0xa5, 0x8a, + 0x86, 0x77, 0x49, 0x49, 0x39, 0xb2, 0x7b, 0x86, 0xcb, 0x5a, 0x8c, 0x7f, 0x81, 0x72, + 0xad, 0x55, 0x50, 0x95, 0x31, 0xc9, 0xb0, 0xe1, 0x1e, 0x99, 0x75, 0x7e, 0x29, 0x6c, + 0xc3, 0xc7, 0xc1, 0x92, ], Core::Increment32 => [ - 0x54, 0xf7, 0x57, 0xae, 0xa7, 0x6b, 0xc7, 0xa3, 0x9f, 0xc4, 0x3d, 0x19, 0xb8, 0xdd, - 0x56, 0x3a, 0x68, 0x07, 0xdf, 0x02, 0x77, 0xa5, 0x6f, 0xcb, 0x50, 0x10, 0x89, 0xce, - 0x7d, 0x06, 0x77, 0x4c, + 0x6b, 0xdb, 0xab, 0x7c, 0xfc, 0x16, 0xc5, 0x03, 0x36, 0x3c, 0x2f, 0x07, 0x7e, 0x02, + 0xc3, 0x35, 0xda, 0x40, 0x61, 0x75, 0xd1, 0x92, 0xfb, 0xef, 0x50, 0xc0, 0x7f, 0xc2, + 0x79, 0xb3, 0xf4, 0x0c, ], Core::Increment64 => [ - 0x79, 0xed, 0x5f, 0x77, 0x99, 0xfb, 0x09, 0xda, 0x51, 0x04, 0x29, 0xa2, 0x01, 0x28, - 0xbe, 0xd0, 0x91, 0xd8, 0x58, 0x76, 0x47, 0x07, 0x12, 0x85, 0xcd, 0xec, 0x3a, 0x0c, - 0x95, 0x70, 0x9e, 0x5b, + 0x20, 0xe7, 0x5e, 0x71, 0x7c, 0xb7, 0x6d, 0x46, 0x95, 0x56, 0x4f, 0x7c, 0x20, 0x22, + 0x1b, 0x7a, 0x01, 0x43, 0x13, 0x87, 0x38, 0xf1, 0x51, 0xaa, 0x19, 0x5e, 0xb1, 0x70, + 0xec, 0x13, 0xc0, 0x49, ], Core::Increment8 => [ - 0x0c, 0x71, 0x7e, 0x84, 0xdf, 0x67, 0x82, 0x3f, 0x57, 0x41, 0xb3, 0xd5, 0x5d, 0xbe, - 0xb4, 0x72, 0x9c, 0x2b, 0xd6, 0x2f, 0x5d, 0x1d, 0xef, 0x3c, 0xab, 0xcc, 0xdd, 0x6c, - 0xb8, 0xdc, 0xb5, 0x6c, + 0x5f, 0x4e, 0x05, 0x6e, 0xf4, 0xed, 0x8d, 0x68, 0xbf, 0x91, 0x1f, 0xc5, 0xcb, 0x69, + 0x03, 0x7e, 0xbf, 0x6c, 0x92, 0x21, 0x73, 0x43, 0xa8, 0x90, 0x5d, 0x38, 0xc4, 0x32, + 0xc1, 0x83, 0x23, 0x3c, ], Core::IsOne16 => [ - 0x84, 0x35, 0x87, 0x9c, 0xcb, 0x86, 0x44, 0x19, 0x8d, 0xcb, 0x9a, 0x0c, 0xd7, 0x35, - 0x46, 0xd7, 0x01, 0xfd, 0xd5, 0xa4, 0xc4, 0x43, 0x23, 0xf5, 0x63, 0x97, 0x15, 0x99, - 0xc3, 0x7d, 0x16, 0xfb, + 0x1b, 0xd3, 0xa2, 0x53, 0xdb, 0x24, 0x3f, 0xca, 0x45, 0x53, 0x37, 0x99, 0xfe, 0x91, + 0x48, 0x38, 0xc3, 0x8e, 0x38, 0x06, 0xb1, 0x2b, 0xd7, 0xe8, 0x5c, 0xa7, 0x12, 0x07, + 0xa8, 0x84, 0x62, 0xb0, ], Core::IsOne32 => [ - 0xdd, 0xfb, 0xd9, 0xf0, 0xa2, 0xe6, 0x7c, 0x07, 0xde, 0xdb, 0x89, 0xe8, 0x96, 0xb6, - 0xc4, 0xf7, 0xd4, 0x5c, 0x51, 0x47, 0xee, 0xd0, 0x61, 0x4e, 0x4c, 0xe7, 0xd0, 0x87, - 0x69, 0xaf, 0xf8, 0x2d, + 0x78, 0xb1, 0xba, 0xe0, 0x99, 0xec, 0x9c, 0x59, 0xcb, 0xf4, 0x12, 0x62, 0x51, 0xc1, + 0xe9, 0x67, 0x41, 0xb3, 0x50, 0xd5, 0x63, 0xbd, 0x74, 0xd5, 0x44, 0x18, 0xba, 0x78, + 0xeb, 0xea, 0x25, 0xbf, ], Core::IsOne64 => [ - 0x35, 0xc5, 0x25, 0x54, 0x8e, 0x48, 0xee, 0xa0, 0xf7, 0x7b, 0x3b, 0xf9, 0x7a, 0xb6, - 0x7a, 0x1f, 0xfe, 0x8f, 0xb0, 0x94, 0xed, 0xe3, 0x32, 0x5e, 0x40, 0x64, 0xb1, 0x65, - 0x9c, 0x6d, 0x07, 0x65, + 0x81, 0x7b, 0x95, 0xa5, 0x39, 0x5e, 0xfb, 0xec, 0xbb, 0x85, 0x15, 0xa5, 0x5b, 0x3f, + 0xfe, 0x1a, 0x4d, 0x7b, 0xac, 0x6e, 0x23, 0xdb, 0xca, 0x54, 0xad, 0x60, 0x66, 0x66, + 0x2f, 0x20, 0x2b, 0x93, ], Core::IsOne8 => [ - 0x0a, 0xba, 0x9e, 0x57, 0x6e, 0x64, 0xd2, 0x80, 0x4c, 0x8a, 0xc4, 0x68, 0x2b, 0xbb, - 0xa5, 0x39, 0x0e, 0xbc, 0x31, 0xa6, 0xe3, 0xe2, 0x65, 0x0f, 0x92, 0x19, 0x23, 0x5d, - 0xf4, 0xa6, 0xec, 0xbb, + 0xf6, 0x92, 0x54, 0x91, 0xd3, 0x4b, 0x37, 0x74, 0x2c, 0xb0, 0x8d, 0xec, 0x19, 0x3e, + 0xe5, 0x12, 0x5f, 0x93, 0x3c, 0xad, 0xcc, 0x23, 0x2a, 0xed, 0xee, 0xdb, 0x57, 0x2d, + 0x12, 0x60, 0xff, 0xd5, ], Core::IsZero16 => [ - 0xa2, 0x5a, 0xbd, 0x9c, 0xd2, 0xa4, 0x07, 0x0c, 0x74, 0x2e, 0xf8, 0xde, 0xb0, 0x68, - 0x29, 0x22, 0x46, 0x03, 0x2b, 0x96, 0xa5, 0x17, 0x22, 0x3b, 0x12, 0x8c, 0xfc, 0x12, - 0xd2, 0x15, 0xc5, 0xba, + 0x1b, 0xa7, 0x21, 0x3b, 0x58, 0x8b, 0xe0, 0x92, 0xb4, 0x46, 0x59, 0x9c, 0x2a, 0x60, + 0xff, 0x54, 0x67, 0x13, 0x6a, 0x79, 0x75, 0x99, 0x61, 0x0b, 0xd7, 0xa5, 0xf1, 0x78, + 0x04, 0xe3, 0x2a, 0x2c, ], Core::IsZero32 => [ - 0x61, 0x2a, 0x48, 0x0c, 0xed, 0x6a, 0x79, 0xda, 0x61, 0x19, 0x54, 0x6e, 0x05, 0x6b, - 0x8d, 0xf9, 0xfa, 0x95, 0xd1, 0x12, 0x4b, 0x96, 0xd6, 0x01, 0xe1, 0xd3, 0xea, 0x91, - 0x8c, 0xc5, 0x60, 0x69, + 0x5e, 0xbf, 0x14, 0x66, 0x93, 0xf0, 0xe2, 0xd2, 0xf9, 0x36, 0x1b, 0x47, 0x6d, 0xba, + 0x34, 0x85, 0x8b, 0x83, 0x2d, 0x66, 0xfa, 0xcf, 0x71, 0x3b, 0xfb, 0x32, 0xc3, 0xbb, + 0x8d, 0xb9, 0xee, 0xbf, ], Core::IsZero64 => [ - 0x18, 0xe8, 0xe1, 0x77, 0x6b, 0xa0, 0x80, 0xcc, 0xd3, 0xe1, 0xd6, 0x0c, 0xb7, 0x53, - 0x41, 0x45, 0x36, 0xbf, 0x70, 0xdf, 0x18, 0x5f, 0x72, 0xc9, 0xe0, 0x70, 0x79, 0x6f, - 0x4c, 0x63, 0xcc, 0x71, + 0x19, 0xab, 0x9a, 0xc0, 0xcf, 0x42, 0x66, 0x82, 0x19, 0xba, 0x6c, 0xb8, 0x97, 0xe4, + 0x87, 0xfe, 0x36, 0x80, 0x93, 0x7f, 0xff, 0xa8, 0xd2, 0x03, 0x51, 0x1d, 0xb7, 0x5d, + 0xbb, 0x10, 0xc7, 0xe5, ], Core::IsZero8 => [ - 0xb4, 0xba, 0xa5, 0x09, 0x38, 0x10, 0x84, 0x26, 0x74, 0x0d, 0x82, 0xcf, 0x12, 0x11, - 0xe0, 0xed, 0x12, 0x6d, 0xe3, 0xb7, 0x6b, 0x8d, 0x25, 0x9c, 0x50, 0xad, 0x4b, 0x8f, - 0xca, 0xb1, 0x0a, 0xb6, + 0x8e, 0xff, 0x62, 0x08, 0x44, 0x07, 0xe9, 0xaf, 0xd5, 0x40, 0xf3, 0x18, 0xf6, 0x6b, + 0xcf, 0x31, 0xdf, 0x1d, 0x42, 0xa5, 0xc1, 0x61, 0xca, 0xe3, 0x5a, 0x29, 0x48, 0x18, + 0x0c, 0xa2, 0xaa, 0x2e, ], Core::Le16 => [ - 0x63, 0xda, 0x72, 0x7c, 0xcb, 0x4c, 0x6a, 0x9d, 0x4e, 0x00, 0x09, 0x64, 0xe7, 0x63, - 0xbf, 0xf9, 0x34, 0xea, 0xaf, 0xd0, 0x44, 0x28, 0x7e, 0x12, 0x68, 0xd0, 0x7e, 0xcd, - 0xfd, 0xe2, 0x07, 0xe1, + 0x01, 0x67, 0x05, 0xa7, 0xd7, 0xdc, 0xe1, 0xaf, 0xc6, 0x3e, 0xab, 0x84, 0x20, 0x3f, + 0x5f, 0x42, 0xd6, 0xb6, 0xbb, 0xad, 0x75, 0xce, 0xe3, 0x8c, 0xec, 0x5a, 0x51, 0x5b, + 0x59, 0x97, 0x48, 0x9f, ], Core::Le32 => [ - 0xde, 0xe2, 0x9a, 0x91, 0x65, 0x6d, 0x7a, 0xe7, 0x3d, 0xf4, 0x95, 0x6f, 0xd8, 0xa2, - 0xc6, 0xb6, 0x27, 0xaa, 0xb5, 0x1c, 0x11, 0x29, 0xf9, 0xfe, 0x7f, 0x6e, 0xd3, 0xe3, - 0x47, 0x92, 0xc7, 0x62, + 0x53, 0x51, 0xfc, 0x5d, 0xeb, 0xe5, 0xb2, 0x98, 0xad, 0x70, 0x57, 0xe4, 0xa5, 0xa7, + 0x6a, 0x3b, 0x9c, 0x65, 0x8a, 0xcd, 0xe7, 0xd1, 0xbb, 0x52, 0xe5, 0x88, 0x9c, 0xa1, + 0xe3, 0x8f, 0x5e, 0xfb, ], Core::Le64 => [ - 0x01, 0xc5, 0x5d, 0xf7, 0xd4, 0x46, 0x59, 0x66, 0x65, 0x9d, 0xdf, 0xc9, 0x4b, 0x36, - 0xd0, 0x33, 0x24, 0x2c, 0x2e, 0xc5, 0x93, 0xce, 0xe1, 0x21, 0x22, 0x44, 0x07, 0x75, - 0x66, 0xed, 0x01, 0x5f, + 0xae, 0x2d, 0xe1, 0xe0, 0xcf, 0x73, 0x0d, 0x1d, 0xcc, 0x96, 0xd7, 0xcc, 0xfe, 0x71, + 0x16, 0x8a, 0x24, 0x0d, 0xea, 0xf8, 0x04, 0x61, 0x5a, 0x7b, 0xa9, 0x20, 0xdc, 0x16, + 0xfd, 0x6e, 0xa4, 0x5f, ], Core::Le8 => [ - 0x0f, 0xb7, 0x2d, 0x9f, 0x8e, 0xe2, 0x37, 0x0a, 0xba, 0x55, 0x66, 0x3a, 0x48, 0x99, - 0x16, 0x2e, 0x40, 0xca, 0x55, 0x14, 0x71, 0x3e, 0xfb, 0x25, 0xe4, 0xa8, 0x9e, 0x2a, - 0x10, 0x4b, 0x34, 0xdb, + 0xaf, 0x29, 0xf6, 0x16, 0x8e, 0xbd, 0xc0, 0x9e, 0xfb, 0xe0, 0xe6, 0x39, 0xcb, 0x75, + 0x0b, 0x12, 0x05, 0x78, 0x8f, 0x90, 0x21, 0xd6, 0x66, 0xef, 0xce, 0xfe, 0x13, 0xf1, + 0x2f, 0x96, 0x71, 0xf0, ], Core::LeftExtend16_32 => [ - 0xdc, 0xf4, 0x2b, 0x65, 0x42, 0xf6, 0xd4, 0x1c, 0xb7, 0xb5, 0x0e, 0x7c, 0x77, 0x2f, - 0x3c, 0x7f, 0x6e, 0x43, 0x22, 0x32, 0xf2, 0xba, 0x20, 0x79, 0xb3, 0x86, 0xa0, 0x5d, - 0x7b, 0x46, 0x6a, 0xdd, + 0x28, 0x99, 0x97, 0xfb, 0xa1, 0xfa, 0xe7, 0xec, 0x1c, 0x45, 0x31, 0xc5, 0x0b, 0xbf, + 0x86, 0x71, 0xb8, 0x97, 0x13, 0x9b, 0xdd, 0x3a, 0xad, 0x97, 0xa3, 0x76, 0x39, 0x57, + 0x4a, 0x04, 0x7c, 0x80, ], Core::LeftExtend16_64 => [ - 0x2e, 0xee, 0x48, 0xa9, 0x22, 0x37, 0x94, 0x7c, 0x1a, 0x51, 0x7d, 0xf9, 0x95, 0xf4, - 0x4f, 0x1d, 0xfe, 0xf2, 0x0d, 0xdb, 0x4e, 0x9b, 0x53, 0x0b, 0x22, 0xd1, 0x8a, 0x0a, - 0x7f, 0xd6, 0x28, 0xaa, + 0x5d, 0xff, 0x21, 0xf6, 0xe6, 0x12, 0x47, 0x75, 0xc5, 0x78, 0xea, 0xf4, 0x85, 0x5c, + 0x0b, 0x01, 0x64, 0xf7, 0x87, 0x9b, 0x17, 0x60, 0xf9, 0x02, 0x7c, 0xb5, 0x0f, 0x7b, + 0x5a, 0xcb, 0x49, 0x18, ], Core::LeftExtend1_16 => [ - 0x9a, 0x48, 0xa4, 0x77, 0x8e, 0x7c, 0x3c, 0x28, 0x5a, 0xb6, 0x53, 0x29, 0xd1, 0xcc, - 0xc4, 0x99, 0x9d, 0x2d, 0x19, 0x4e, 0x00, 0x5b, 0xd7, 0x94, 0x69, 0x49, 0x53, 0x3d, - 0x8c, 0xba, 0x80, 0x6c, + 0x8c, 0x87, 0xd7, 0x56, 0xd1, 0x4b, 0xd3, 0xd9, 0xa7, 0x86, 0x90, 0x81, 0x29, 0x12, + 0xb8, 0x94, 0x29, 0xc0, 0x17, 0x1a, 0x41, 0x10, 0x3a, 0x58, 0xc6, 0xe9, 0xf2, 0x25, + 0x14, 0x1a, 0x02, 0x22, ], Core::LeftExtend1_32 => [ - 0xda, 0xb6, 0xa5, 0x33, 0xcb, 0xcb, 0xe8, 0x36, 0x2c, 0xf1, 0xd5, 0xa1, 0x6e, 0xa3, - 0x7c, 0xbc, 0x7e, 0xdc, 0x7f, 0xc8, 0xa9, 0x42, 0x85, 0x71, 0xe1, 0x71, 0xec, 0x6e, - 0xe4, 0x4d, 0x08, 0x00, + 0xc8, 0xf1, 0x54, 0xd4, 0x6d, 0x2e, 0x78, 0x95, 0xda, 0x1b, 0x33, 0xc2, 0xb3, 0x15, + 0xe6, 0xd4, 0xd4, 0x85, 0x1d, 0xde, 0xe2, 0x8a, 0xef, 0x8b, 0x70, 0x70, 0x90, 0x61, + 0x6b, 0xc7, 0xee, 0xa0, ], Core::LeftExtend1_64 => [ - 0x11, 0x0e, 0x5c, 0x1e, 0xf0, 0xb4, 0x69, 0xa7, 0x63, 0x85, 0x70, 0xda, 0x94, 0x4d, - 0x23, 0x2e, 0x0f, 0x28, 0xc4, 0x61, 0x51, 0xa2, 0x25, 0x35, 0x7d, 0xe3, 0xe9, 0x04, - 0x57, 0xa8, 0x8e, 0xa2, + 0xa3, 0x40, 0x4d, 0xf6, 0x8c, 0xc9, 0x20, 0x75, 0x4c, 0x6e, 0x18, 0x47, 0x20, 0x7d, + 0xb3, 0x84, 0x5d, 0x11, 0xc7, 0x49, 0x09, 0xd0, 0x7c, 0xa8, 0x2a, 0xd1, 0xf1, 0xcc, + 0x67, 0xbf, 0x3a, 0x9b, ], Core::LeftExtend1_8 => [ - 0x5a, 0x83, 0x1c, 0xa9, 0x96, 0x21, 0x51, 0x7a, 0x2b, 0x35, 0x4e, 0x5c, 0xac, 0x38, - 0xbc, 0x3a, 0x30, 0xc4, 0x00, 0x1f, 0x20, 0xd2, 0x5d, 0x77, 0x97, 0xad, 0xdc, 0xac, - 0x5d, 0xa8, 0x61, 0x06, + 0x3b, 0xca, 0x33, 0x97, 0xb8, 0x3c, 0x27, 0xf3, 0x63, 0x16, 0xf8, 0xb8, 0xb3, 0x03, + 0x35, 0x0a, 0xfe, 0x8b, 0xa0, 0x07, 0x8f, 0x77, 0xf1, 0xd4, 0x2a, 0x9b, 0x78, 0x92, + 0xb2, 0xa4, 0xdb, 0xee, ], Core::LeftExtend32_64 => [ - 0x84, 0xfc, 0xc6, 0x9b, 0xa1, 0xdb, 0x50, 0xdb, 0xd5, 0x36, 0x3c, 0xf2, 0x77, 0x79, - 0x57, 0x60, 0x1d, 0xe2, 0x56, 0x8a, 0xdf, 0x07, 0xaf, 0x41, 0x61, 0xde, 0xbb, 0x1e, - 0x5e, 0x37, 0x31, 0x0a, + 0x42, 0xcb, 0xeb, 0x01, 0xfe, 0x7a, 0x3a, 0x6d, 0xd3, 0x31, 0x1d, 0xb3, 0x36, 0x5f, + 0x91, 0xe5, 0xc1, 0x18, 0xc7, 0xe4, 0x1f, 0x03, 0xaa, 0xe7, 0xb2, 0x83, 0xde, 0x6b, + 0xb9, 0x05, 0x3e, 0x6b, ], Core::LeftExtend8_16 => [ - 0xfe, 0xa1, 0xf2, 0x5a, 0x82, 0xfd, 0xf6, 0xf8, 0x66, 0x9c, 0xc4, 0x0f, 0xbb, 0x8e, - 0x54, 0xa9, 0x26, 0x58, 0xbf, 0xab, 0x94, 0xeb, 0x08, 0x2f, 0x71, 0x7b, 0xa2, 0x65, - 0xb5, 0xd8, 0x44, 0xb4, + 0x9a, 0x57, 0xc9, 0x6a, 0xf5, 0x71, 0x48, 0x96, 0xb7, 0x24, 0xde, 0x45, 0xeb, 0x9f, + 0xe9, 0x7d, 0x73, 0x69, 0x7d, 0xe6, 0x2e, 0x8d, 0xad, 0x78, 0x71, 0xeb, 0x58, 0xf5, + 0x81, 0xa0, 0x11, 0xbb, ], Core::LeftExtend8_32 => [ - 0x09, 0xd7, 0x03, 0xca, 0x46, 0xf7, 0x5d, 0x05, 0x1a, 0x93, 0xd0, 0xe8, 0xa2, 0xaf, - 0x05, 0x01, 0xa3, 0x8e, 0x84, 0x86, 0x83, 0xef, 0x10, 0x9c, 0x1f, 0xb4, 0xb5, 0xbe, - 0x20, 0xe6, 0x31, 0x5d, + 0xd6, 0x24, 0xbd, 0x40, 0x40, 0x76, 0x3c, 0xb1, 0x3c, 0xca, 0xd4, 0x98, 0xf5, 0x3d, + 0x38, 0xc1, 0x12, 0xf1, 0x92, 0x95, 0x68, 0x26, 0xda, 0xfe, 0xc9, 0xac, 0x91, 0x65, + 0x79, 0x2b, 0x34, 0x7a, ], Core::LeftExtend8_64 => [ - 0xd3, 0xda, 0xfc, 0xbd, 0xab, 0x69, 0xa2, 0xbb, 0x32, 0x0f, 0x8d, 0x23, 0x0c, 0xef, - 0xd0, 0x9c, 0x27, 0xa1, 0x54, 0xc5, 0x1e, 0x7e, 0x5c, 0xd5, 0x33, 0x4e, 0xaf, 0xed, - 0x19, 0xe2, 0x0d, 0xf4, + 0x9d, 0xc4, 0xa2, 0x05, 0x4d, 0x5d, 0x26, 0x34, 0x2a, 0xc5, 0x90, 0xb6, 0x67, 0xf1, + 0xb0, 0x1d, 0xf5, 0x4f, 0xd0, 0xcd, 0xaa, 0x40, 0x5e, 0xf8, 0xcb, 0xb7, 0x6f, 0xd8, + 0xf9, 0xb0, 0x0e, 0xe5, ], Core::LeftPadHigh16_32 => [ - 0x88, 0x8c, 0x7e, 0x0a, 0xb0, 0x03, 0x14, 0x75, 0xc5, 0x14, 0xf9, 0xb3, 0x7c, 0x81, - 0xf4, 0x5a, 0x47, 0x31, 0x49, 0x84, 0xe5, 0x02, 0x75, 0x08, 0xdd, 0xc5, 0xeb, 0x8d, - 0x8d, 0x10, 0xbe, 0xb9, + 0x05, 0x45, 0xc4, 0xb5, 0x8f, 0x00, 0x4a, 0x21, 0xe7, 0xf1, 0x29, 0xa4, 0xc0, 0x51, + 0x89, 0x97, 0x17, 0x14, 0xca, 0xa2, 0xd9, 0x1d, 0x1d, 0xfd, 0x5f, 0xad, 0x3e, 0x63, + 0x24, 0x49, 0x94, 0x28, ], Core::LeftPadHigh16_64 => [ - 0x52, 0x6b, 0x35, 0x05, 0x45, 0x01, 0x36, 0xd6, 0x81, 0xa5, 0x0b, 0x4b, 0xde, 0x4f, - 0xa6, 0x12, 0xda, 0x9d, 0x69, 0xbd, 0x08, 0x17, 0x0e, 0xa3, 0x2d, 0x0a, 0x26, 0x51, - 0x11, 0x50, 0x72, 0xeb, + 0x1c, 0x61, 0xd0, 0x3d, 0x49, 0x3b, 0xbd, 0x05, 0x82, 0x22, 0x59, 0xd1, 0x73, 0x0a, + 0x8d, 0x7a, 0x5f, 0x55, 0xb0, 0xba, 0x2a, 0x93, 0x91, 0xa6, 0xc8, 0x88, 0x1e, 0xb4, + 0x75, 0x04, 0xaf, 0xfd, ], Core::LeftPadHigh1_16 => [ - 0x93, 0xae, 0xd6, 0xf6, 0x87, 0x50, 0x77, 0x4b, 0x2d, 0xbf, 0x83, 0x14, 0xca, 0xde, - 0xbe, 0x5a, 0x41, 0x52, 0x43, 0xfb, 0xdf, 0x7c, 0x2e, 0xea, 0x8b, 0x22, 0x3d, 0xf3, - 0x26, 0x1e, 0x3b, 0xdb, + 0x56, 0xfd, 0xf5, 0x4f, 0x1f, 0xcd, 0x19, 0x82, 0x5e, 0x7c, 0x3b, 0x79, 0x06, 0x15, + 0xc1, 0xd3, 0xfe, 0x82, 0x88, 0x6c, 0x74, 0x7b, 0xc4, 0x87, 0x59, 0x87, 0xf5, 0x05, + 0x16, 0x94, 0x5f, 0xb3, ], Core::LeftPadHigh1_32 => [ - 0x00, 0x82, 0x98, 0xf8, 0x2f, 0xb6, 0xcf, 0x37, 0xe9, 0xdc, 0x70, 0x3e, 0xa4, 0xf9, - 0x49, 0x56, 0x5c, 0x29, 0x65, 0xa7, 0xc7, 0xf4, 0xfa, 0x22, 0xf5, 0x54, 0x56, 0x42, - 0x34, 0x08, 0xa3, 0xab, + 0xdb, 0x33, 0x05, 0x9a, 0xbe, 0x2d, 0x43, 0x2d, 0x67, 0xf4, 0x2b, 0x1e, 0x94, 0x27, + 0x56, 0xdc, 0xa6, 0xcd, 0xe6, 0x37, 0x85, 0xe5, 0xbd, 0x43, 0x0d, 0xc8, 0xf4, 0xae, + 0xfc, 0x31, 0xb8, 0xdf, ], Core::LeftPadHigh1_64 => [ - 0x2b, 0x45, 0x4e, 0xbd, 0x79, 0x1e, 0xc7, 0xda, 0xce, 0xdc, 0xb8, 0x6c, 0x69, 0xd0, - 0x26, 0x79, 0x4a, 0x5d, 0xc3, 0x72, 0x52, 0x61, 0xe7, 0xdc, 0x16, 0x50, 0xcc, 0x88, - 0x81, 0x17, 0xfc, 0x4f, + 0x1d, 0x66, 0x9c, 0x1f, 0xa5, 0xfd, 0x3e, 0xf6, 0x6e, 0xb4, 0xae, 0xf6, 0x18, 0x6e, + 0x3e, 0xc1, 0x36, 0xee, 0x75, 0x84, 0x10, 0xdf, 0x3e, 0xde, 0xbb, 0x31, 0xbf, 0x26, + 0xd4, 0x56, 0x20, 0x51, ], Core::LeftPadHigh1_8 => [ - 0x6c, 0x27, 0x7c, 0x4c, 0xd0, 0x53, 0xdd, 0x35, 0x02, 0xdb, 0xe0, 0xbb, 0xc1, 0x4e, - 0xb0, 0xb3, 0x6a, 0x20, 0x1a, 0xbe, 0xf3, 0xb1, 0x74, 0xb0, 0xeb, 0xfe, 0x05, 0x20, - 0x18, 0xb6, 0x7e, 0x67, + 0x9a, 0x1b, 0xad, 0x3d, 0x8a, 0xb9, 0x00, 0x30, 0x3d, 0xa2, 0x02, 0xf0, 0xf4, 0x49, + 0xf0, 0xb7, 0xe6, 0x79, 0x5c, 0x2a, 0x7c, 0x12, 0x17, 0x18, 0x80, 0x0a, 0xc4, 0x0c, + 0x87, 0xd8, 0x27, 0x29, ], Core::LeftPadHigh32_64 => [ - 0x5d, 0x41, 0x22, 0x1c, 0xf6, 0x15, 0x82, 0x97, 0xb0, 0x6c, 0x19, 0x57, 0x11, 0x2c, - 0x0d, 0x12, 0xf3, 0xeb, 0x91, 0x7a, 0x2f, 0x50, 0x9a, 0x53, 0x9d, 0x5c, 0x9b, 0x79, - 0x10, 0x21, 0x9b, 0x65, + 0x39, 0x20, 0xcc, 0x4b, 0x33, 0xba, 0xf7, 0xef, 0xa5, 0xca, 0xf9, 0xe7, 0x80, 0x01, + 0x44, 0x67, 0x06, 0xf6, 0xe4, 0xe8, 0x26, 0x56, 0x74, 0x05, 0x7e, 0xed, 0x87, 0x17, + 0x78, 0x08, 0x9e, 0x94, ], Core::LeftPadHigh8_16 => [ - 0x21, 0x78, 0xdc, 0x76, 0xc0, 0x4c, 0x79, 0xd9, 0x18, 0x15, 0xd3, 0x8c, 0x96, 0x7f, - 0x34, 0x21, 0x3f, 0xfc, 0xc6, 0xc5, 0xf2, 0x43, 0xc9, 0x56, 0x29, 0x73, 0xf0, 0x90, - 0xca, 0x5c, 0xae, 0xfa, + 0x75, 0x2e, 0x29, 0xf2, 0xfe, 0x2b, 0xec, 0xc3, 0xf6, 0x62, 0x90, 0xfe, 0x44, 0xe1, + 0xae, 0xb3, 0x78, 0x41, 0x80, 0xdd, 0x90, 0x5e, 0x19, 0x62, 0x4e, 0x19, 0x5f, 0x21, + 0x6c, 0x07, 0xc5, 0x7c, ], Core::LeftPadHigh8_32 => [ - 0xa4, 0xe8, 0x6b, 0x53, 0xe5, 0xd0, 0x0f, 0xaf, 0x0b, 0x3e, 0x9d, 0x53, 0x20, 0x2a, - 0xf7, 0x73, 0x8d, 0xcb, 0x88, 0x87, 0xa1, 0x8d, 0xfe, 0xe5, 0xbe, 0x34, 0xc4, 0x97, - 0x69, 0x8c, 0xa6, 0xb7, + 0xbe, 0xe8, 0x8f, 0x1c, 0x8c, 0x30, 0x63, 0x4c, 0x6e, 0x95, 0xca, 0xcc, 0x0e, 0x9a, + 0xdd, 0x49, 0x41, 0x32, 0x21, 0xfd, 0xab, 0xbd, 0x8d, 0x4c, 0x0a, 0xcc, 0xf1, 0xca, + 0xe2, 0xd2, 0xa7, 0x78, ], Core::LeftPadHigh8_64 => [ - 0xc8, 0x43, 0xa7, 0x2c, 0x41, 0x17, 0x0f, 0x40, 0x34, 0x33, 0xc4, 0x36, 0xa3, 0x9b, - 0x05, 0xcf, 0x19, 0x3c, 0x27, 0xd8, 0xbe, 0x35, 0x30, 0xf9, 0xb9, 0x4e, 0x42, 0xd7, - 0x63, 0x00, 0x3d, 0x54, + 0x39, 0x23, 0x87, 0xf6, 0xdc, 0x04, 0xbf, 0xc5, 0x4d, 0xd4, 0xa2, 0x81, 0x19, 0xc8, + 0x1d, 0x15, 0xd7, 0xa5, 0x80, 0x9b, 0xbf, 0x62, 0xfc, 0xc2, 0x7d, 0xc5, 0x5c, 0xf8, + 0x2e, 0x9e, 0x5e, 0xe6, ], Core::LeftPadLow16_32 => [ - 0x21, 0x53, 0x7f, 0x7d, 0x8f, 0x97, 0xf2, 0x20, 0x3c, 0xcc, 0xb0, 0x35, 0xef, 0x1d, - 0x46, 0x28, 0x9e, 0xe8, 0xaa, 0x50, 0xf0, 0x23, 0x60, 0x77, 0xd0, 0xd0, 0xb2, 0x10, - 0x70, 0x04, 0x40, 0xa1, + 0x4f, 0xfd, 0x6c, 0xb3, 0x40, 0x23, 0x05, 0x82, 0x1d, 0xd8, 0x99, 0x70, 0xd7, 0x22, + 0xd1, 0xc1, 0x3f, 0x1f, 0xf7, 0x73, 0x9f, 0xd5, 0xf3, 0x4b, 0xa1, 0x6c, 0x73, 0x65, + 0x3b, 0x04, 0x47, 0x18, ], Core::LeftPadLow16_64 => [ - 0x6b, 0x2e, 0xa9, 0x63, 0x0c, 0x5d, 0xde, 0x03, 0x7a, 0xab, 0x2b, 0xf7, 0x33, 0x21, - 0x9b, 0x99, 0xc7, 0xed, 0xc2, 0xec, 0xed, 0xb9, 0xa0, 0x3a, 0xdf, 0xd1, 0x69, 0x43, - 0x0b, 0x08, 0xbb, 0x9c, + 0xbe, 0x3e, 0xb8, 0x5c, 0x5f, 0x19, 0x91, 0x53, 0xfb, 0x1c, 0x46, 0x13, 0x5c, 0x04, + 0xfa, 0xcf, 0xdb, 0xc6, 0xf1, 0xb7, 0x8c, 0x2b, 0xb7, 0xae, 0x75, 0xf1, 0x55, 0xbc, + 0x3e, 0xa0, 0x8a, 0x8b, ], Core::LeftPadLow1_16 => [ - 0x4a, 0xa4, 0x05, 0x20, 0xfa, 0xed, 0x72, 0xe6, 0xe9, 0xbe, 0x3b, 0xe6, 0x93, 0x0f, - 0x1e, 0x32, 0xb0, 0xb1, 0x82, 0xc4, 0x32, 0x7a, 0xda, 0x94, 0xa7, 0x1f, 0x00, 0x6d, - 0x14, 0x90, 0x15, 0xf9, + 0xdd, 0xd0, 0x15, 0x3e, 0xf3, 0x12, 0xf2, 0x8d, 0x64, 0x2c, 0xd9, 0x4c, 0xb3, 0x6f, + 0x32, 0x97, 0x75, 0xb0, 0x0d, 0xa8, 0x8f, 0xcc, 0xc4, 0xce, 0xa1, 0xba, 0xe8, 0x9b, + 0xad, 0x13, 0xbe, 0x6b, ], Core::LeftPadLow1_32 => [ - 0xcf, 0xb4, 0x75, 0x3b, 0xb9, 0xba, 0x36, 0x21, 0xba, 0x09, 0x37, 0x82, 0x5f, 0xad, - 0xe6, 0x43, 0x09, 0x8e, 0x38, 0x5e, 0xd6, 0x8e, 0xfb, 0x16, 0xff, 0x58, 0xec, 0xf3, - 0x65, 0xd7, 0xe5, 0xe2, + 0xbc, 0x9d, 0x31, 0x14, 0x35, 0x46, 0x7b, 0xc0, 0x8b, 0x10, 0x08, 0xe5, 0x47, 0xaa, + 0x7a, 0x07, 0xe8, 0x3b, 0x15, 0x14, 0x68, 0x61, 0xa9, 0xe9, 0xb5, 0x41, 0x3b, 0xe3, + 0x1b, 0x82, 0xb6, 0xb5, ], Core::LeftPadLow1_64 => [ - 0xe6, 0xf1, 0xc0, 0x9b, 0x5f, 0xe1, 0x26, 0xd0, 0xea, 0x86, 0xe7, 0xbf, 0xc0, 0xb2, - 0x8e, 0x84, 0x9f, 0x8f, 0x7e, 0xfd, 0x31, 0x06, 0x4e, 0xa4, 0xfd, 0x1c, 0xca, 0x07, - 0x1b, 0x45, 0xdb, 0x93, + 0x8b, 0xc6, 0x2f, 0x93, 0x60, 0x89, 0x4e, 0x48, 0xa4, 0x73, 0x2c, 0x95, 0x76, 0x9c, + 0x8f, 0xaa, 0xe9, 0x56, 0x8f, 0x9d, 0xe8, 0xe8, 0xa2, 0x00, 0x83, 0x6b, 0xd4, 0xe5, + 0x0b, 0x02, 0xcd, 0x84, ], Core::LeftPadLow1_8 => [ - 0xdc, 0x5a, 0x47, 0xf8, 0xd7, 0x77, 0x65, 0xc9, 0x94, 0xcb, 0xe8, 0x6a, 0xae, 0x44, - 0xa9, 0xc5, 0xff, 0x2e, 0xbc, 0x38, 0x10, 0xd7, 0x9c, 0xd8, 0x3b, 0xd2, 0xc4, 0x09, - 0x8c, 0x76, 0x2b, 0xf5, + 0xf6, 0x6c, 0xd7, 0xa4, 0x2b, 0x32, 0x0f, 0x97, 0xc1, 0x9f, 0x2d, 0x54, 0x16, 0xcd, + 0xe0, 0x87, 0x25, 0x3a, 0x27, 0x91, 0x29, 0x65, 0xd5, 0x5b, 0x65, 0x71, 0x2a, 0xd8, + 0x09, 0xb8, 0x3c, 0xfd, ], Core::LeftPadLow32_64 => [ - 0x2d, 0x88, 0xe4, 0xd0, 0x1e, 0x01, 0x08, 0xc0, 0xd6, 0x88, 0x0f, 0x3c, 0xe8, 0x48, - 0x2b, 0xb0, 0x95, 0x1f, 0x2b, 0x3f, 0xc5, 0xdf, 0x4b, 0x1a, 0xdb, 0x18, 0x4a, 0x1b, - 0xfd, 0x1f, 0x64, 0x65, + 0xa3, 0x3a, 0x07, 0xb9, 0xbc, 0xf9, 0x45, 0xf6, 0x4f, 0x07, 0x2b, 0x8b, 0x9c, 0x91, + 0x48, 0x39, 0xa5, 0x85, 0xbf, 0xa9, 0xf3, 0x42, 0x5b, 0x14, 0x77, 0x54, 0xab, 0x55, + 0xa8, 0xba, 0x6c, 0x0f, ], Core::LeftPadLow8_16 => [ - 0xac, 0x1a, 0x4c, 0x97, 0x83, 0xe4, 0xdb, 0xed, 0x27, 0x00, 0xeb, 0x29, 0x52, 0xe3, - 0x06, 0x2a, 0x5a, 0x72, 0x71, 0x2f, 0x82, 0x15, 0x98, 0x61, 0xb0, 0x8e, 0x67, 0xef, - 0x4a, 0x71, 0xf5, 0xf2, + 0x2a, 0x51, 0x6a, 0x79, 0x3f, 0x97, 0xc4, 0x5f, 0xea, 0xeb, 0xb1, 0xcc, 0x96, 0x1a, + 0x15, 0x6d, 0x80, 0x35, 0x49, 0x28, 0x79, 0x78, 0x9d, 0x6e, 0xdc, 0x9b, 0x57, 0xe7, + 0x2f, 0x11, 0xe5, 0xb5, ], Core::LeftPadLow8_32 => [ - 0x3d, 0xa5, 0xf1, 0xa8, 0xc9, 0x78, 0x19, 0xae, 0x7e, 0x10, 0xb9, 0x36, 0x4f, 0xf8, - 0x49, 0x96, 0xd0, 0xd7, 0x3e, 0x69, 0x8a, 0x49, 0xda, 0x69, 0x1f, 0x69, 0xa2, 0x73, - 0x25, 0x42, 0x01, 0xcd, + 0x1a, 0xa2, 0xe4, 0xd0, 0x4b, 0xd6, 0x90, 0x55, 0x12, 0x3d, 0xd6, 0xaa, 0xfe, 0x27, + 0xf5, 0xf7, 0xf4, 0x7c, 0x3b, 0x30, 0x90, 0xc3, 0xa8, 0x27, 0x29, 0x73, 0xfe, 0x2f, + 0x75, 0x16, 0x5a, 0x5d, ], Core::LeftPadLow8_64 => [ - 0x25, 0xbc, 0x18, 0xd4, 0x9f, 0x93, 0x40, 0x72, 0x27, 0x7d, 0x3f, 0x61, 0x3b, 0xf1, - 0x6c, 0x11, 0x8d, 0xf1, 0x97, 0xbc, 0x92, 0x87, 0x2d, 0x2a, 0xff, 0xe4, 0x17, 0xad, - 0xea, 0xaf, 0x1a, 0x85, + 0xb6, 0x52, 0xe0, 0xae, 0xdd, 0x0f, 0x4f, 0x66, 0xf6, 0xa1, 0xcd, 0x4b, 0xeb, 0xf8, + 0x75, 0xff, 0x7b, 0xbb, 0x2d, 0xd9, 0x9b, 0x06, 0x5b, 0x2d, 0xb5, 0xb5, 0xb5, 0x90, + 0x53, 0x61, 0x61, 0x4d, ], Core::LeftRotate16 => [ - 0x88, 0xc1, 0x23, 0x37, 0xcd, 0x75, 0x4f, 0x83, 0x80, 0x98, 0x6d, 0x86, 0xfe, 0x3a, - 0x89, 0xe2, 0x62, 0x74, 0x66, 0x53, 0xe1, 0xba, 0xdd, 0x9c, 0xc9, 0xb4, 0x76, 0x45, - 0xfe, 0x57, 0x19, 0x5a, + 0x8a, 0x12, 0xff, 0x6a, 0x4b, 0xf2, 0x37, 0x15, 0xdd, 0x3b, 0x76, 0x6b, 0x99, 0x67, + 0xc7, 0x15, 0x8b, 0xf3, 0xed, 0x74, 0xb3, 0xdc, 0xe7, 0x30, 0xaf, 0xfc, 0xf4, 0x66, + 0x16, 0x47, 0x8e, 0xcb, ], Core::LeftRotate32 => [ - 0x39, 0x81, 0x6c, 0xcd, 0x9e, 0x9c, 0xf1, 0x19, 0x1f, 0x06, 0x5d, 0x2e, 0xb7, 0xa7, - 0xfb, 0x83, 0x82, 0x8d, 0x91, 0xec, 0x7d, 0x99, 0x77, 0xa1, 0xfc, 0x70, 0xbe, 0x9b, - 0x31, 0xa4, 0x68, 0xb9, + 0x2f, 0xcb, 0x52, 0x17, 0x2f, 0xd4, 0x9c, 0x36, 0x21, 0x7d, 0xea, 0xe0, 0xc2, 0x37, + 0x14, 0x32, 0x1f, 0x69, 0xf5, 0xf1, 0x3f, 0x6e, 0x94, 0xb2, 0xbd, 0xfe, 0x4b, 0x74, + 0x88, 0x69, 0x7f, 0xd5, ], Core::LeftRotate64 => [ - 0x8b, 0x23, 0x55, 0xc3, 0x1e, 0x3b, 0x61, 0x4b, 0xd4, 0xb4, 0x1c, 0x3e, 0xcf, 0x27, - 0x74, 0x24, 0xd0, 0x26, 0x76, 0x6b, 0x37, 0xbc, 0x6c, 0x10, 0x56, 0x21, 0xf4, 0xf6, - 0xa1, 0x6f, 0x9b, 0xdf, + 0x72, 0xcc, 0xd6, 0xc4, 0xe5, 0xfd, 0xf6, 0x8a, 0xd3, 0x3b, 0x6d, 0x58, 0xfb, 0x37, + 0x2b, 0xe4, 0xf1, 0xb8, 0x0e, 0xef, 0x70, 0x1f, 0x9d, 0xb7, 0xe5, 0xed, 0x85, 0x9b, + 0x96, 0xb3, 0x62, 0x09, ], Core::LeftRotate8 => [ - 0x9e, 0x96, 0x6e, 0x88, 0x0c, 0x6b, 0x0c, 0x48, 0x3c, 0x90, 0xbe, 0xee, 0xd7, 0xc5, - 0x73, 0x7c, 0xa5, 0xf3, 0xfa, 0xcf, 0x85, 0xaa, 0xb3, 0xd5, 0x31, 0xad, 0x34, 0xbd, - 0x7b, 0x1a, 0x9b, 0x68, + 0x1a, 0xae, 0xc9, 0xf3, 0xb7, 0x5d, 0x89, 0xf8, 0x2a, 0x64, 0x98, 0x45, 0x8c, 0x44, + 0x83, 0xcb, 0x9a, 0x78, 0x44, 0x89, 0x05, 0xf3, 0xbb, 0x39, 0xfc, 0x08, 0x3f, 0x14, + 0xdd, 0xcc, 0xdc, 0x9b, ], Core::LeftShift16 => [ - 0xb0, 0x53, 0x60, 0x18, 0x4d, 0x06, 0x02, 0xb5, 0x81, 0x40, 0x5e, 0x32, 0x96, 0x0b, - 0x31, 0xc0, 0x52, 0x19, 0x35, 0x8d, 0xe8, 0x9e, 0xfd, 0xf4, 0x94, 0x64, 0x72, 0x3d, - 0xd6, 0x25, 0x61, 0x7a, + 0x37, 0xac, 0x63, 0x87, 0x21, 0xab, 0x09, 0x7a, 0x96, 0x02, 0xba, 0x4d, 0xc9, 0x2e, + 0x19, 0xb5, 0xa1, 0x85, 0xb2, 0x32, 0x9f, 0x1a, 0xa6, 0x00, 0xcb, 0x9c, 0x15, 0x61, + 0x5a, 0x00, 0x81, 0xf8, ], Core::LeftShift32 => [ - 0x34, 0xbf, 0x54, 0xf5, 0x94, 0xc2, 0x62, 0x10, 0x07, 0xf8, 0xc7, 0x8b, 0x30, 0xfa, - 0xd3, 0x96, 0x72, 0x00, 0x9b, 0xb3, 0x66, 0xaa, 0xce, 0x1e, 0x5e, 0x41, 0xee, 0x4d, - 0x9c, 0xc5, 0x41, 0xa8, + 0x8e, 0x3c, 0x47, 0x3b, 0x28, 0x67, 0xf1, 0x54, 0x73, 0xb3, 0x63, 0x2d, 0xbf, 0xdd, + 0x99, 0x77, 0x55, 0x51, 0xef, 0x5f, 0x9d, 0xba, 0x47, 0x5e, 0x9c, 0xf0, 0x90, 0x75, + 0x80, 0x70, 0xf0, 0xbf, ], Core::LeftShift64 => [ - 0x5d, 0xe9, 0x53, 0xf0, 0x4d, 0xea, 0xed, 0x90, 0x47, 0x56, 0x76, 0x47, 0xa1, 0xeb, - 0x7a, 0xbe, 0x66, 0x5f, 0xec, 0xcb, 0xe7, 0xed, 0x10, 0xcb, 0x7d, 0xbe, 0x69, 0x12, - 0x73, 0xc0, 0x94, 0xb0, + 0x50, 0x49, 0xf4, 0x04, 0xd1, 0x73, 0x29, 0x9a, 0x3a, 0xee, 0x04, 0xcb, 0xc2, 0x46, + 0x2c, 0xb3, 0x4c, 0x80, 0x69, 0xc1, 0xb6, 0xdb, 0x7f, 0xed, 0x0e, 0x38, 0x8f, 0xf6, + 0xd4, 0x67, 0xa0, 0x86, ], Core::LeftShift8 => [ - 0xab, 0x9d, 0x3e, 0x9a, 0xc3, 0x90, 0x38, 0xad, 0x88, 0xb1, 0x03, 0xf0, 0x72, 0x25, - 0x4c, 0x0e, 0xc6, 0xe2, 0x74, 0x75, 0xe2, 0x75, 0xc2, 0x45, 0xe8, 0x8c, 0xce, 0x0d, - 0x07, 0x2e, 0x64, 0x46, + 0x83, 0x2f, 0x63, 0x6e, 0x63, 0x44, 0x6c, 0xef, 0xba, 0x8d, 0xf3, 0xa4, 0x6e, 0xfb, + 0xb3, 0x61, 0x59, 0xc1, 0x88, 0x54, 0x56, 0x77, 0x68, 0xad, 0xc9, 0xb8, 0xdb, 0x8a, + 0x07, 0x49, 0x2a, 0x58, ], Core::LeftShiftWith16 => [ - 0xe2, 0x91, 0x07, 0x88, 0x55, 0x50, 0x45, 0x0e, 0xb7, 0x27, 0xd0, 0xcf, 0x14, 0xe1, - 0x04, 0xae, 0x12, 0xf8, 0x3a, 0x24, 0xe2, 0xe2, 0xac, 0xa3, 0xcc, 0xe4, 0x33, 0xde, - 0x2f, 0x35, 0xd7, 0xb3, + 0xe6, 0x47, 0x62, 0xb1, 0xc5, 0xe6, 0x14, 0x4a, 0x71, 0x81, 0xea, 0xaf, 0x4d, 0xd9, + 0xd9, 0xb3, 0xaa, 0x43, 0xaa, 0xd9, 0x55, 0x15, 0x81, 0x98, 0xee, 0x20, 0x90, 0xeb, + 0xd9, 0xe4, 0xbb, 0x0d, ], Core::LeftShiftWith32 => [ - 0xf3, 0x92, 0x50, 0xc4, 0x5a, 0x13, 0x10, 0xcc, 0x63, 0x8c, 0x78, 0x8d, 0xee, 0xc5, - 0xc3, 0x65, 0xb4, 0xd1, 0x76, 0xd1, 0x0e, 0xfb, 0xf4, 0xc6, 0x01, 0xcf, 0x5e, 0xeb, - 0xe0, 0xa5, 0x73, 0xe9, + 0x64, 0x76, 0xba, 0x89, 0x95, 0xf8, 0x3b, 0x5e, 0xe1, 0xeb, 0xc2, 0x2c, 0xb4, 0x16, + 0xf5, 0x58, 0x15, 0x7f, 0x2e, 0x57, 0x69, 0x9a, 0x5c, 0xaf, 0x84, 0x29, 0x1f, 0xf3, + 0xfc, 0x14, 0x83, 0xc1, ], Core::LeftShiftWith64 => [ - 0xad, 0x87, 0x94, 0xcf, 0xae, 0xf2, 0xb7, 0xf7, 0x74, 0xfa, 0x68, 0xd3, 0x09, 0xbb, - 0xc9, 0x8d, 0xfe, 0xe5, 0x8c, 0x40, 0x40, 0x0b, 0x2e, 0xb5, 0x78, 0xa2, 0x12, 0xf4, - 0x38, 0xbd, 0x07, 0xab, + 0x06, 0xb8, 0xfe, 0x67, 0xcf, 0xc5, 0x86, 0x32, 0x23, 0x97, 0xaf, 0x02, 0x4f, 0xde, + 0x29, 0x11, 0xf7, 0xae, 0x87, 0xa0, 0x6a, 0xbc, 0x6c, 0x59, 0x30, 0x93, 0x40, 0x97, + 0x15, 0x69, 0x1c, 0x19, ], Core::LeftShiftWith8 => [ - 0xdd, 0x9c, 0xc1, 0xce, 0xa7, 0x49, 0x09, 0x48, 0x1f, 0xf5, 0x8f, 0x87, 0x6f, 0xf6, - 0x6e, 0x0f, 0x5d, 0x52, 0xbf, 0x89, 0xb0, 0x25, 0x8f, 0xa9, 0x5b, 0x32, 0x00, 0x02, - 0xc3, 0x2a, 0x79, 0x15, + 0xb1, 0xac, 0x9c, 0x68, 0x23, 0x58, 0xc4, 0x5b, 0xab, 0xf4, 0x06, 0x95, 0x56, 0xfe, + 0x6e, 0x37, 0x5b, 0x45, 0x54, 0xde, 0x9e, 0x10, 0xc5, 0x91, 0xc1, 0x48, 0x39, 0x84, + 0x47, 0xac, 0x18, 0x0e, ], Core::Leftmost16_1 => [ - 0xde, 0x6a, 0x4c, 0x98, 0x33, 0x7e, 0x68, 0x0d, 0x6e, 0x6e, 0xe2, 0xbf, 0x36, 0xd3, - 0xa0, 0x81, 0x7d, 0x2a, 0x9a, 0x98, 0x32, 0x5f, 0x87, 0xe5, 0xec, 0xeb, 0x8a, 0x6f, - 0x11, 0x68, 0xf5, 0xca, + 0x5b, 0xff, 0x4c, 0xb5, 0x58, 0x76, 0x05, 0xd5, 0xfd, 0x05, 0x9d, 0x77, 0x33, 0x49, + 0x0d, 0x7d, 0xd2, 0x2d, 0x27, 0x8b, 0x59, 0x9e, 0x06, 0xd3, 0xb5, 0xdb, 0x6d, 0x79, + 0xf3, 0xc9, 0x23, 0xbd, ], Core::Leftmost16_2 => [ - 0x00, 0x58, 0x09, 0xb8, 0x05, 0x1a, 0x2a, 0x50, 0x28, 0x33, 0xb2, 0x2c, 0x2c, 0x17, - 0x98, 0x1e, 0xaf, 0x9d, 0xd1, 0xd3, 0xdb, 0xc8, 0xf8, 0xc8, 0x94, 0x51, 0x6c, 0x1d, - 0x5f, 0x31, 0x14, 0x6c, + 0x53, 0x6d, 0xb4, 0x86, 0xb1, 0x22, 0x27, 0xe5, 0xb0, 0x9d, 0x6f, 0xeb, 0xd2, 0x77, + 0x6b, 0x1a, 0xbb, 0xc6, 0x74, 0x99, 0x96, 0xaa, 0x78, 0x3e, 0xd7, 0xe5, 0x37, 0x44, + 0x6b, 0xbf, 0x15, 0x1b, ], Core::Leftmost16_4 => [ - 0x9c, 0x50, 0xee, 0x22, 0x84, 0xd8, 0x57, 0xc4, 0x7c, 0x05, 0x44, 0x47, 0x13, 0x54, - 0x10, 0x5e, 0x98, 0xdf, 0xe0, 0x27, 0x54, 0xd2, 0xe4, 0x2d, 0xe1, 0x1d, 0x32, 0x34, - 0xed, 0x10, 0xb6, 0x42, + 0xf2, 0x32, 0x13, 0x67, 0x49, 0x6d, 0x1a, 0x77, 0xee, 0xa0, 0x5e, 0x95, 0xe3, 0xb8, + 0x07, 0xd3, 0xba, 0x5f, 0x05, 0x13, 0x6c, 0xe0, 0x91, 0x2a, 0xe7, 0x17, 0xc8, 0x3a, + 0x02, 0x61, 0xb2, 0xe1, ], Core::Leftmost16_8 => [ - 0x5a, 0x1a, 0x72, 0x91, 0x4e, 0x14, 0x9c, 0x22, 0xb4, 0x64, 0xc8, 0xf6, 0xa3, 0xd9, - 0xcf, 0x41, 0xb0, 0x71, 0x92, 0xbe, 0xf0, 0xd8, 0xa1, 0xcc, 0x7c, 0xbe, 0x57, 0x04, - 0xa9, 0xe8, 0xea, 0x70, + 0x24, 0x14, 0x8e, 0xf3, 0x0a, 0xd4, 0x3e, 0xbe, 0xc5, 0x63, 0x72, 0x83, 0x22, 0xc3, + 0xce, 0x11, 0x79, 0xae, 0xd7, 0xa7, 0x82, 0x16, 0xd7, 0x99, 0x88, 0x8b, 0xf1, 0x8b, + 0x39, 0x57, 0x06, 0x71, ], Core::Leftmost32_1 => [ - 0x5f, 0xb8, 0xe6, 0x34, 0x2a, 0xb7, 0x4e, 0xe2, 0xc9, 0x22, 0x5b, 0x87, 0x2f, 0xa0, - 0xc9, 0x12, 0x04, 0x6a, 0x69, 0xdb, 0xb7, 0x19, 0xbc, 0xd6, 0xc8, 0xd7, 0x9b, 0x76, - 0x60, 0xc4, 0xeb, 0xca, + 0xb9, 0x2e, 0x15, 0xec, 0x5d, 0xa0, 0x7e, 0xe8, 0xed, 0x39, 0x7c, 0xb9, 0xf6, 0x0a, + 0x4c, 0x5d, 0xa8, 0x38, 0x62, 0x93, 0x1a, 0x90, 0x73, 0x59, 0xd2, 0x7c, 0xae, 0xb6, + 0x0e, 0x60, 0xef, 0x8a, ], Core::Leftmost32_16 => [ - 0x54, 0xae, 0x50, 0xb4, 0x6b, 0x5b, 0x2e, 0x68, 0xf5, 0x36, 0xc0, 0x1c, 0x39, 0x61, - 0x7b, 0x0c, 0xee, 0x42, 0xe1, 0xc4, 0x9a, 0x2c, 0xd1, 0xd2, 0x6a, 0xf8, 0xea, 0x87, - 0x15, 0xac, 0x4d, 0x11, + 0xad, 0xb0, 0x27, 0xb2, 0x06, 0x56, 0x73, 0x58, 0x53, 0x26, 0xc0, 0x1c, 0x3b, 0xe2, + 0xfa, 0xeb, 0x38, 0x63, 0x49, 0xe2, 0x90, 0x09, 0xb6, 0x57, 0x6e, 0xe5, 0x3a, 0x85, + 0x55, 0x12, 0xcc, 0x67, ], Core::Leftmost32_2 => [ - 0x12, 0x30, 0x68, 0x55, 0x45, 0x95, 0x42, 0x7e, 0x3c, 0x1d, 0xe2, 0x43, 0xba, 0xb6, - 0x6f, 0x33, 0x48, 0x36, 0x8a, 0xaa, 0x44, 0x61, 0x7d, 0x6a, 0x02, 0x47, 0x9f, 0xb7, - 0x04, 0xbc, 0xfd, 0x1e, + 0xb7, 0x5b, 0x31, 0xc5, 0x59, 0x12, 0x3d, 0x3d, 0x63, 0x35, 0x98, 0x59, 0x32, 0xb8, + 0xb1, 0xb2, 0x66, 0x4e, 0xe5, 0x97, 0xaf, 0xb1, 0x5f, 0xd1, 0xa4, 0x99, 0xd0, 0x07, + 0xcf, 0xf2, 0x75, 0x5c, ], Core::Leftmost32_4 => [ - 0x55, 0xa8, 0x7b, 0x66, 0xc3, 0x39, 0xe3, 0x63, 0xe0, 0x3d, 0x4d, 0xaa, 0xc6, 0x22, - 0x90, 0xeb, 0xa9, 0x3c, 0x1a, 0x3a, 0x73, 0x82, 0xcb, 0xf6, 0x1f, 0x20, 0xb3, 0x4a, - 0x50, 0x51, 0x24, 0xad, + 0xcb, 0x75, 0x7e, 0x47, 0x1e, 0x9d, 0x9a, 0x40, 0x77, 0x1d, 0xd1, 0xcf, 0x3c, 0x1b, + 0xf5, 0xd2, 0x3c, 0x17, 0xed, 0x68, 0xcd, 0xbd, 0xb2, 0x2d, 0xad, 0xa1, 0x7a, 0x73, + 0xa7, 0xb4, 0x07, 0xb2, ], Core::Leftmost32_8 => [ - 0x9f, 0x34, 0x5b, 0xee, 0x0b, 0x16, 0x2d, 0x42, 0xa0, 0x35, 0x71, 0x8f, 0x8c, 0xa1, - 0xad, 0xc8, 0xac, 0x2f, 0x71, 0x0d, 0xc4, 0x00, 0x52, 0xa8, 0x25, 0x66, 0xe6, 0xd8, - 0x07, 0xbe, 0xf8, 0xb8, + 0xbf, 0xc5, 0x34, 0xb4, 0x9e, 0x06, 0x00, 0x6e, 0x19, 0xf3, 0xb6, 0x8e, 0x0a, 0x02, + 0x39, 0x1c, 0x14, 0x9f, 0x9a, 0x34, 0xf4, 0x3e, 0xe3, 0x6b, 0x9f, 0x1d, 0x79, 0xa7, + 0x9c, 0x9a, 0x9e, 0x4d, ], Core::Leftmost64_1 => [ - 0xb9, 0x24, 0xd3, 0x3b, 0x5e, 0xfe, 0xfc, 0x8e, 0x20, 0x42, 0x08, 0x19, 0x25, 0x91, - 0x7c, 0xff, 0x23, 0x9b, 0x31, 0xc8, 0xbd, 0xbd, 0xf4, 0xac, 0xae, 0x6b, 0xb8, 0xd9, - 0xcd, 0x21, 0x7b, 0x4f, + 0x1b, 0x1d, 0x4e, 0x92, 0x38, 0x4b, 0x8b, 0x15, 0x9b, 0xa0, 0xd8, 0x06, 0x55, 0x8b, + 0x54, 0x94, 0xe3, 0x61, 0x4e, 0xed, 0xe0, 0x3c, 0x94, 0x6c, 0xea, 0xf1, 0x41, 0xf3, + 0x6f, 0x01, 0xc7, 0x9b, ], Core::Leftmost64_16 => [ - 0x12, 0xaa, 0x85, 0xe0, 0x5c, 0x1e, 0x96, 0x22, 0x27, 0x9c, 0x4c, 0x2d, 0xdc, 0xf8, - 0x97, 0xc9, 0x5d, 0xdc, 0xc0, 0x11, 0x39, 0x97, 0x28, 0x3b, 0x6b, 0x3e, 0x09, 0x49, - 0xbc, 0x81, 0x13, 0xcb, + 0x0d, 0xeb, 0xdc, 0x1a, 0xa0, 0x43, 0x30, 0x34, 0x42, 0xe1, 0x8f, 0xe0, 0x3d, 0x8a, + 0x99, 0xd2, 0xbe, 0x6b, 0xb8, 0xa8, 0x69, 0x1a, 0xba, 0x19, 0x56, 0x62, 0x59, 0xe3, + 0x67, 0x60, 0xf7, 0xf9, ], Core::Leftmost64_2 => [ - 0xbc, 0xec, 0x97, 0xf4, 0x3b, 0xa5, 0x5c, 0xd4, 0x0d, 0x85, 0xa1, 0xe7, 0x6c, 0xba, - 0xde, 0x7b, 0x0b, 0x1e, 0x9f, 0x13, 0x97, 0x47, 0x79, 0x3d, 0xcb, 0x34, 0x80, 0xbe, - 0xe1, 0xf7, 0x51, 0xca, + 0x83, 0x9e, 0xcf, 0xa3, 0x18, 0x70, 0x5c, 0x25, 0x3d, 0x0c, 0x52, 0xff, 0x27, 0xb9, + 0x04, 0x64, 0x92, 0x3d, 0x8c, 0x0e, 0x55, 0xa8, 0x2c, 0x0d, 0x16, 0x24, 0x02, 0x39, + 0x7f, 0x36, 0x53, 0x78, ], Core::Leftmost64_32 => [ - 0x9c, 0x89, 0x69, 0x39, 0x86, 0xe5, 0x57, 0x33, 0xab, 0x96, 0x2a, 0x30, 0x0b, 0x05, - 0x79, 0x50, 0x3d, 0x83, 0xde, 0x8a, 0xc1, 0x9b, 0x17, 0x9b, 0x41, 0x7e, 0x1c, 0xa2, - 0x53, 0x85, 0xb3, 0x8f, + 0x92, 0x91, 0x97, 0xa9, 0x64, 0x28, 0x61, 0xa7, 0x7b, 0xd6, 0x62, 0x58, 0x05, 0x11, + 0x97, 0xbe, 0x86, 0xff, 0x08, 0xe6, 0x28, 0xe3, 0x0f, 0x7e, 0xfc, 0xbd, 0x2c, 0x4d, + 0xfe, 0xcf, 0x9b, 0xdd, ], Core::Leftmost64_4 => [ - 0xd2, 0xd6, 0x45, 0x20, 0x92, 0xd6, 0x56, 0x6f, 0x89, 0xa1, 0xf6, 0x4e, 0x73, 0x65, - 0x96, 0xf9, 0x00, 0x0e, 0x5e, 0x6f, 0x63, 0xe4, 0x00, 0x17, 0xd0, 0xcb, 0x80, 0xf3, - 0xf7, 0xad, 0xfd, 0x18, + 0x02, 0xbd, 0x16, 0x45, 0xd5, 0x75, 0xf0, 0x4b, 0x3c, 0xbb, 0xaa, 0x6d, 0x8c, 0xa9, + 0x86, 0xef, 0x1c, 0x8c, 0xd0, 0xff, 0xe1, 0x65, 0x89, 0x03, 0x93, 0x9d, 0xb7, 0x64, + 0x56, 0x2a, 0x26, 0x47, ], Core::Leftmost64_8 => [ - 0xf7, 0x7b, 0x62, 0xbb, 0x01, 0xb9, 0x05, 0x11, 0xb6, 0xd0, 0x6e, 0xbf, 0x2e, 0x36, - 0xc0, 0x65, 0x65, 0xac, 0xb5, 0xaa, 0xd1, 0xef, 0xc7, 0x7c, 0x36, 0xa1, 0x0a, 0x26, - 0x1d, 0xe9, 0x21, 0xda, + 0x35, 0x58, 0xb3, 0x1b, 0x3b, 0x6e, 0x8f, 0x9a, 0x28, 0x8f, 0xdc, 0x72, 0xf2, 0x46, + 0x02, 0xbe, 0x05, 0x58, 0x19, 0x10, 0x71, 0xa5, 0x4a, 0x99, 0xfa, 0x03, 0xa0, 0x25, + 0x34, 0xf8, 0x80, 0x05, ], Core::Leftmost8_1 => [ - 0x5a, 0x73, 0x0b, 0x58, 0xe3, 0xab, 0xcb, 0x2f, 0x4d, 0xe2, 0x21, 0x59, 0x80, 0x30, - 0x23, 0x10, 0x2c, 0xd6, 0x64, 0x21, 0x91, 0x19, 0x20, 0xca, 0x21, 0xa2, 0xa0, 0x5c, - 0x9b, 0x21, 0x1c, 0xe8, + 0x28, 0x65, 0xef, 0xd4, 0x29, 0x83, 0xcb, 0xe3, 0xf8, 0x16, 0x37, 0x3a, 0xb8, 0xa8, + 0x82, 0xf1, 0x83, 0x17, 0x19, 0x4d, 0xc1, 0xab, 0xa3, 0x8d, 0xa0, 0x30, 0x4b, 0x8c, + 0x14, 0x4b, 0x1d, 0xa4, ], Core::Leftmost8_2 => [ - 0x25, 0x79, 0x08, 0x56, 0x10, 0x3d, 0xce, 0x6c, 0x7b, 0xbb, 0x3d, 0xd7, 0x18, 0xb1, - 0x69, 0x10, 0x9c, 0xae, 0x85, 0x37, 0x99, 0xd1, 0x24, 0x56, 0xc8, 0x5d, 0x83, 0x49, - 0xec, 0x18, 0xdc, 0x53, + 0x51, 0x96, 0x4c, 0xb0, 0x74, 0x05, 0xa8, 0xd2, 0x3d, 0x21, 0x87, 0x74, 0x1a, 0x9e, + 0xd3, 0x04, 0xbc, 0xb4, 0x69, 0xd9, 0xac, 0x9f, 0x5d, 0x92, 0x55, 0x82, 0x5c, 0xfd, + 0xa3, 0xda, 0x07, 0xc0, ], Core::Leftmost8_4 => [ - 0x73, 0xd9, 0xf0, 0x18, 0x15, 0x7a, 0x14, 0x78, 0x4e, 0xe7, 0x0b, 0x21, 0x9c, 0xeb, - 0x40, 0x42, 0xfa, 0x62, 0x1d, 0x0e, 0xe6, 0xd5, 0x45, 0xa0, 0xfd, 0xba, 0xb9, 0x44, - 0x43, 0x46, 0xe3, 0x31, + 0x88, 0x3c, 0x94, 0xf8, 0xa2, 0x6c, 0xda, 0xb7, 0xbc, 0x5c, 0xd6, 0x31, 0xe5, 0x22, + 0x55, 0xa8, 0x5e, 0xf6, 0xe0, 0x70, 0x76, 0x64, 0x57, 0xf6, 0x32, 0x1e, 0x2c, 0xcb, + 0x11, 0x9d, 0x9b, 0x2b, ], Core::LinearCombination1 => [ - 0x6d, 0x9f, 0x4a, 0x87, 0x0f, 0xbf, 0x74, 0x0c, 0x22, 0x0e, 0xff, 0xf3, 0x07, 0xb5, - 0xed, 0x91, 0xa5, 0x8c, 0x5e, 0x51, 0xa8, 0xad, 0xfc, 0x3b, 0x15, 0x90, 0x30, 0xf5, - 0x12, 0xd3, 0x99, 0x41, + 0x34, 0x10, 0xa9, 0xee, 0x33, 0x3d, 0xf8, 0xc8, 0xa0, 0x1c, 0x14, 0x11, 0x5b, 0x54, + 0x43, 0x27, 0xe3, 0x24, 0xe2, 0x87, 0xaa, 0x11, 0x07, 0xe0, 0x19, 0x55, 0xbd, 0x20, + 0x50, 0x6e, 0xa9, 0x87, ], Core::LinearVerify1 => [ - 0x27, 0x83, 0x13, 0xd7, 0xce, 0x4a, 0xd5, 0x89, 0x11, 0xde, 0x24, 0xee, 0x54, 0x0d, - 0x19, 0xec, 0xeb, 0xb6, 0x2f, 0x4a, 0xb4, 0xa7, 0x1e, 0x2a, 0xad, 0xd4, 0x51, 0x2b, - 0x2e, 0x4b, 0xc2, 0xe2, + 0xdc, 0x66, 0xd3, 0x31, 0xc1, 0x7f, 0x3f, 0xdd, 0xa3, 0x99, 0x46, 0x98, 0x1b, 0x39, + 0xb3, 0x57, 0xd0, 0x55, 0x5c, 0x35, 0x62, 0xec, 0xae, 0x02, 0xaa, 0x2d, 0xad, 0x16, + 0x3e, 0x6c, 0x9a, 0x2e, ], Core::Low1 => [ - 0xf2, 0x7b, 0x69, 0xbb, 0x09, 0x16, 0x09, 0xf5, 0x9e, 0x00, 0x33, 0x05, 0x0d, 0x01, - 0xa5, 0xbc, 0x77, 0xff, 0x07, 0xd9, 0x42, 0x70, 0x7a, 0x79, 0xcf, 0x5e, 0xe4, 0x10, - 0xa9, 0x98, 0xa0, 0x43, + 0xfe, 0x62, 0x14, 0xf9, 0x67, 0x15, 0x6d, 0xcd, 0xe6, 0xdd, 0x49, 0xfd, 0xc5, 0x5e, + 0xfb, 0x86, 0x50, 0x69, 0xfe, 0xab, 0xff, 0xf0, 0xfe, 0x93, 0x1d, 0xba, 0x85, 0x31, + 0x34, 0xee, 0xd1, 0x30, ], Core::Low16 => [ - 0x97, 0x7c, 0xbd, 0x1e, 0x7f, 0xfc, 0x05, 0xe7, 0x16, 0xd9, 0xc1, 0xb4, 0x9f, 0x7d, - 0x51, 0x7f, 0x85, 0x3d, 0xbf, 0x3e, 0x98, 0xa4, 0xc7, 0x48, 0x04, 0x6e, 0xac, 0xf4, - 0x17, 0xf8, 0x9c, 0x2f, + 0x74, 0x93, 0xcf, 0x69, 0x8a, 0x48, 0x82, 0xe5, 0xc3, 0x57, 0x9d, 0x06, 0x51, 0x8e, + 0x7e, 0xca, 0x2b, 0x84, 0x28, 0xf6, 0x2e, 0x2b, 0x51, 0x38, 0x02, 0xab, 0xe6, 0x22, + 0x17, 0x0c, 0x20, 0xfe, ], Core::Low32 => [ - 0xbe, 0x41, 0x69, 0x82, 0x8f, 0x07, 0x67, 0x78, 0xb6, 0x0d, 0x54, 0x56, 0xf7, 0x88, - 0x6e, 0xd7, 0xf3, 0x0b, 0x10, 0x1d, 0x6c, 0xcb, 0xd9, 0xea, 0x0c, 0x4d, 0xb1, 0x42, - 0xea, 0xc6, 0x6b, 0x12, + 0x36, 0x2d, 0x66, 0xa4, 0xf0, 0xae, 0xb9, 0x65, 0x84, 0xa5, 0x67, 0x57, 0x82, 0x71, + 0xb1, 0xf7, 0xbb, 0xfc, 0xc2, 0xde, 0x0d, 0xcf, 0x95, 0x79, 0x6b, 0x6f, 0x7a, 0x82, + 0x6b, 0x2a, 0x8a, 0xf7, ], Core::Low64 => [ - 0x01, 0x9a, 0x66, 0xbf, 0xba, 0x17, 0x51, 0x68, 0x8b, 0xe7, 0x13, 0x89, 0xed, 0x7b, - 0xf3, 0x71, 0xb3, 0x01, 0x4d, 0xfb, 0x32, 0x95, 0x62, 0xac, 0x3b, 0x3e, 0x9d, 0xfe, - 0x92, 0x06, 0xa5, 0xbc, + 0x97, 0x33, 0x23, 0xbc, 0x2b, 0x92, 0xe4, 0x28, 0x04, 0xd2, 0xe4, 0xf5, 0x8b, 0x86, + 0xf6, 0x5b, 0x56, 0xf9, 0x1d, 0xee, 0xb4, 0x81, 0x0e, 0xab, 0x8a, 0x1d, 0xed, 0xa9, + 0x69, 0x7a, 0x08, 0x72, ], Core::Low8 => [ - 0x21, 0x7b, 0x56, 0x43, 0x95, 0x6b, 0x48, 0x33, 0xaa, 0x56, 0x22, 0xf0, 0x0f, 0x06, - 0x88, 0xba, 0x86, 0x0d, 0x4a, 0xdb, 0xf9, 0x40, 0xcb, 0xdc, 0xd2, 0xb5, 0x9f, 0x26, - 0xd6, 0x15, 0x93, 0xb1, + 0xcd, 0x1a, 0x85, 0x58, 0xef, 0x99, 0xa3, 0x22, 0x60, 0x21, 0x7a, 0x76, 0x49, 0xff, + 0x51, 0x40, 0xda, 0x69, 0xda, 0x70, 0x06, 0x72, 0x69, 0x0b, 0x27, 0x91, 0x7b, 0x07, + 0xd7, 0xc1, 0x4c, 0x67, ], Core::Lt16 => [ - 0x56, 0xa2, 0x0d, 0x55, 0xed, 0xb4, 0x43, 0x88, 0x18, 0x05, 0x44, 0xc3, 0xed, 0x40, - 0x41, 0x45, 0xa3, 0xb6, 0x6f, 0xd2, 0xc4, 0x11, 0x38, 0x42, 0xf6, 0x4e, 0xae, 0xaf, - 0xba, 0xd4, 0xbb, 0x06, + 0x04, 0xac, 0xa8, 0x7e, 0x3e, 0x17, 0xf8, 0x05, 0xa2, 0x1c, 0xf2, 0x91, 0x7a, 0xee, + 0x99, 0x57, 0xb9, 0x50, 0xb2, 0xdb, 0x5d, 0x7a, 0xe5, 0xc8, 0x26, 0xd4, 0xac, 0x2e, + 0xc9, 0x7b, 0x5a, 0x52, ], Core::Lt32 => [ - 0xca, 0xb0, 0xdc, 0x5b, 0x0e, 0xcb, 0xf6, 0xd2, 0x48, 0x16, 0xfc, 0x20, 0x10, 0xfc, - 0x31, 0x19, 0x36, 0x63, 0xc3, 0x06, 0x96, 0x8d, 0x9c, 0xee, 0x3b, 0x00, 0x4c, 0x0b, - 0xc1, 0x84, 0xb4, 0x78, + 0x23, 0xa0, 0xa5, 0xc1, 0x97, 0x74, 0x7e, 0x3a, 0x95, 0x79, 0xe9, 0x0e, 0x0f, 0x22, + 0xf8, 0x4a, 0x29, 0xbf, 0xb5, 0xf0, 0x7b, 0x84, 0xb5, 0x9b, 0x26, 0x68, 0x8a, 0x0c, + 0xd5, 0x9d, 0xfe, 0xbd, ], Core::Lt64 => [ - 0x47, 0xd6, 0x7e, 0x52, 0xb2, 0x7b, 0xa7, 0x8e, 0xdd, 0x07, 0x5a, 0xa2, 0x70, 0xde, - 0xd0, 0x07, 0xa7, 0xa9, 0xa6, 0x84, 0x99, 0x34, 0x4f, 0x28, 0x62, 0xf5, 0x06, 0x90, - 0x49, 0xa0, 0xce, 0xfe, + 0xd2, 0x99, 0x90, 0x1c, 0x7b, 0x5b, 0x3a, 0x59, 0xff, 0xc8, 0xdd, 0x09, 0x54, 0x5a, + 0x32, 0x38, 0x24, 0xb7, 0x79, 0xa9, 0x9b, 0x2d, 0x1a, 0x2f, 0x87, 0x45, 0x2d, 0x9e, + 0x4b, 0xef, 0xaf, 0x30, ], Core::Lt8 => [ - 0x73, 0xd0, 0x04, 0x46, 0x55, 0xc0, 0xdf, 0x45, 0xc2, 0x71, 0xa1, 0x71, 0x3f, 0xf9, - 0xb9, 0xa4, 0x3d, 0xde, 0x56, 0xe6, 0x74, 0xd1, 0x75, 0x4e, 0x76, 0xed, 0xb1, 0x6f, - 0x94, 0x9c, 0x4f, 0xab, + 0xdd, 0x94, 0x41, 0x3b, 0x52, 0x9c, 0x29, 0x8c, 0x16, 0x96, 0xe9, 0xfb, 0x08, 0xe6, + 0x67, 0x67, 0xb3, 0xf8, 0x33, 0x7a, 0xc0, 0x2e, 0x44, 0xb0, 0x68, 0xe9, 0x40, 0x14, + 0xf7, 0xc4, 0x1f, 0x2a, ], Core::Maj1 => [ - 0xcb, 0x2d, 0x98, 0x6d, 0x7f, 0x00, 0x10, 0x7a, 0x3c, 0x25, 0xf6, 0xb2, 0xf1, 0x48, - 0x91, 0xd0, 0x2e, 0x20, 0xae, 0x16, 0xf0, 0xa1, 0x25, 0x2c, 0x92, 0xd9, 0xb5, 0x8a, - 0xe7, 0x33, 0x88, 0xaa, + 0x0e, 0x6f, 0xb4, 0x0f, 0xe3, 0x1a, 0x3a, 0x52, 0x6b, 0x44, 0xcf, 0x0b, 0x7c, 0x79, + 0x36, 0xc7, 0x77, 0xcb, 0xba, 0x89, 0x65, 0xa7, 0x25, 0x52, 0x32, 0xa7, 0xcf, 0x53, + 0xa9, 0x22, 0x88, 0x5a, ], Core::Maj16 => [ - 0x0a, 0xf6, 0xd0, 0xc1, 0x71, 0xfe, 0x33, 0xa2, 0x15, 0x9b, 0xf9, 0x88, 0x00, 0xf0, - 0x41, 0x2c, 0x25, 0x97, 0xe9, 0x97, 0x84, 0xd0, 0x74, 0xfd, 0xfa, 0x33, 0xd7, 0xfd, - 0xe5, 0x97, 0xdd, 0xfd, + 0x38, 0x66, 0x9c, 0xe5, 0xe1, 0xe1, 0x71, 0x47, 0x54, 0x00, 0x73, 0x1b, 0xee, 0xb6, + 0x0b, 0xca, 0xfa, 0xd6, 0x66, 0x04, 0xc9, 0x39, 0x40, 0x16, 0x0c, 0xd7, 0x12, 0x88, + 0x35, 0x55, 0x93, 0x42, ], Core::Maj32 => [ - 0x30, 0x60, 0x83, 0x8d, 0x48, 0x45, 0x6f, 0x33, 0x92, 0xd5, 0xd6, 0x9b, 0x5e, 0xec, - 0x08, 0x92, 0x76, 0xcd, 0x58, 0xbb, 0x67, 0xa1, 0x2c, 0x64, 0x2e, 0xc7, 0x3a, 0xeb, - 0x9a, 0xda, 0xcb, 0xdd, + 0x55, 0x54, 0x34, 0x9b, 0x58, 0x4f, 0x5c, 0x38, 0x72, 0xc7, 0xf4, 0xf2, 0x57, 0x82, + 0x9e, 0x2a, 0xe8, 0x22, 0xd8, 0x23, 0x42, 0x4c, 0xeb, 0x95, 0x98, 0xf0, 0x83, 0x18, + 0x58, 0x6a, 0x88, 0x07, ], Core::Maj64 => [ - 0x8e, 0xbc, 0xc1, 0x74, 0x57, 0xea, 0x2b, 0x14, 0x23, 0x1b, 0x0e, 0x90, 0x1e, 0xa7, - 0xb1, 0xd4, 0x7b, 0x9b, 0x78, 0x98, 0x63, 0x72, 0xa4, 0x41, 0x6f, 0xe7, 0x3f, 0x67, - 0x63, 0xfe, 0xb2, 0x4b, + 0x73, 0x49, 0x03, 0xba, 0xef, 0xb7, 0x1d, 0x5e, 0xa4, 0x16, 0x48, 0xff, 0x43, 0xee, + 0xe6, 0x98, 0x94, 0xe0, 0x63, 0xb3, 0x88, 0xea, 0x42, 0x2f, 0x96, 0xae, 0xde, 0x19, + 0x3c, 0xea, 0xb8, 0x39, ], Core::Maj8 => [ - 0x89, 0x30, 0xd1, 0xd0, 0x99, 0x1b, 0x0a, 0x58, 0x1d, 0x0b, 0x1d, 0x85, 0xad, 0x72, - 0x14, 0x7d, 0x66, 0x49, 0xa3, 0x59, 0x93, 0x28, 0x3f, 0xc9, 0x72, 0x14, 0x43, 0x1f, - 0x0b, 0x6a, 0x7a, 0xa8, + 0xba, 0x47, 0xa3, 0x99, 0xdc, 0x94, 0x35, 0xe1, 0x8e, 0x08, 0x0a, 0x4e, 0x18, 0xaf, + 0x7c, 0x65, 0x7f, 0xd3, 0x9f, 0x7c, 0xe7, 0xd6, 0x05, 0x2e, 0x46, 0x90, 0x23, 0x11, + 0xb0, 0x78, 0xd5, 0x85, ], Core::Max16 => [ - 0xe0, 0x11, 0x47, 0x17, 0x69, 0x1a, 0xc1, 0xa7, 0x39, 0x28, 0x8f, 0xc6, 0xff, 0xa1, - 0xc6, 0x50, 0x7c, 0x43, 0xe6, 0xf1, 0xd4, 0xc1, 0x87, 0x70, 0xff, 0xa1, 0x66, 0xae, - 0x83, 0x9d, 0xd5, 0x33, + 0xaa, 0x55, 0x23, 0x74, 0x6c, 0xab, 0xfa, 0xf5, 0x66, 0x8e, 0x9e, 0x07, 0x37, 0xe5, + 0x6b, 0x06, 0x06, 0x22, 0x51, 0xd7, 0xe8, 0x0a, 0xb9, 0xb9, 0x10, 0x6d, 0x8f, 0x17, + 0x2d, 0xc8, 0x4d, 0xd6, ], Core::Max32 => [ - 0x1d, 0x72, 0x3c, 0xb3, 0x89, 0x94, 0x22, 0x19, 0xec, 0x10, 0x34, 0x85, 0x31, 0x7f, - 0xa5, 0xd8, 0x7e, 0xe1, 0x5c, 0x24, 0xb2, 0x08, 0x0f, 0x50, 0x46, 0x65, 0x0d, 0x80, - 0x30, 0x8b, 0x18, 0x9d, + 0x69, 0x22, 0x96, 0x5d, 0x14, 0x43, 0x45, 0xc9, 0x13, 0xec, 0xb3, 0x0b, 0x5e, 0xd4, + 0x7e, 0x88, 0xda, 0xe3, 0x5c, 0x12, 0x21, 0xf2, 0x6a, 0xa9, 0x2d, 0xd5, 0xa5, 0xf6, + 0x15, 0xdb, 0xdb, 0x53, ], Core::Max64 => [ - 0x00, 0x73, 0xac, 0x3c, 0x6e, 0xa9, 0x39, 0xdc, 0xc7, 0xee, 0xe4, 0xea, 0x63, 0xdc, - 0xfd, 0x75, 0x20, 0x37, 0x35, 0x5b, 0x48, 0x4f, 0x6e, 0x70, 0x16, 0xb3, 0x00, 0xe2, - 0xd2, 0x8c, 0x07, 0xc3, + 0x8a, 0x9b, 0xe9, 0x07, 0xb6, 0xa4, 0xc3, 0x0a, 0xbc, 0xc0, 0xf2, 0x2d, 0x01, 0x30, + 0x74, 0xc2, 0xd5, 0x6b, 0xb0, 0x81, 0xf2, 0x62, 0x18, 0x57, 0xd5, 0x38, 0xcc, 0x97, + 0x13, 0x1e, 0x44, 0x09, ], Core::Max8 => [ - 0x6b, 0xc1, 0x03, 0x70, 0xf3, 0xe7, 0xa7, 0xb9, 0x2a, 0xcb, 0x14, 0x23, 0xbb, 0xdf, - 0x0b, 0x3d, 0x7e, 0x3c, 0xd0, 0xd2, 0xdb, 0xc7, 0x05, 0xa3, 0x4d, 0x8d, 0xc9, 0x9c, - 0x91, 0x04, 0x22, 0xfb, + 0xb4, 0xbf, 0x93, 0x23, 0x40, 0x22, 0xe8, 0x60, 0xfe, 0x76, 0xc0, 0xb5, 0x36, 0x0e, + 0x8b, 0x36, 0xff, 0x81, 0xee, 0x67, 0x05, 0xb5, 0x93, 0xac, 0xdf, 0x65, 0x5a, 0xc6, + 0xe6, 0xd7, 0xae, 0xba, ], Core::Median16 => [ - 0x24, 0x14, 0xe3, 0xc4, 0x39, 0x65, 0x9d, 0x8a, 0xa9, 0xd0, 0x87, 0xe1, 0xad, 0xe7, - 0x72, 0x66, 0x67, 0x3d, 0x1c, 0x8b, 0xd4, 0xe7, 0x50, 0x1b, 0x22, 0xac, 0x46, 0xa3, - 0xff, 0x39, 0x97, 0x5d, + 0x17, 0xe2, 0xe8, 0x7f, 0x07, 0x60, 0xf4, 0xfb, 0x3c, 0x9f, 0xd0, 0xbe, 0xd0, 0x00, + 0xd7, 0x39, 0x73, 0xab, 0x60, 0xf5, 0xe6, 0xc2, 0xc1, 0xfa, 0xb1, 0x7f, 0x9b, 0x23, + 0xee, 0x6a, 0xca, 0x48, ], Core::Median32 => [ - 0x07, 0x92, 0x35, 0x6b, 0x61, 0x0b, 0x57, 0xd0, 0xec, 0x19, 0x9e, 0x98, 0x53, 0x5e, - 0xa9, 0xbc, 0xcc, 0xe8, 0x43, 0xa5, 0xdf, 0x5d, 0xd2, 0x40, 0x8c, 0x41, 0x48, 0x86, - 0xdf, 0xd6, 0xbd, 0x1e, + 0x11, 0x60, 0xae, 0x8e, 0xa8, 0xd3, 0x0f, 0x9a, 0x22, 0x33, 0xc4, 0x8e, 0x73, 0x12, + 0x40, 0xf8, 0x44, 0x93, 0xb8, 0x28, 0xb5, 0x57, 0x93, 0xe2, 0xf4, 0x04, 0x2a, 0x19, + 0x82, 0xac, 0x26, 0xa5, ], Core::Median64 => [ - 0x07, 0x66, 0xd8, 0x9b, 0x43, 0x0f, 0xfd, 0xf0, 0x38, 0x69, 0x1b, 0x18, 0x43, 0x9c, - 0xd6, 0xfc, 0x49, 0x29, 0x17, 0x2e, 0xa8, 0x84, 0xfd, 0xaf, 0x16, 0x69, 0x36, 0xb3, - 0x8b, 0x15, 0xfd, 0x0c, + 0xc8, 0x73, 0x73, 0x64, 0x9e, 0x7e, 0x40, 0x50, 0xbb, 0x73, 0x33, 0x7e, 0x08, 0xeb, + 0x5d, 0xe4, 0x52, 0x28, 0xab, 0x86, 0xad, 0x4e, 0x1f, 0x41, 0x91, 0xe5, 0x20, 0x2a, + 0xa6, 0xaf, 0xa0, 0xc5, ], Core::Median8 => [ - 0xa4, 0xa0, 0xb6, 0x31, 0x0f, 0xf0, 0xed, 0x4a, 0x4c, 0x3e, 0x03, 0xeb, 0xc7, 0xa9, - 0x13, 0x06, 0xef, 0x66, 0x04, 0x24, 0xbc, 0x95, 0xa0, 0xd3, 0xf2, 0xfd, 0xb7, 0x1f, - 0xb6, 0xaf, 0xd8, 0xb7, + 0xc3, 0xb4, 0xe0, 0x89, 0x8a, 0x21, 0xbd, 0xe9, 0x4d, 0xae, 0xd3, 0x7a, 0x20, 0xad, + 0xf9, 0x0c, 0x8b, 0xe5, 0x69, 0x1a, 0x03, 0xb6, 0xa1, 0xe5, 0x56, 0x38, 0x5d, 0x42, + 0xeb, 0x19, 0x02, 0x2b, ], Core::Min16 => [ - 0xf1, 0x58, 0xf4, 0x0a, 0x86, 0x09, 0x93, 0xb4, 0x10, 0x7f, 0xb2, 0x71, 0xfb, 0x4c, - 0x8f, 0x95, 0x5b, 0xa4, 0x54, 0x2a, 0xd1, 0x82, 0x1c, 0xd2, 0xf1, 0x3c, 0x88, 0x0c, - 0xa4, 0xbe, 0xe2, 0xe2, + 0x5f, 0xd0, 0x05, 0x1e, 0xdb, 0x37, 0x19, 0xa6, 0x45, 0xb2, 0x72, 0xa0, 0x21, 0x08, + 0xef, 0xbb, 0x3d, 0x9b, 0xc0, 0xf6, 0x06, 0x21, 0xbf, 0x5a, 0x5b, 0xab, 0xe1, 0x16, + 0xd5, 0x55, 0xd5, 0x78, ], Core::Min32 => [ - 0xe5, 0xe4, 0x13, 0xdc, 0x5d, 0xe5, 0xe2, 0x2d, 0x66, 0xf3, 0x2d, 0x8d, 0xbf, 0x50, - 0x05, 0x3e, 0xd2, 0x78, 0xe1, 0x75, 0xc0, 0xd4, 0xb3, 0x44, 0xeb, 0xd4, 0x61, 0xbe, - 0xb1, 0x08, 0xe5, 0x5e, + 0xd8, 0x07, 0x82, 0xa2, 0xb5, 0xd8, 0x6a, 0xb6, 0xb9, 0xc9, 0xc3, 0xfb, 0x77, 0x8a, + 0x34, 0x73, 0xf6, 0x00, 0xb1, 0x85, 0xfe, 0x19, 0x25, 0xee, 0x9f, 0xc2, 0xe8, 0x77, + 0x7e, 0xd2, 0x66, 0x01, ], Core::Min64 => [ - 0x43, 0xd8, 0x2f, 0x6c, 0x61, 0x28, 0xaa, 0x01, 0xa9, 0x97, 0xbb, 0x17, 0xe5, 0xe7, - 0xf5, 0x01, 0xe7, 0xbe, 0x7d, 0xb9, 0x58, 0x9e, 0x56, 0x6d, 0xe9, 0x7a, 0x32, 0xea, - 0xe7, 0xe7, 0xb3, 0x39, + 0xc5, 0xc0, 0x9d, 0x50, 0x13, 0x38, 0xe9, 0xa5, 0x12, 0xcf, 0x89, 0x76, 0xca, 0x4b, + 0x32, 0xb9, 0x24, 0x80, 0xbe, 0xf6, 0xae, 0xb2, 0x9d, 0x36, 0xd5, 0x90, 0xd3, 0x5b, + 0xf9, 0xf9, 0xec, 0xe1, ], Core::Min8 => [ - 0x6b, 0x01, 0x2c, 0xa3, 0x18, 0x5d, 0xc0, 0x05, 0xe8, 0x94, 0x2c, 0xfb, 0xc9, 0xf2, - 0x38, 0xdc, 0xed, 0xaf, 0x0c, 0x00, 0x43, 0x52, 0x64, 0x47, 0xe3, 0xec, 0x31, 0xce, - 0xfa, 0x6e, 0x40, 0x64, + 0x81, 0xd2, 0x1e, 0x12, 0x81, 0x42, 0x38, 0x81, 0x80, 0x2c, 0x0e, 0x0c, 0x7d, 0x22, + 0xbd, 0x34, 0xd2, 0x6b, 0xd1, 0x2a, 0x4c, 0x4f, 0x1b, 0x70, 0x68, 0xe7, 0xe1, 0x83, + 0x82, 0x08, 0x48, 0xe9, ], Core::Modulo16 => [ - 0x62, 0xc1, 0x79, 0xac, 0x84, 0xc5, 0x75, 0x0b, 0x42, 0x5f, 0x9a, 0x1b, 0x8f, 0x81, - 0xed, 0xaa, 0x7f, 0x5c, 0xf2, 0x2c, 0x19, 0xd8, 0x6b, 0x0d, 0xcf, 0x96, 0xde, 0xa6, - 0xba, 0xd9, 0x9b, 0x3b, + 0xb6, 0xb8, 0x7c, 0xfa, 0xb6, 0x7e, 0x55, 0x19, 0xf1, 0xc9, 0x98, 0xda, 0x47, 0x94, + 0x37, 0xbb, 0x79, 0xe6, 0x74, 0xf7, 0x15, 0xe9, 0xa2, 0xe5, 0x38, 0xee, 0xc5, 0xec, + 0x18, 0xe1, 0x8e, 0xa5, ], Core::Modulo32 => [ - 0xa1, 0xf0, 0x1c, 0x10, 0x6f, 0xc3, 0x6a, 0x76, 0x4e, 0x99, 0xb2, 0x33, 0x98, 0xe2, - 0x1e, 0x7c, 0x26, 0x7f, 0x88, 0x9f, 0xcc, 0xeb, 0xd1, 0x48, 0x7d, 0x3d, 0xe1, 0xcc, - 0x67, 0xc3, 0x2b, 0xd9, + 0x8d, 0x48, 0x6e, 0x83, 0x16, 0x54, 0xf3, 0x8a, 0x32, 0xda, 0x35, 0xeb, 0x7b, 0xb6, + 0x55, 0xa6, 0xed, 0x69, 0x4d, 0xbf, 0xa0, 0x58, 0x95, 0x7d, 0x9f, 0x5c, 0xbf, 0xcc, + 0x57, 0x92, 0xc6, 0x5b, ], Core::Modulo64 => [ - 0x50, 0xc8, 0x2f, 0xd0, 0x31, 0x09, 0xc9, 0x8b, 0x72, 0x37, 0xe9, 0x16, 0x74, 0x04, - 0x19, 0x64, 0x38, 0x1e, 0x6c, 0x2e, 0xbb, 0xe2, 0x5b, 0xf3, 0xe0, 0xd3, 0x7a, 0x9f, - 0x06, 0x0f, 0x15, 0x02, + 0x14, 0xdf, 0x20, 0xd9, 0x3d, 0xfd, 0xef, 0xe2, 0x55, 0x9b, 0xac, 0x50, 0xed, 0x38, + 0x19, 0x3b, 0xd7, 0x8b, 0xd6, 0x3f, 0x92, 0x9d, 0x86, 0xfb, 0x4f, 0x29, 0xa7, 0xc5, + 0xaf, 0x32, 0x42, 0xad, ], Core::Modulo8 => [ - 0x5c, 0x63, 0xc7, 0x7a, 0x16, 0x08, 0xe2, 0xf6, 0xa3, 0x74, 0x8c, 0x11, 0x0f, 0xbb, - 0x9a, 0x1c, 0x56, 0x9f, 0xb4, 0xd5, 0x40, 0xf3, 0xdd, 0x2e, 0x4f, 0x80, 0xe9, 0x0d, - 0xd5, 0xea, 0x99, 0x82, + 0x2c, 0x75, 0x8a, 0x7c, 0x0f, 0x59, 0xe8, 0x00, 0xe9, 0x4f, 0x3d, 0xc5, 0xa0, 0x01, + 0xbf, 0x8e, 0xd9, 0x43, 0x5f, 0x75, 0xa2, 0xd9, 0x69, 0x30, 0xc5, 0x7e, 0xaa, 0xb0, + 0xcd, 0x80, 0xaf, 0x5c, ], Core::Multiply16 => [ - 0x46, 0xe6, 0x2a, 0xbf, 0x8e, 0x30, 0xa7, 0x74, 0x6d, 0xe0, 0xe9, 0x29, 0xf7, 0xbe, - 0xed, 0xdb, 0xde, 0x8b, 0x26, 0x9b, 0xab, 0x08, 0xf7, 0x6e, 0x95, 0x47, 0x10, 0x8b, - 0x1c, 0x36, 0x01, 0x74, + 0x75, 0xbd, 0x41, 0xf2, 0xd2, 0xb3, 0x39, 0xf0, 0x69, 0xbf, 0xdf, 0xd8, 0x02, 0xd6, + 0x1e, 0x6c, 0xa8, 0xe3, 0xba, 0xd6, 0xfb, 0x6d, 0x95, 0xb6, 0x72, 0x09, 0x5b, 0x93, + 0x34, 0x5f, 0x04, 0x7f, ], Core::Multiply32 => [ - 0x2d, 0xec, 0xdc, 0x5b, 0x0c, 0x6f, 0xf6, 0x3d, 0x11, 0xf5, 0x38, 0x52, 0xe0, 0xde, - 0xed, 0x11, 0x44, 0x81, 0x35, 0x5b, 0xb6, 0xc6, 0xce, 0x15, 0x46, 0xae, 0x9f, 0x81, - 0x5b, 0xee, 0x77, 0x50, + 0x84, 0xcb, 0xe6, 0xce, 0x87, 0x03, 0x79, 0x92, 0x13, 0x87, 0x7c, 0x1b, 0xd5, 0x05, + 0xc7, 0x64, 0x34, 0x33, 0x69, 0x00, 0x2e, 0x50, 0x2c, 0x43, 0xd9, 0x7f, 0x3d, 0x57, + 0x77, 0x2d, 0x6c, 0x87, ], Core::Multiply64 => [ - 0xbf, 0xa8, 0x62, 0x6d, 0xbf, 0x10, 0x00, 0x1d, 0xe3, 0x90, 0xd9, 0x97, 0xf2, 0xee, - 0x7b, 0x19, 0x0c, 0x24, 0xa7, 0x8c, 0xfe, 0xcb, 0x91, 0xf5, 0xd7, 0xc1, 0x0c, 0x3f, - 0x9d, 0xdb, 0xb1, 0xe6, + 0x92, 0x98, 0x7b, 0x80, 0x1b, 0x92, 0xf6, 0x79, 0xeb, 0x96, 0x13, 0x68, 0x84, 0x44, + 0xa1, 0x78, 0x87, 0x50, 0xa8, 0x50, 0x6e, 0x03, 0xa9, 0x21, 0x8c, 0x21, 0xec, 0xc7, + 0x20, 0x82, 0xdc, 0x6a, ], Core::Multiply8 => [ - 0x29, 0xda, 0x13, 0x37, 0x4f, 0x7c, 0xb3, 0x08, 0x40, 0x5f, 0xe2, 0x30, 0xf8, 0x99, - 0x48, 0x5c, 0x50, 0x0e, 0x6e, 0x95, 0x20, 0xc1, 0x5e, 0x8a, 0x76, 0xe5, 0x3a, 0x92, - 0xe7, 0xac, 0x64, 0xd6, + 0x76, 0x4c, 0xab, 0x71, 0xdb, 0x94, 0x59, 0xa7, 0x69, 0x6d, 0x94, 0x4a, 0x50, 0x09, + 0x5b, 0x1a, 0xeb, 0xdf, 0xd9, 0x28, 0x4b, 0xdb, 0x74, 0x96, 0xa7, 0xb3, 0x02, 0x41, + 0xcc, 0xba, 0x3e, 0xce, ], Core::Negate16 => [ - 0xf6, 0x42, 0x17, 0x3b, 0x85, 0xef, 0x21, 0x96, 0x9d, 0x8d, 0x90, 0x48, 0x80, 0x7e, - 0x3d, 0x4f, 0xac, 0xf3, 0xf5, 0xf9, 0xe5, 0x9a, 0xa5, 0xcf, 0x0c, 0x60, 0xf8, 0x74, - 0x22, 0xed, 0x7c, 0x8f, + 0xe7, 0x60, 0xee, 0x40, 0x29, 0xc3, 0x4f, 0x89, 0x74, 0x06, 0xff, 0xde, 0xa5, 0x55, + 0x84, 0x86, 0x62, 0xe8, 0x9c, 0x98, 0x3e, 0x60, 0x70, 0xbd, 0x02, 0x72, 0xad, 0x0f, + 0xa3, 0x42, 0xef, 0xa3, ], Core::Negate32 => [ - 0x54, 0x9b, 0x65, 0xce, 0x97, 0xc6, 0xb3, 0x34, 0xb8, 0xae, 0x94, 0x56, 0x96, 0x0e, - 0x36, 0x5b, 0xb2, 0x84, 0xd7, 0x6d, 0x40, 0x05, 0xe9, 0x21, 0xf4, 0x89, 0xbc, 0x36, - 0x26, 0x17, 0x1b, 0x06, + 0x84, 0x95, 0xb7, 0x40, 0x09, 0xad, 0x07, 0xc9, 0x30, 0x2a, 0x25, 0xae, 0x56, 0xc3, + 0xe9, 0x73, 0x3f, 0x00, 0xc2, 0xba, 0xa4, 0x10, 0xea, 0xc4, 0xa5, 0x8e, 0x75, 0xdb, + 0x83, 0xaf, 0x1d, 0x22, ], Core::Negate64 => [ - 0x35, 0xac, 0xca, 0x27, 0xce, 0x65, 0x85, 0x79, 0xef, 0x1c, 0x55, 0xad, 0x1a, 0xbe, - 0xa0, 0x05, 0x0d, 0x93, 0x66, 0xd1, 0x22, 0x09, 0xad, 0x13, 0x05, 0x25, 0x49, 0xc3, - 0x43, 0x64, 0x91, 0xd0, + 0x34, 0xe8, 0x9f, 0xaf, 0x34, 0x5a, 0xfd, 0x5e, 0x7b, 0x29, 0x00, 0x14, 0x52, 0xfc, + 0x5f, 0xc2, 0xe3, 0x78, 0x3a, 0xf7, 0xf2, 0x10, 0x16, 0x43, 0xbd, 0x76, 0x70, 0x6a, + 0x6f, 0xc3, 0xf3, 0x6a, ], Core::Negate8 => [ - 0xd8, 0x71, 0xc5, 0x42, 0x47, 0x3f, 0x4d, 0xd9, 0x02, 0xd3, 0x1f, 0xe3, 0xfc, 0x9a, - 0xc0, 0xf3, 0x31, 0x9e, 0x42, 0xe8, 0x0c, 0xae, 0x21, 0x81, 0xff, 0xc8, 0x5e, 0x6c, - 0x60, 0xfb, 0x09, 0x88, + 0xe8, 0x1b, 0xe0, 0xb1, 0x5c, 0x67, 0x1a, 0xb8, 0xdf, 0x1f, 0x48, 0x69, 0xc5, 0x7f, + 0x11, 0x11, 0x18, 0xcb, 0x66, 0x83, 0x54, 0x97, 0x5c, 0x63, 0x66, 0xec, 0xb2, 0xb8, + 0xbb, 0x7c, 0x15, 0xcf, ], Core::One16 => [ - 0x3f, 0x9f, 0x8d, 0xd1, 0x4c, 0x46, 0xee, 0x02, 0x47, 0x15, 0x57, 0x92, 0x9a, 0xc2, - 0xbb, 0x6c, 0x1a, 0xca, 0x00, 0x52, 0x1d, 0x8a, 0xfa, 0xf0, 0xdc, 0xd9, 0xf2, 0xca, - 0x7f, 0x31, 0xe6, 0x04, + 0x2e, 0x5e, 0x3d, 0x95, 0xe4, 0x53, 0x16, 0x88, 0x8e, 0x4f, 0x37, 0x09, 0xef, 0x83, + 0x2b, 0x9f, 0xd9, 0xe1, 0x5f, 0x30, 0x71, 0x9b, 0xf5, 0x5f, 0xc2, 0xe0, 0xe0, 0x9a, + 0x36, 0x57, 0xd8, 0x82, ], Core::One32 => [ - 0x47, 0x8d, 0xc3, 0x9d, 0xc3, 0x99, 0x5e, 0x2e, 0xdb, 0x7e, 0xc6, 0x74, 0x65, 0x6c, - 0xae, 0x79, 0x8f, 0x52, 0xe5, 0x72, 0x92, 0x61, 0x74, 0xa6, 0x68, 0xcc, 0x97, 0xbc, - 0xa4, 0x48, 0xd1, 0xcc, + 0x06, 0x42, 0x6b, 0x85, 0x3c, 0x1b, 0xcb, 0x33, 0x8a, 0xed, 0xbe, 0x1f, 0x89, 0xa6, + 0xd9, 0xb7, 0xa3, 0xda, 0x03, 0x8c, 0xd0, 0x0a, 0x44, 0x71, 0x18, 0x36, 0x93, 0x49, + 0x66, 0x9e, 0x29, 0x76, ], Core::One64 => [ - 0xa3, 0x92, 0xce, 0xfc, 0x0d, 0xa5, 0x3c, 0x65, 0xae, 0xe6, 0x12, 0xf5, 0xc6, 0x81, - 0x6c, 0xa8, 0x92, 0xfc, 0x15, 0x6d, 0x43, 0x71, 0x48, 0x76, 0xb3, 0xa0, 0x05, 0x68, - 0xe1, 0xba, 0x3e, 0xba, + 0xab, 0x1d, 0x2c, 0xd9, 0x96, 0x78, 0xda, 0x3c, 0x12, 0x8d, 0x39, 0xad, 0x9f, 0xe6, + 0xff, 0xa9, 0x55, 0xc1, 0x6e, 0x5e, 0xf2, 0xc2, 0x5b, 0xb4, 0x31, 0x83, 0x15, 0x59, + 0x69, 0x51, 0xf4, 0x27, ], Core::One8 => [ - 0xff, 0x59, 0x4e, 0x22, 0xbf, 0xd7, 0x58, 0x13, 0xc0, 0x56, 0xe0, 0xa2, 0x34, 0xed, - 0x12, 0xfa, 0x82, 0x87, 0xd1, 0xd5, 0x31, 0x6f, 0x23, 0x90, 0x2b, 0xf0, 0x79, 0xdb, - 0xcc, 0x4f, 0x4e, 0xa8, + 0x3c, 0xc5, 0xf5, 0x23, 0xd6, 0xa6, 0x35, 0x5d, 0xc9, 0x24, 0xee, 0x0a, 0xc1, 0xf5, + 0xfe, 0x2c, 0x52, 0x12, 0x75, 0xe3, 0xaa, 0x9f, 0x21, 0xd3, 0x1b, 0x08, 0x2d, 0xb2, + 0xac, 0x23, 0x0d, 0x9d, ], Core::Or1 => [ - 0x9b, 0xf5, 0x91, 0x74, 0x41, 0x0a, 0x80, 0x9d, 0x3d, 0xa2, 0xb5, 0x8c, 0x7e, 0x0d, - 0x05, 0xc5, 0x5c, 0xec, 0x38, 0xbd, 0xaa, 0x5f, 0xca, 0xc3, 0x82, 0xa3, 0x11, 0x77, - 0x0e, 0xe0, 0xeb, 0x38, + 0xc4, 0x65, 0x96, 0x43, 0x69, 0xfc, 0xa2, 0x09, 0x7f, 0x83, 0x53, 0x0c, 0x87, 0xbc, + 0xbc, 0x90, 0xc3, 0x06, 0x57, 0x9d, 0x9f, 0x3b, 0xfe, 0xdd, 0xf4, 0xa1, 0x72, 0xa4, + 0xea, 0x0b, 0x58, 0xec, ], Core::Or16 => [ - 0xdd, 0x9a, 0x31, 0x93, 0xd6, 0x19, 0xd9, 0x59, 0xfa, 0x0b, 0x6d, 0x8b, 0x47, 0xaf, - 0x78, 0x54, 0xf7, 0xe0, 0x46, 0x7b, 0xa3, 0x59, 0x01, 0xce, 0x43, 0xd8, 0x00, 0xfc, - 0xaf, 0x73, 0x0f, 0xf9, + 0x5a, 0x98, 0x5e, 0x04, 0x3b, 0x85, 0x27, 0x3b, 0x90, 0xf9, 0x0e, 0x20, 0xf8, 0x2b, + 0x75, 0x32, 0x33, 0x51, 0xcf, 0x2a, 0x4e, 0x62, 0xa7, 0xf9, 0xcb, 0x2f, 0x05, 0x96, + 0x40, 0x2e, 0x9e, 0x28, ], Core::Or32 => [ - 0x9a, 0x01, 0x9f, 0x07, 0xdf, 0x49, 0x96, 0xb3, 0x3e, 0x64, 0x7f, 0x4d, 0xe7, 0xe5, - 0x6c, 0x1d, 0x8f, 0x03, 0x26, 0x9c, 0xbf, 0xa3, 0xc7, 0x58, 0x2c, 0xfe, 0x80, 0x8e, - 0x90, 0x98, 0x70, 0xb7, + 0x35, 0x52, 0x38, 0x3a, 0x57, 0xff, 0xb4, 0x8d, 0x63, 0xa0, 0x33, 0x7a, 0xf0, 0xdd, + 0x6e, 0xfa, 0xb6, 0xb4, 0x6c, 0x5d, 0xe1, 0x72, 0x0e, 0x42, 0x0b, 0xdd, 0x1c, 0x82, + 0x27, 0x6b, 0xc9, 0xa9, ], Core::Or64 => [ - 0xc2, 0x4f, 0x35, 0x80, 0x05, 0xf8, 0x03, 0x77, 0x2b, 0x1c, 0x3e, 0x43, 0x9c, 0xf1, - 0xb7, 0x09, 0xbd, 0x9f, 0x4d, 0x42, 0x52, 0x75, 0x91, 0x30, 0x3a, 0x36, 0xf6, 0xb1, - 0xc3, 0xcf, 0x29, 0xcc, + 0x51, 0xa1, 0x73, 0xda, 0xdc, 0xa0, 0x1a, 0xc6, 0xf6, 0x2e, 0x75, 0xd5, 0xcd, 0x35, + 0x22, 0xf0, 0x9f, 0xde, 0x62, 0xb1, 0x15, 0x13, 0xe0, 0x68, 0x42, 0x28, 0x52, 0xa4, + 0x91, 0x67, 0xb6, 0x06, ], Core::Or8 => [ - 0x84, 0xb5, 0x36, 0x89, 0xf2, 0x1d, 0x4e, 0x69, 0x7d, 0x0f, 0xe8, 0x98, 0x8c, 0xe7, - 0x36, 0xab, 0x72, 0xc9, 0xc8, 0x6f, 0x84, 0x75, 0x89, 0xda, 0xa9, 0xae, 0x6a, 0x78, - 0x46, 0x30, 0xe6, 0x20, + 0x79, 0xef, 0xbd, 0xcb, 0x53, 0x7b, 0xeb, 0xcb, 0x18, 0x8d, 0x11, 0x16, 0xb7, 0x8a, + 0x10, 0x9b, 0xff, 0xbc, 0x2a, 0x6c, 0xe3, 0xd1, 0xf8, 0x70, 0x15, 0x4a, 0x79, 0x56, + 0x09, 0x1b, 0x34, 0x2f, ], Core::ParseLock => [ - 0x3d, 0x38, 0x36, 0xfd, 0x30, 0x85, 0xc1, 0xfb, 0xac, 0x6c, 0xd5, 0xfa, 0x0d, 0xbf, - 0x4a, 0x3f, 0xb2, 0x55, 0x45, 0x93, 0x17, 0xa2, 0x66, 0xd6, 0xd6, 0xf7, 0x38, 0x2b, - 0xb0, 0x5f, 0x07, 0xad, + 0x3d, 0xb8, 0x45, 0x35, 0xfa, 0x3d, 0x90, 0xef, 0x0b, 0x58, 0x1e, 0x22, 0xb6, 0x1d, + 0x21, 0x27, 0x84, 0x4b, 0x21, 0x16, 0xe8, 0x4f, 0x81, 0x4a, 0x5c, 0xba, 0xc5, 0x2d, + 0xf5, 0x15, 0xf2, 0xd2, ], Core::ParseSequence => [ - 0x74, 0xf3, 0x5c, 0x01, 0x9e, 0xf5, 0x14, 0xb7, 0x0a, 0xb0, 0x08, 0xbf, 0x2a, 0x12, - 0x6d, 0xe7, 0xe0, 0x0f, 0x6e, 0x3c, 0xcd, 0x28, 0x5d, 0x51, 0xdb, 0xd3, 0xac, 0x71, - 0xbe, 0xa9, 0xc8, 0x8d, + 0x38, 0xb2, 0x53, 0x3f, 0x5f, 0xed, 0xe8, 0x69, 0xba, 0xa1, 0x70, 0x69, 0x83, 0xdf, + 0x4c, 0x89, 0xd6, 0x2d, 0x5f, 0x90, 0x80, 0x0b, 0x47, 0xea, 0xb2, 0x11, 0x13, 0x31, + 0x1a, 0x5a, 0xae, 0xc9, ], Core::PointVerify1 => [ - 0x90, 0xa3, 0xd6, 0x69, 0xb0, 0x0d, 0xa7, 0x95, 0xef, 0xb2, 0xbe, 0xd8, 0xc3, 0x70, - 0xc9, 0xe3, 0xea, 0x0f, 0x19, 0xc4, 0x1c, 0x7c, 0xf2, 0x3e, 0x49, 0x2e, 0x33, 0x17, - 0x1a, 0x47, 0xf5, 0xff, + 0xbe, 0x2a, 0x98, 0x90, 0xf1, 0xd5, 0xb6, 0x15, 0x14, 0x7f, 0x82, 0x41, 0xe0, 0x60, + 0x9b, 0x5c, 0xac, 0x01, 0xec, 0xe0, 0xa3, 0xf9, 0x23, 0x68, 0x67, 0xb2, 0xbf, 0xde, + 0xa1, 0xb8, 0x04, 0x4e, ], Core::RightExtend16_32 => [ - 0x78, 0x07, 0x16, 0xd3, 0xe8, 0x29, 0x1a, 0x51, 0xe4, 0x5a, 0xda, 0x50, 0x55, 0x8e, - 0xfe, 0x41, 0x1c, 0x47, 0x5c, 0x08, 0x5e, 0xec, 0x5a, 0x28, 0xad, 0x97, 0x91, 0xc3, - 0x12, 0xfe, 0xe2, 0xbc, + 0xdb, 0xf1, 0x8d, 0x87, 0xa7, 0x89, 0x21, 0x39, 0xa3, 0x88, 0xe9, 0xa9, 0x83, 0xc4, + 0x89, 0x92, 0xac, 0x35, 0xa8, 0x45, 0x56, 0xee, 0x0d, 0xef, 0xc1, 0xda, 0xdf, 0x0c, + 0x5f, 0x47, 0x1a, 0x26, ], Core::RightExtend16_64 => [ - 0xc7, 0x70, 0x49, 0x7e, 0x45, 0x23, 0x08, 0xeb, 0xf5, 0x2e, 0x51, 0xb0, 0x58, 0x5e, - 0x91, 0x51, 0xe0, 0xff, 0xc3, 0x50, 0x86, 0xab, 0x77, 0x2d, 0x72, 0x41, 0x53, 0x2a, - 0x1b, 0xe1, 0x5e, 0x07, + 0xd0, 0x11, 0xac, 0xc7, 0x94, 0xe3, 0xc4, 0x78, 0x9a, 0xcc, 0xd0, 0xd5, 0xfe, 0x49, + 0x97, 0xd3, 0x34, 0xd9, 0x1f, 0x08, 0x31, 0xa1, 0xeb, 0x35, 0x04, 0xb4, 0xcb, 0x2d, + 0xdf, 0x47, 0x97, 0xaf, ], Core::RightExtend32_64 => [ - 0x42, 0xb4, 0x3a, 0xdc, 0x74, 0xb5, 0x26, 0x6c, 0x91, 0xd7, 0x3d, 0xf4, 0x91, 0xdc, - 0xae, 0x59, 0x73, 0x88, 0x04, 0xeb, 0x44, 0x0b, 0x23, 0xda, 0x32, 0x75, 0x30, 0x48, - 0x74, 0x86, 0xb7, 0xe8, + 0xa5, 0xaa, 0x5d, 0xb1, 0xe5, 0x35, 0xe7, 0x23, 0x2a, 0xd3, 0x6d, 0xaf, 0xba, 0x6d, + 0x5a, 0x20, 0x0d, 0x54, 0xeb, 0x85, 0x3b, 0x75, 0xdc, 0x70, 0xa5, 0x94, 0xed, 0x64, + 0xaa, 0x6b, 0xd9, 0xab, ], Core::RightExtend8_16 => [ - 0xbc, 0xb2, 0x68, 0x3a, 0x8c, 0xb8, 0xb8, 0xc2, 0x35, 0xfa, 0xa8, 0x96, 0xa9, 0xc0, - 0x69, 0xe1, 0xb5, 0x5b, 0xb0, 0x55, 0x8e, 0x73, 0x9e, 0x70, 0xe2, 0x89, 0x14, 0x21, - 0x1e, 0x32, 0x75, 0xc8, + 0x81, 0x06, 0xd5, 0x8a, 0x80, 0x66, 0xee, 0x6e, 0x15, 0xe5, 0x5c, 0xa5, 0x2c, 0xb7, + 0xaf, 0xd8, 0xe3, 0x27, 0x75, 0x87, 0xbf, 0xd7, 0xde, 0xc0, 0xbe, 0x37, 0xd4, 0x06, + 0x74, 0x2a, 0x39, 0x31, ], Core::RightExtend8_32 => [ - 0x6d, 0xdb, 0x55, 0x48, 0xfd, 0x58, 0x3c, 0xd2, 0xd3, 0x58, 0x6e, 0x6b, 0x8b, 0xf9, - 0x95, 0x24, 0x6b, 0x61, 0x93, 0x4f, 0x49, 0x76, 0x44, 0x67, 0x77, 0xdd, 0x57, 0x40, - 0xb3, 0x19, 0xe4, 0x62, + 0xdf, 0xa4, 0xba, 0xfa, 0x43, 0x2a, 0x53, 0x38, 0xd3, 0x74, 0xde, 0xb6, 0xb7, 0x24, + 0xb7, 0xf6, 0xea, 0xe5, 0x58, 0x61, 0xfe, 0x73, 0x1d, 0x43, 0x04, 0x8a, 0xa3, 0x04, + 0xd1, 0xf7, 0xf9, 0xa2, ], Core::RightExtend8_64 => [ - 0xda, 0x4f, 0x9c, 0x21, 0x45, 0x51, 0x26, 0x82, 0x07, 0x58, 0xa2, 0xe4, 0xb5, 0x3f, - 0xce, 0xb4, 0x52, 0x3e, 0x6e, 0x7a, 0x29, 0x23, 0xa1, 0xa1, 0x61, 0xfc, 0x37, 0x89, - 0x2a, 0xc8, 0xda, 0x2a, + 0x62, 0x0a, 0x37, 0x03, 0x8b, 0x6f, 0xa1, 0x27, 0x49, 0x5f, 0x0b, 0x46, 0x49, 0x6f, + 0x64, 0x35, 0xdd, 0x2d, 0xad, 0x7e, 0xf0, 0xc0, 0xfd, 0x2c, 0xd6, 0x5f, 0x54, 0xdc, + 0x18, 0x5e, 0x99, 0x7b, ], Core::RightPadHigh16_32 => [ - 0x3e, 0x4e, 0x5e, 0x9e, 0x71, 0xe1, 0x37, 0xa2, 0x68, 0x63, 0x43, 0xe0, 0x5a, 0xc5, - 0x63, 0x16, 0xac, 0xfc, 0x58, 0x99, 0x1c, 0xb3, 0x8d, 0xb1, 0xb3, 0x23, 0x44, 0x13, - 0xf7, 0x30, 0xa1, 0x42, + 0x2b, 0x6a, 0xbc, 0x38, 0x32, 0x1a, 0x7c, 0x54, 0x2f, 0xb1, 0x69, 0x74, 0x62, 0x1c, + 0xed, 0x80, 0x88, 0x0d, 0xb5, 0x19, 0xbb, 0x48, 0x60, 0x93, 0x42, 0x6e, 0x8c, 0xe1, + 0x8e, 0x01, 0x69, 0xb1, ], Core::RightPadHigh16_64 => [ - 0xde, 0x09, 0xdf, 0x9d, 0x43, 0xdd, 0xad, 0x2d, 0x69, 0x12, 0x04, 0x98, 0x6c, 0xf0, - 0x81, 0x9d, 0x6b, 0x80, 0x45, 0xbc, 0xa4, 0x14, 0xd8, 0x0a, 0xf2, 0x16, 0x28, 0x92, - 0xa9, 0x25, 0x7e, 0xad, + 0xad, 0x90, 0xd8, 0xff, 0xa5, 0x74, 0x50, 0xb3, 0xb5, 0xe9, 0x09, 0x62, 0x25, 0x34, + 0x9e, 0xd8, 0xf0, 0x72, 0xe1, 0x01, 0x72, 0x93, 0xf3, 0x92, 0xef, 0x85, 0x4e, 0x03, + 0x19, 0xab, 0xc9, 0x34, ], Core::RightPadHigh1_16 => [ - 0xff, 0x12, 0x97, 0xd8, 0x78, 0xe2, 0x6e, 0x19, 0x59, 0xbc, 0xc7, 0xe8, 0xae, 0xf9, - 0x7a, 0xc0, 0xb6, 0x5a, 0xdc, 0x39, 0x92, 0x3e, 0xc6, 0x50, 0x5e, 0x50, 0xf9, 0x83, - 0x05, 0x73, 0x3b, 0x6c, + 0x28, 0x81, 0x58, 0xb1, 0xc9, 0x10, 0x87, 0x7b, 0x7e, 0xea, 0x3d, 0xfc, 0xf2, 0xb2, + 0xb7, 0x88, 0x92, 0x28, 0x08, 0xb6, 0xd6, 0xfa, 0x75, 0xf8, 0x96, 0x77, 0x19, 0x04, + 0x8b, 0x14, 0x12, 0x49, ], Core::RightPadHigh1_32 => [ - 0x28, 0x3f, 0x8a, 0xfb, 0x41, 0x38, 0x2d, 0x2b, 0xe1, 0x8f, 0x8a, 0x77, 0xc3, 0x14, - 0xba, 0x17, 0x76, 0xcb, 0x80, 0xc8, 0xec, 0x36, 0xca, 0x12, 0xaa, 0x67, 0xb3, 0x2b, - 0xb6, 0x4e, 0xd8, 0x43, + 0xee, 0x2a, 0xd7, 0x7f, 0x66, 0x8d, 0x3d, 0x6a, 0x2e, 0x68, 0x50, 0x6e, 0x49, 0x04, + 0xcf, 0x50, 0xa0, 0x84, 0x60, 0xe1, 0xd2, 0xb8, 0x6a, 0x81, 0xe1, 0x4e, 0x41, 0xf8, + 0xda, 0x4c, 0xdd, 0xf2, ], Core::RightPadHigh1_64 => [ - 0xa3, 0x42, 0x35, 0x28, 0x60, 0xa3, 0x35, 0x0d, 0x79, 0xc3, 0xe9, 0xfc, 0x7a, 0x4a, - 0xb3, 0x78, 0x9b, 0x8b, 0x02, 0x97, 0x85, 0x6f, 0xd1, 0x69, 0xca, 0x4d, 0x7d, 0xe2, - 0x5f, 0x7d, 0x7c, 0xc4, + 0x3d, 0x6a, 0x7f, 0xe6, 0x9a, 0x11, 0x64, 0x2a, 0xce, 0xd6, 0x84, 0x2b, 0x89, 0xaa, + 0x1b, 0xb8, 0x41, 0x3e, 0x39, 0x90, 0x63, 0xcc, 0x16, 0x78, 0x6a, 0xf7, 0xc0, 0x33, + 0xda, 0xd5, 0x8b, 0x95, ], Core::RightPadHigh1_8 => [ - 0x71, 0x03, 0xc0, 0xfe, 0x00, 0xf5, 0x22, 0xa2, 0x21, 0x6c, 0x4a, 0x6b, 0xe5, 0xf7, - 0xe0, 0xeb, 0x4d, 0x70, 0x3c, 0xa7, 0x8f, 0x9c, 0x59, 0x8f, 0x6b, 0x3d, 0xfd, 0xe4, - 0x37, 0xd8, 0x0c, 0x84, + 0x28, 0x44, 0xbd, 0xfd, 0x6a, 0xba, 0x29, 0xdf, 0x03, 0xf9, 0x3a, 0xa6, 0xae, 0xb2, + 0x1c, 0x06, 0x40, 0x28, 0xdb, 0x05, 0xff, 0x77, 0xd8, 0xd9, 0x1c, 0xfd, 0xcd, 0xef, + 0xb1, 0x90, 0xc5, 0xbd, ], Core::RightPadHigh32_64 => [ - 0x5d, 0xc9, 0x10, 0x7d, 0x45, 0x34, 0x95, 0x8c, 0xe4, 0x42, 0x27, 0x67, 0x56, 0x3a, - 0x03, 0x1a, 0x38, 0x0f, 0x60, 0xd3, 0x83, 0x71, 0x48, 0xab, 0x3c, 0x8c, 0xc9, 0xc4, - 0xc7, 0xd9, 0x96, 0xa2, + 0xb4, 0x32, 0xe5, 0x32, 0x1a, 0xe1, 0x71, 0x4c, 0xe1, 0x95, 0x29, 0xd8, 0x5f, 0x24, + 0xff, 0x89, 0x87, 0x91, 0x0e, 0xbc, 0xf0, 0x15, 0xf8, 0x7f, 0x15, 0xbb, 0xed, 0x55, + 0xf0, 0xa0, 0xe8, 0x92, ], Core::RightPadHigh8_16 => [ - 0xc0, 0xe2, 0xfd, 0x46, 0xf7, 0x88, 0x3b, 0x12, 0x85, 0xa6, 0xf1, 0xa1, 0xdb, 0x96, - 0xd9, 0x3c, 0x25, 0x48, 0x04, 0x0f, 0xcd, 0x3f, 0x5c, 0x23, 0xfb, 0xb2, 0x0b, 0x5e, - 0x83, 0x03, 0x7c, 0x96, + 0x6f, 0x2d, 0x96, 0xc9, 0x54, 0x13, 0xca, 0x9a, 0xa8, 0xcc, 0x55, 0x0f, 0x25, 0x73, + 0xe1, 0x66, 0x99, 0x56, 0xd6, 0x07, 0x69, 0x2c, 0xf1, 0xca, 0x6d, 0xc7, 0x6d, 0x2f, + 0x2b, 0x4a, 0x3a, 0xc8, ], Core::RightPadHigh8_32 => [ - 0x29, 0x1e, 0x62, 0x77, 0x08, 0x52, 0x0c, 0x2c, 0xa6, 0xae, 0xce, 0x32, 0xa8, 0x77, - 0xb7, 0x78, 0x49, 0xc4, 0xa7, 0xa2, 0x13, 0xcb, 0x89, 0xe1, 0xbd, 0xa7, 0xc5, 0xc5, - 0xfe, 0x75, 0x5f, 0x73, + 0xdf, 0x2c, 0x7f, 0x92, 0x99, 0x00, 0xa4, 0x49, 0x01, 0xe6, 0xff, 0x65, 0x27, 0x6a, + 0x95, 0x1a, 0xeb, 0x95, 0xdf, 0x25, 0x0b, 0x13, 0x97, 0x14, 0xd4, 0x19, 0x54, 0x04, + 0xd7, 0x78, 0x98, 0xed, ], Core::RightPadHigh8_64 => [ - 0x6b, 0x6f, 0xa2, 0x37, 0x2e, 0xd2, 0x5e, 0x4a, 0x34, 0xd4, 0xae, 0x17, 0x23, 0x42, - 0xad, 0xbb, 0x25, 0x9b, 0xe8, 0x98, 0x76, 0x00, 0xdb, 0x19, 0x2e, 0xcb, 0x8d, 0xa4, - 0x34, 0xb9, 0xd8, 0x8f, + 0x79, 0xc0, 0x1d, 0xa3, 0xe6, 0x0b, 0x9c, 0x69, 0x35, 0xce, 0x3e, 0x15, 0x98, 0xb1, + 0x78, 0x40, 0xaf, 0x82, 0xdc, 0xb0, 0xdd, 0xc6, 0x3a, 0xef, 0x4a, 0x06, 0xe7, 0xf9, + 0xca, 0x5d, 0x27, 0x41, ], Core::RightPadLow16_32 => [ - 0x77, 0x31, 0xd5, 0x60, 0xd3, 0x75, 0x92, 0xd1, 0xa3, 0x1f, 0x73, 0x62, 0x96, 0x7a, - 0xb2, 0xe4, 0x75, 0x92, 0xac, 0xa6, 0xe9, 0x2a, 0xb8, 0x58, 0x82, 0x37, 0x92, 0xda, - 0xe5, 0xd2, 0xdb, 0x52, + 0x6f, 0x20, 0x10, 0x27, 0xcc, 0x75, 0x98, 0x02, 0x30, 0xa0, 0x70, 0x85, 0x9c, 0x3e, + 0x38, 0x02, 0x36, 0xa1, 0xcb, 0x10, 0xe6, 0x1a, 0x01, 0xaa, 0x1f, 0x6d, 0x23, 0x1d, + 0x15, 0x14, 0x2f, 0x25, ], Core::RightPadLow16_64 => [ - 0x0f, 0xe1, 0xc0, 0xdb, 0x9d, 0x4a, 0x2d, 0x63, 0xe2, 0xba, 0x4a, 0x33, 0x11, 0x7a, - 0xad, 0xba, 0x64, 0x51, 0x4a, 0x2b, 0x87, 0xa7, 0xa4, 0xe7, 0x93, 0xfa, 0xac, 0xfe, - 0x6b, 0x36, 0x34, 0x47, + 0xb8, 0x6e, 0x1f, 0x0b, 0xfe, 0xc6, 0x55, 0x98, 0xd0, 0xa3, 0xd1, 0xec, 0x96, 0x03, + 0x05, 0xb9, 0x67, 0x45, 0x67, 0x3e, 0x1b, 0x16, 0xbf, 0x32, 0x7a, 0x71, 0x68, 0x05, + 0x83, 0xd7, 0x1d, 0x90, ], Core::RightPadLow1_16 => [ - 0x79, 0x14, 0xc8, 0xf2, 0x22, 0x47, 0xc2, 0xc3, 0x4b, 0x9c, 0x84, 0xe9, 0x2d, 0x14, - 0x44, 0xae, 0xc2, 0xe1, 0x7a, 0x0e, 0xf5, 0x86, 0xba, 0xb2, 0x78, 0x8e, 0xe6, 0xef, - 0x68, 0x84, 0x0d, 0x98, + 0x05, 0x2a, 0x64, 0x99, 0xc9, 0x3e, 0xe6, 0xbc, 0x1a, 0xe6, 0x57, 0xf8, 0x5f, 0xd4, + 0xd4, 0xfe, 0x67, 0x7a, 0xbc, 0xee, 0x54, 0x0d, 0x13, 0x40, 0x33, 0x54, 0x2e, 0x9a, + 0xb6, 0x0a, 0x63, 0xdd, ], Core::RightPadLow1_32 => [ - 0x31, 0xb6, 0xce, 0x26, 0xe5, 0x59, 0xf7, 0x6c, 0xf3, 0x66, 0xf4, 0x80, 0x69, 0x85, - 0xec, 0xc2, 0x99, 0x55, 0x0f, 0x15, 0xd4, 0xc3, 0xa6, 0x72, 0x9e, 0x29, 0xd7, 0x0e, - 0x39, 0x89, 0x56, 0x52, + 0x5b, 0x70, 0xd4, 0x28, 0x96, 0x0e, 0x95, 0xcc, 0x40, 0xd5, 0x18, 0x46, 0xf5, 0x3a, + 0x4d, 0x0a, 0x35, 0xc9, 0x01, 0x5d, 0x15, 0x00, 0xb6, 0xbc, 0x84, 0x9b, 0x72, 0x83, + 0x5e, 0x2b, 0xd4, 0x40, ], Core::RightPadLow1_64 => [ - 0xc5, 0x52, 0x4a, 0xe6, 0x54, 0x8a, 0xcd, 0x63, 0x08, 0x2d, 0x94, 0x89, 0x3e, 0x18, - 0xf9, 0xed, 0xbb, 0x92, 0x31, 0xe7, 0x6b, 0xb4, 0xe1, 0x1b, 0xbf, 0xf6, 0xa7, 0xbd, - 0x16, 0xf4, 0xb0, 0x29, + 0x44, 0xef, 0xeb, 0x87, 0xca, 0x2a, 0xd7, 0xfd, 0x4b, 0x73, 0xf1, 0x63, 0x07, 0xc7, + 0xf0, 0x59, 0x02, 0x65, 0x6f, 0x35, 0x09, 0x0f, 0xb0, 0xa4, 0x32, 0x6c, 0x64, 0x89, + 0x88, 0xae, 0x1d, 0x39, ], Core::RightPadLow1_8 => [ - 0x59, 0xd7, 0x22, 0x70, 0xef, 0x0e, 0x8f, 0x77, 0x0c, 0x8d, 0x11, 0xf3, 0x17, 0x73, - 0xf9, 0xb6, 0xe9, 0x0a, 0x4a, 0xec, 0xeb, 0x5b, 0xfb, 0x3d, 0xfe, 0x96, 0x8c, 0x4e, - 0x9d, 0xac, 0x5f, 0xe8, + 0x93, 0x40, 0x39, 0x8b, 0xcc, 0x8e, 0xa8, 0x3e, 0xc8, 0x40, 0xbe, 0x72, 0x9d, 0xbb, + 0x8b, 0x81, 0x20, 0x78, 0x24, 0xee, 0x87, 0x5d, 0x15, 0x82, 0x59, 0xd6, 0xda, 0xd2, + 0x0a, 0x83, 0x93, 0x0c, ], Core::RightPadLow32_64 => [ - 0xd4, 0x22, 0x7d, 0x06, 0x6f, 0x18, 0xb9, 0x11, 0xd6, 0xf5, 0xd9, 0xbf, 0xb9, 0xd9, - 0xf4, 0x6e, 0x9a, 0xea, 0xdb, 0xbe, 0xfa, 0x34, 0xd4, 0x74, 0x43, 0x2a, 0x1e, 0x78, - 0x9e, 0x48, 0x86, 0xff, + 0x69, 0x3e, 0x28, 0x10, 0x1e, 0x04, 0xfd, 0xa4, 0x3b, 0x97, 0xe6, 0x11, 0xf0, 0xfe, + 0x98, 0x00, 0x0e, 0x14, 0x30, 0x2e, 0x5d, 0xcd, 0x6e, 0xd6, 0x5e, 0xee, 0x42, 0xe3, + 0x40, 0x14, 0x24, 0x2f, ], Core::RightPadLow8_16 => [ - 0xab, 0xa4, 0x7a, 0x53, 0x6e, 0x12, 0x27, 0xe1, 0x22, 0xba, 0xac, 0xf1, 0x9c, 0xfd, - 0x28, 0x23, 0xb9, 0xb7, 0x8d, 0x79, 0xcc, 0x06, 0xd3, 0x4c, 0x34, 0x8b, 0x14, 0xa1, - 0xa1, 0x5a, 0xbd, 0x64, + 0x09, 0x6b, 0x25, 0xc3, 0xc8, 0x41, 0x5f, 0x04, 0xd8, 0x83, 0x27, 0x43, 0xeb, 0x2f, + 0x84, 0x56, 0xd5, 0xf0, 0xa6, 0x44, 0x91, 0x3d, 0x3e, 0xc5, 0x9d, 0x34, 0xf4, 0x55, + 0x25, 0x01, 0xfa, 0x20, ], Core::RightPadLow8_32 => [ - 0x8f, 0x80, 0xa6, 0xc2, 0x74, 0x71, 0x6b, 0x67, 0x22, 0x04, 0x11, 0x34, 0xea, 0x1c, - 0x68, 0xaa, 0xbf, 0x02, 0x13, 0x29, 0x8f, 0x4e, 0x18, 0xf8, 0xf4, 0x92, 0xdc, 0x53, - 0x80, 0x8a, 0x31, 0x74, + 0xfc, 0x7f, 0x57, 0x22, 0xa6, 0x2a, 0xa2, 0x20, 0x18, 0xcc, 0x81, 0xcd, 0x00, 0xa9, + 0x32, 0x6c, 0x7f, 0xe9, 0xc6, 0x3a, 0xbc, 0xe2, 0xbd, 0xa4, 0xc0, 0xe6, 0x6a, 0x3f, + 0x47, 0xc6, 0x7c, 0x53, ], Core::RightPadLow8_64 => [ - 0xd6, 0x9c, 0x85, 0xe7, 0xb2, 0xd7, 0xe9, 0x49, 0x43, 0x6c, 0xb1, 0x29, 0x5e, 0x4a, - 0xa7, 0x05, 0x57, 0xd7, 0x5e, 0x7c, 0xbd, 0xec, 0x02, 0xcc, 0xa8, 0x5f, 0xbf, 0xb1, - 0x33, 0x08, 0xb2, 0x10, + 0xa5, 0xbb, 0x7d, 0x5e, 0xfc, 0xa0, 0xe4, 0x8d, 0x9d, 0x80, 0xc5, 0x02, 0x71, 0x15, + 0xb4, 0x85, 0x78, 0x10, 0x51, 0xe0, 0xef, 0x46, 0xe4, 0xd6, 0x08, 0x31, 0x7a, 0x1c, + 0x42, 0x61, 0xbc, 0x46, ], Core::RightRotate16 => [ - 0xe5, 0x10, 0x70, 0x82, 0x47, 0xf9, 0x1b, 0x4f, 0x0a, 0x8a, 0x22, 0xa4, 0x46, 0xb8, - 0x13, 0x7d, 0x0d, 0x42, 0xbe, 0xe7, 0x4c, 0x8c, 0x1e, 0xdd, 0x6d, 0x44, 0x6e, 0xdb, - 0x20, 0x13, 0xb5, 0x98, + 0x48, 0x2e, 0xa7, 0xe1, 0x21, 0x45, 0x01, 0xd9, 0x3c, 0x9a, 0xd1, 0x6f, 0xa8, 0xb9, + 0x7b, 0xf5, 0xb3, 0x84, 0xfc, 0x2b, 0x54, 0x78, 0x9b, 0x8c, 0xd9, 0xe7, 0x84, 0xcc, + 0xd0, 0xeb, 0x9d, 0x57, ], Core::RightRotate32 => [ - 0x98, 0x91, 0x57, 0x31, 0x41, 0x29, 0x22, 0xdb, 0xc5, 0x16, 0xa7, 0x37, 0x3a, 0xfc, - 0x4d, 0xe6, 0x48, 0x09, 0xf8, 0x3b, 0x26, 0x4b, 0xcf, 0xca, 0x6a, 0xe7, 0x48, 0x83, - 0xdb, 0xe1, 0x04, 0xd6, + 0x09, 0x41, 0xb6, 0xee, 0xea, 0x9a, 0xf8, 0x19, 0x5b, 0x02, 0x8a, 0xfc, 0x0b, 0xd2, + 0xa5, 0x34, 0x21, 0x8b, 0xf9, 0x0d, 0x1a, 0x0e, 0x37, 0x3d, 0x74, 0x74, 0x18, 0x54, + 0x0b, 0x72, 0x6d, 0x73, ], Core::RightRotate64 => [ - 0x9e, 0x2f, 0xb9, 0x8a, 0xdf, 0x10, 0x29, 0x33, 0x9d, 0xbe, 0x45, 0xa2, 0x2a, 0x54, - 0xa3, 0x90, 0xca, 0x09, 0x86, 0xed, 0xce, 0xa3, 0x2e, 0xac, 0xb8, 0x2e, 0xbc, 0xc8, - 0x94, 0xa2, 0x71, 0x1a, + 0x44, 0x4d, 0xbb, 0xc3, 0xdd, 0x2a, 0x11, 0xa5, 0xc7, 0xb0, 0x43, 0x9f, 0xdb, 0xa9, + 0x9a, 0xc7, 0x4a, 0x11, 0xb8, 0xee, 0xb2, 0xdb, 0x30, 0x1e, 0x24, 0x3e, 0xa8, 0x91, + 0x22, 0x90, 0x71, 0x52, ], Core::RightRotate8 => [ - 0x00, 0xc7, 0xc2, 0x6d, 0x95, 0xa5, 0x0b, 0x5a, 0xf9, 0x34, 0x9f, 0xfe, 0x47, 0xe1, - 0xd4, 0x3f, 0x3d, 0x76, 0x1f, 0x17, 0xa7, 0x45, 0x3c, 0x98, 0x47, 0x91, 0xe8, 0x7d, - 0xc6, 0xa3, 0x11, 0xc8, + 0x72, 0x65, 0xa3, 0x0c, 0x2e, 0x83, 0x6e, 0x65, 0x54, 0x4a, 0xba, 0x91, 0x1b, 0x64, + 0xd1, 0x8f, 0xa6, 0x9b, 0x17, 0x65, 0x45, 0x85, 0x6c, 0x77, 0xc4, 0xf0, 0xd7, 0x6f, + 0xc3, 0xf5, 0x83, 0x51, ], Core::RightShift16 => [ - 0x8b, 0x5e, 0x0f, 0xeb, 0x95, 0x81, 0x30, 0xf0, 0x50, 0x83, 0x32, 0x15, 0x9e, 0x54, - 0xc2, 0xdf, 0x98, 0xaf, 0x83, 0x52, 0x1a, 0xca, 0xb3, 0x08, 0x4f, 0xd4, 0xf7, 0xc3, - 0xa2, 0xcc, 0xea, 0x77, + 0xcd, 0x57, 0xa3, 0xd3, 0xab, 0x2d, 0x92, 0xd4, 0xf0, 0x86, 0x55, 0x04, 0x3a, 0x8b, + 0x8b, 0xb6, 0x73, 0x89, 0x81, 0xfa, 0xe6, 0xda, 0x01, 0x34, 0xb4, 0xde, 0xda, 0xce, + 0x5f, 0x00, 0x88, 0x60, ], Core::RightShift32 => [ - 0x4b, 0x1f, 0x25, 0x80, 0xe0, 0x85, 0x0d, 0x38, 0xe2, 0xa1, 0x15, 0x73, 0x38, 0x05, - 0x2f, 0x1c, 0x37, 0x9f, 0x9d, 0x81, 0x57, 0xf6, 0x2d, 0x33, 0x89, 0x0a, 0xf2, 0x4f, - 0xd9, 0xa7, 0xf7, 0x3e, + 0xd6, 0xb3, 0x26, 0xb1, 0xa3, 0x23, 0x57, 0xa3, 0x32, 0x80, 0x7d, 0x3f, 0xa1, 0xb1, + 0x56, 0xc2, 0x8b, 0x16, 0x22, 0xf7, 0x38, 0xde, 0xf1, 0x26, 0x81, 0x46, 0x7f, 0x34, + 0x9b, 0xd3, 0x49, 0x4b, ], Core::RightShift64 => [ - 0x91, 0xa2, 0x97, 0xd7, 0xb5, 0x8a, 0x39, 0x3b, 0xf5, 0x90, 0x25, 0x94, 0x77, 0x47, - 0xc8, 0x6d, 0xd4, 0x87, 0x65, 0x9c, 0xc5, 0x6f, 0xb5, 0xa6, 0xf6, 0x43, 0x99, 0x55, - 0x12, 0x9a, 0x95, 0x63, + 0xb2, 0x09, 0x5f, 0x2d, 0x47, 0x33, 0x5d, 0x5f, 0x98, 0xc8, 0x54, 0x34, 0xa2, 0xfa, + 0xf5, 0xb0, 0xf7, 0x5c, 0xf8, 0x99, 0x01, 0x2a, 0x34, 0xbb, 0xcd, 0x0a, 0x14, 0xcb, + 0xed, 0xb6, 0x11, 0x07, ], Core::RightShift8 => [ - 0xa4, 0xc3, 0x54, 0x6f, 0xf2, 0x7e, 0x56, 0xd6, 0x4e, 0x91, 0x8a, 0xb2, 0xfa, 0x6d, - 0x00, 0xfc, 0x27, 0x04, 0x58, 0x5b, 0x25, 0xbd, 0xe0, 0x04, 0x9d, 0x6d, 0x8f, 0x48, - 0xd8, 0xcf, 0x1c, 0xd0, + 0x4b, 0x2b, 0x1a, 0xa2, 0xef, 0x73, 0x21, 0x73, 0x17, 0x0d, 0x62, 0x1a, 0x38, 0xde, + 0xb2, 0x61, 0xe4, 0x73, 0xc0, 0x7c, 0x55, 0x8b, 0x05, 0x5a, 0x25, 0xa8, 0x6e, 0x4e, + 0x32, 0x1a, 0xfc, 0x04, ], Core::RightShiftWith16 => [ - 0xfd, 0x97, 0x70, 0x30, 0xe3, 0xa2, 0x5a, 0x32, 0xe7, 0x75, 0xb8, 0xd5, 0xe8, 0x71, - 0x74, 0xa7, 0xa9, 0xe8, 0x73, 0x1e, 0xc3, 0x6c, 0xf1, 0x32, 0x64, 0x20, 0xad, 0x91, - 0x50, 0x2e, 0x6e, 0x98, + 0x14, 0xb7, 0x76, 0x85, 0x47, 0xb3, 0xd3, 0xf4, 0x7e, 0xe5, 0xc2, 0xb8, 0x0d, 0x9b, + 0xda, 0xe2, 0xae, 0xc1, 0xf9, 0xc6, 0x59, 0x4e, 0xd3, 0x12, 0x7b, 0x12, 0x64, 0x5a, + 0xdc, 0xf5, 0x97, 0x54, ], Core::RightShiftWith32 => [ - 0x28, 0x29, 0xba, 0x02, 0x1f, 0x54, 0x07, 0x7a, 0xff, 0xb6, 0x6a, 0xc6, 0xb6, 0xdf, - 0xd3, 0xfe, 0xf3, 0x8b, 0xc4, 0x14, 0x91, 0x84, 0x5a, 0x41, 0xce, 0x9d, 0xd3, 0x70, - 0x58, 0x6c, 0x2d, 0x04, + 0x32, 0x7b, 0x6e, 0x98, 0xa6, 0xfd, 0x34, 0x0c, 0x60, 0xcf, 0x83, 0xaa, 0x64, 0x99, + 0x33, 0x11, 0x4c, 0xb8, 0xd8, 0x4f, 0x59, 0x0e, 0x01, 0x21, 0x3a, 0x26, 0x10, 0x01, + 0x2b, 0x46, 0x07, 0xea, ], Core::RightShiftWith64 => [ - 0x00, 0x6f, 0xa3, 0xc5, 0x45, 0x79, 0x75, 0x47, 0x86, 0xfc, 0x64, 0xdc, 0x32, 0xe1, - 0x9a, 0x22, 0x5c, 0xc1, 0x52, 0xc9, 0x4d, 0xee, 0xb3, 0xc6, 0xab, 0x29, 0x67, 0xdd, - 0xbf, 0xc6, 0x46, 0x53, + 0x06, 0x2f, 0xa7, 0x4a, 0xf3, 0x47, 0x6e, 0x59, 0x38, 0x7b, 0xe0, 0x8e, 0x69, 0x49, + 0xa0, 0x05, 0x43, 0xbc, 0x84, 0xa2, 0xb6, 0x89, 0xea, 0x39, 0xad, 0x6e, 0xed, 0x7f, + 0x75, 0x67, 0x85, 0xd4, ], Core::RightShiftWith8 => [ - 0xfc, 0xb5, 0xbe, 0x65, 0x07, 0xf0, 0xca, 0x44, 0xbe, 0x2b, 0xe1, 0xcc, 0x3c, 0x3c, - 0xfe, 0x39, 0x94, 0x40, 0x4b, 0x80, 0x83, 0xbd, 0x76, 0x02, 0xb2, 0x10, 0x2c, 0xb1, - 0xfc, 0xfa, 0x2c, 0x61, + 0x14, 0x1b, 0xe4, 0x7e, 0x96, 0x7b, 0x2f, 0xd7, 0xc7, 0x12, 0x6c, 0x5a, 0xdf, 0x2d, + 0xfe, 0x47, 0x31, 0x5b, 0xbc, 0x10, 0x53, 0xbb, 0xe6, 0x05, 0xb3, 0x88, 0x98, 0xdb, + 0xed, 0x49, 0xf2, 0x27, ], Core::Rightmost16_1 => [ 0x3f, 0x3c, 0x43, 0x46, 0x87, 0x17, 0x42, 0x26, 0x5e, 0x87, 0xf0, 0x01, 0xb4, 0x6d, @@ -2295,14 +2302,14 @@ impl Jet for Core { 0x8d, 0x9b, 0x98, 0xa4, ], Core::Rightmost16_2 => [ - 0x78, 0xf1, 0x71, 0x47, 0x6a, 0x3b, 0x0e, 0xd1, 0xe3, 0xa5, 0x45, 0x5a, 0x5f, 0xbb, - 0xcc, 0x90, 0x19, 0x81, 0xb3, 0x23, 0x0f, 0xea, 0x12, 0x64, 0x20, 0x4d, 0xac, 0xd0, - 0x81, 0xf9, 0x40, 0x80, + 0xc1, 0x8b, 0x9f, 0xdd, 0x34, 0x0a, 0x26, 0x7a, 0xc1, 0x6d, 0x4f, 0x39, 0xee, 0x75, + 0x43, 0x56, 0x52, 0xaa, 0xca, 0x52, 0x56, 0x50, 0xb5, 0x1a, 0x45, 0x87, 0x98, 0x04, + 0x8e, 0x62, 0x7d, 0x51, ], Core::Rightmost16_4 => [ - 0x75, 0xa1, 0xdf, 0xb6, 0xae, 0x2c, 0x06, 0x6b, 0x2d, 0x0e, 0x20, 0x93, 0x04, 0x8a, - 0xdb, 0xc5, 0x0d, 0x46, 0x50, 0x65, 0x6f, 0xb2, 0xd3, 0x57, 0x8b, 0x57, 0xd9, 0xde, - 0x4c, 0x61, 0xc8, 0xb5, + 0xc6, 0xc5, 0x3f, 0xa7, 0x1e, 0x23, 0x0c, 0xf0, 0x58, 0x51, 0x58, 0xf4, 0x70, 0x58, + 0x8b, 0xac, 0x5c, 0x51, 0x8f, 0x84, 0xf9, 0xfc, 0x23, 0x86, 0x52, 0xf1, 0x75, 0xfb, + 0x6e, 0xa1, 0x8c, 0x11, ], Core::Rightmost16_8 => [ 0xee, 0x76, 0x9c, 0x1c, 0xc8, 0xa3, 0xfd, 0xd1, 0x83, 0x8f, 0xc9, 0xf0, 0x49, 0x0c, @@ -2310,14 +2317,14 @@ impl Jet for Core { 0xc4, 0x43, 0x11, 0xbd, ], Core::Rightmost32_1 => [ - 0xcb, 0x0d, 0xb5, 0x69, 0xa3, 0x61, 0x86, 0xa2, 0x56, 0x05, 0xa9, 0xd2, 0xe4, 0xe1, - 0x0a, 0x20, 0xc1, 0x11, 0xd5, 0x0c, 0x34, 0xf1, 0x72, 0x46, 0x52, 0x0b, 0xc4, 0x54, - 0xd8, 0x68, 0x28, 0x36, + 0x1c, 0x44, 0x23, 0x69, 0xfb, 0x81, 0xf6, 0x11, 0xd3, 0x28, 0x01, 0x0b, 0x86, 0x4b, + 0xcc, 0xb7, 0xf3, 0x5e, 0xd4, 0x77, 0xdf, 0xa3, 0x85, 0x55, 0x74, 0xc1, 0x35, 0x64, + 0xcd, 0xbd, 0xb8, 0x60, ], Core::Rightmost32_16 => [ - 0x06, 0xfa, 0xa3, 0xbe, 0x67, 0x8c, 0xd6, 0xfd, 0xd7, 0xf3, 0x11, 0x2e, 0xbf, 0x2c, - 0x48, 0x62, 0x7a, 0xfa, 0x78, 0x75, 0xf7, 0x06, 0x8d, 0x26, 0xa9, 0xcc, 0x04, 0x5b, - 0x2c, 0x8f, 0x11, 0xbc, + 0xad, 0xd2, 0xc3, 0x39, 0x0d, 0x9a, 0xf7, 0xc2, 0x4a, 0x15, 0x9a, 0x37, 0xd6, 0x9d, + 0x44, 0x84, 0xd2, 0xc2, 0x4a, 0x2c, 0xb5, 0xb0, 0xeb, 0x2d, 0x3c, 0x49, 0x3d, 0x98, + 0x12, 0xac, 0xfd, 0x74, ], Core::Rightmost32_2 => [ 0x00, 0xb8, 0x81, 0x5a, 0xd7, 0x42, 0x3d, 0xd5, 0x8c, 0xb9, 0x8b, 0xe8, 0x2c, 0xad, @@ -2325,69 +2332,69 @@ impl Jet for Core { 0x5a, 0x4e, 0x8c, 0xe6, ], Core::Rightmost32_4 => [ - 0x3d, 0xfa, 0x7a, 0x20, 0x19, 0x8e, 0x42, 0xd6, 0xa7, 0x94, 0x8c, 0x8e, 0xd8, 0xe0, - 0xd4, 0x7e, 0xc7, 0xc0, 0x00, 0x7b, 0x3d, 0x68, 0x66, 0xca, 0x15, 0xe3, 0xda, 0x04, - 0x5b, 0x85, 0x63, 0xc7, + 0x84, 0xfa, 0x5a, 0x54, 0xf7, 0x72, 0x9f, 0x9d, 0x68, 0x99, 0x4b, 0xea, 0xb9, 0x3a, + 0xe7, 0x9b, 0x8c, 0x4a, 0x10, 0xd5, 0xb7, 0xae, 0x97, 0x27, 0xaa, 0x17, 0x16, 0xe5, + 0x7d, 0x03, 0x3b, 0x74, ], Core::Rightmost32_8 => [ - 0x17, 0xb5, 0x8d, 0x6e, 0x30, 0x4b, 0x1c, 0x7e, 0x5d, 0xbf, 0x0c, 0x4d, 0xf6, 0xfc, - 0xc8, 0x03, 0xc0, 0x08, 0x94, 0x4c, 0x79, 0x95, 0x55, 0x5b, 0x94, 0xe1, 0x28, 0x9b, - 0x25, 0x49, 0xbe, 0x99, + 0x7d, 0x38, 0x05, 0xd3, 0xc7, 0x8c, 0x4e, 0xea, 0x91, 0xe3, 0xd3, 0x5e, 0xfd, 0xd4, + 0x7e, 0xed, 0xd4, 0x21, 0xaf, 0x84, 0xd2, 0x19, 0x10, 0x32, 0x93, 0x32, 0xa0, 0xb5, + 0x48, 0x7f, 0xab, 0x63, ], Core::Rightmost64_1 => [ - 0x5e, 0x8f, 0xb4, 0x9f, 0xac, 0xe0, 0x34, 0x48, 0x1d, 0xc6, 0x53, 0x61, 0x8e, 0x2a, - 0x8b, 0x65, 0xea, 0xf0, 0x99, 0x3f, 0x28, 0x84, 0x4c, 0xc9, 0xb1, 0x30, 0xca, 0xcc, - 0xe4, 0x5e, 0x82, 0xde, + 0xd3, 0xb1, 0x64, 0xc5, 0xdc, 0x66, 0xcc, 0x7e, 0xf9, 0x23, 0x4f, 0xed, 0xe4, 0xdc, + 0x7f, 0x0d, 0xa5, 0xcd, 0x71, 0xc1, 0xc1, 0xd4, 0xca, 0xd6, 0x0f, 0xb4, 0xec, 0x57, + 0x3e, 0x2b, 0x8a, 0x75, ], Core::Rightmost64_16 => [ - 0xc6, 0x4c, 0xa9, 0x96, 0x55, 0x36, 0xf2, 0x37, 0xbc, 0x4d, 0x16, 0x6e, 0x4a, 0xec, - 0xa5, 0x6e, 0xac, 0x26, 0x62, 0xe6, 0x3a, 0xcc, 0xb9, 0x8b, 0x6e, 0x54, 0x25, 0x60, - 0xf9, 0xe5, 0x38, 0xda, + 0xea, 0xe4, 0x34, 0x78, 0xf9, 0xf2, 0xf4, 0x52, 0xef, 0xac, 0x15, 0xee, 0xe6, 0x0f, + 0x8b, 0x52, 0x53, 0xd8, 0x0a, 0x2d, 0x32, 0x12, 0x9b, 0x4e, 0x5b, 0xa3, 0x83, 0x00, + 0xad, 0x98, 0x52, 0xfd, ], Core::Rightmost64_2 => [ - 0x83, 0xd2, 0xda, 0x6f, 0x34, 0x20, 0xd7, 0x79, 0xbc, 0xb8, 0xf6, 0x0d, 0x0b, 0x69, - 0x6e, 0xed, 0x74, 0xc3, 0x1d, 0xb0, 0x8a, 0xdd, 0xbe, 0xbd, 0x12, 0x35, 0xa5, 0xdf, - 0x8f, 0x59, 0xc4, 0x2f, + 0x9c, 0xd4, 0xa9, 0x8b, 0xbd, 0xb8, 0xa3, 0x35, 0x85, 0xc0, 0x0f, 0x47, 0xd6, 0xad, + 0xab, 0x7a, 0xf5, 0x42, 0x86, 0xfb, 0x8a, 0xe6, 0x0f, 0x72, 0x30, 0x11, 0xfb, 0x84, + 0xc0, 0xee, 0x78, 0xf9, ], Core::Rightmost64_32 => [ - 0x7d, 0x2d, 0xff, 0x6e, 0x3d, 0xd5, 0x04, 0xbb, 0x0e, 0x57, 0x03, 0xa0, 0x33, 0x58, - 0x6d, 0x27, 0xd9, 0x66, 0x44, 0xc0, 0x48, 0xab, 0x34, 0xa4, 0x5b, 0xf5, 0x35, 0x12, - 0x9d, 0x50, 0x11, 0x67, + 0x7f, 0x24, 0x20, 0xae, 0x5b, 0x0f, 0x5a, 0x3f, 0x6f, 0x2e, 0x60, 0xb6, 0x1f, 0x8a, + 0x41, 0x5c, 0x08, 0x8b, 0x94, 0xb2, 0x1c, 0x1a, 0x62, 0xa3, 0xfd, 0xaa, 0xc7, 0x49, + 0xdb, 0xdf, 0x4c, 0x71, ], Core::Rightmost64_4 => [ - 0x84, 0x1b, 0xbd, 0x65, 0x27, 0x42, 0xdd, 0xd3, 0xad, 0xea, 0xe4, 0x3c, 0xfe, 0xd6, - 0x32, 0x9f, 0x2f, 0xd6, 0x2e, 0x6f, 0xec, 0xd0, 0xfd, 0x58, 0xe3, 0xc3, 0xfb, 0x8b, - 0x5a, 0x0e, 0x4d, 0xd5, + 0xe2, 0x65, 0x55, 0x2a, 0x24, 0xfb, 0xcd, 0xec, 0x05, 0x83, 0xd7, 0x18, 0x3e, 0x48, + 0xeb, 0xc2, 0xff, 0x6d, 0x31, 0x65, 0x57, 0xba, 0xc5, 0x91, 0x5c, 0x03, 0xcb, 0x23, + 0x35, 0xd2, 0x32, 0x95, ], Core::Rightmost64_8 => [ - 0xa0, 0xa6, 0x1c, 0x76, 0x58, 0xa1, 0x86, 0x23, 0xbf, 0x1d, 0x01, 0x1a, 0x97, 0x92, - 0xd5, 0x18, 0xfb, 0xd0, 0x24, 0x14, 0x2a, 0x90, 0x44, 0x00, 0xec, 0xde, 0xea, 0x92, - 0x45, 0x7a, 0x0a, 0x81, + 0x98, 0xcd, 0x95, 0xf9, 0x5d, 0x46, 0x64, 0x1b, 0x04, 0x9e, 0x77, 0xbf, 0x90, 0xee, + 0xa5, 0x98, 0xad, 0xf2, 0x9e, 0xe5, 0x00, 0xe6, 0x50, 0x72, 0x87, 0x54, 0x8b, 0xb1, + 0xcd, 0xaf, 0x78, 0x4d, ], Core::Rightmost8_1 => [ - 0x99, 0x9b, 0x68, 0x6e, 0x60, 0xb3, 0xd1, 0xec, 0xd6, 0xc6, 0xd7, 0x7f, 0xbc, 0xa8, - 0x2c, 0xb2, 0xab, 0xbd, 0x41, 0x82, 0xc8, 0x21, 0x12, 0x67, 0x47, 0x5f, 0xa0, 0xc1, - 0x90, 0x1d, 0x89, 0xf9, + 0x08, 0x76, 0xfc, 0xd4, 0x69, 0x85, 0x91, 0xf3, 0x31, 0x91, 0x01, 0x57, 0x4c, 0xe1, + 0x53, 0xfc, 0xdf, 0xe9, 0x4f, 0x58, 0x1a, 0xac, 0x5e, 0x75, 0xf3, 0xcd, 0x74, 0x46, + 0xdf, 0x56, 0xf3, 0xc7, ], Core::Rightmost8_2 => [ - 0x53, 0x07, 0xff, 0xbf, 0x51, 0x6c, 0xd0, 0xee, 0xf3, 0xff, 0x43, 0x87, 0xb9, 0x05, - 0x2c, 0x14, 0x4a, 0x4d, 0xfa, 0x23, 0x29, 0x23, 0x7c, 0x6b, 0x27, 0x49, 0x92, 0xb2, - 0xc8, 0x04, 0x7b, 0x60, + 0xb9, 0xf7, 0xb2, 0x90, 0xaf, 0xe7, 0xf1, 0x89, 0xe3, 0x2a, 0xeb, 0xf2, 0xcc, 0x4d, + 0xdc, 0xa9, 0x6b, 0xb0, 0x07, 0x64, 0xc7, 0xbe, 0x28, 0x87, 0xdc, 0xe0, 0x54, 0xd0, + 0x9e, 0x38, 0xc3, 0x53, ], Core::Rightmost8_4 => [ - 0x7f, 0x52, 0xe6, 0x45, 0xbb, 0xbb, 0xd7, 0x92, 0x69, 0xc4, 0x3e, 0xf0, 0x2d, 0xb9, - 0x82, 0xf8, 0xc6, 0x36, 0x33, 0xc1, 0x79, 0xe4, 0x06, 0x91, 0x73, 0x93, 0x36, 0x04, - 0xcc, 0x63, 0x5b, 0xca, + 0xf2, 0x8e, 0x9a, 0xf5, 0xaf, 0x4c, 0x9c, 0xca, 0x4b, 0x43, 0xcc, 0x6a, 0xdf, 0x9d, + 0x9d, 0x8d, 0x16, 0x9c, 0x87, 0xc5, 0x55, 0x9f, 0x9f, 0x3c, 0xca, 0xc8, 0xf2, 0x35, + 0x2b, 0x62, 0x9f, 0x18, ], Core::ScalarAdd => [ - 0x34, 0xba, 0xa4, 0x0b, 0x2e, 0x0a, 0xa8, 0xcb, 0x7e, 0x97, 0xc7, 0x3e, 0x3e, 0xd3, - 0xb3, 0x65, 0xa1, 0x5b, 0x7c, 0x3f, 0x76, 0x61, 0xfb, 0x19, 0x71, 0x5e, 0xc6, 0x05, - 0xc1, 0x14, 0x9d, 0x11, + 0x11, 0xdd, 0xbe, 0xba, 0xeb, 0xf4, 0x21, 0x80, 0xa0, 0xb7, 0xed, 0xdf, 0xfd, 0xc4, + 0x8e, 0xc7, 0x51, 0x13, 0x30, 0xfb, 0x33, 0x15, 0xfa, 0x65, 0xd5, 0x8a, 0xff, 0x66, + 0xb9, 0xca, 0xf2, 0xd4, ], Core::ScalarInvert => [ - 0x62, 0x31, 0xbd, 0xab, 0x73, 0xca, 0x34, 0xea, 0x7e, 0x83, 0x7d, 0xaa, 0xd6, 0x92, - 0xed, 0xe5, 0xba, 0xbf, 0xae, 0x09, 0xb5, 0x75, 0x6d, 0x2a, 0xb3, 0x6c, 0x5a, 0x36, - 0x47, 0x5a, 0x65, 0x89, + 0xa6, 0x39, 0x27, 0x25, 0xbb, 0x2d, 0xad, 0xbb, 0x1e, 0x76, 0xdf, 0x2d, 0xec, 0x57, + 0xdf, 0x55, 0xc3, 0xfc, 0xc5, 0x77, 0x3b, 0x62, 0x21, 0x8a, 0xec, 0x55, 0xa7, 0x5e, + 0x14, 0xf3, 0xd6, 0x0d, ], Core::ScalarIsZero => [ 0xf7, 0x5e, 0xda, 0x06, 0xce, 0x6a, 0xf0, 0x9f, 0xae, 0x37, 0xdb, 0x4e, 0x62, 0x25, @@ -2395,219 +2402,219 @@ impl Jet for Core { 0xf3, 0xb3, 0x9d, 0x90, ], Core::ScalarMultiply => [ - 0xb2, 0xbc, 0xc3, 0x90, 0xd6, 0x37, 0xb9, 0xe0, 0x3f, 0xbf, 0xc4, 0x2f, 0xff, 0x71, - 0xd2, 0x2e, 0x72, 0x00, 0xf6, 0x93, 0x29, 0xce, 0xf7, 0x16, 0x9e, 0x68, 0xa8, 0xc7, - 0x1a, 0x7f, 0x0a, 0x4b, + 0x4a, 0x61, 0x67, 0x2a, 0xce, 0xc4, 0x88, 0x77, 0x56, 0xde, 0x1d, 0xb6, 0x04, 0x21, + 0xa1, 0x2b, 0x90, 0x1a, 0x85, 0x8a, 0x6e, 0xe6, 0x35, 0x2e, 0x55, 0x9d, 0x4c, 0xe5, + 0x97, 0x33, 0x52, 0xbe, ], Core::ScalarMultiplyLambda => [ - 0x89, 0xd5, 0x85, 0x5c, 0x5f, 0x85, 0xc0, 0x03, 0x5d, 0x27, 0xb0, 0xc0, 0x9e, 0x20, - 0x33, 0x0b, 0x00, 0x1c, 0x68, 0x4b, 0x59, 0x86, 0xab, 0xce, 0xd8, 0x36, 0x0c, 0xd3, - 0x9b, 0x08, 0xc4, 0xe1, + 0x49, 0xea, 0x9c, 0x3f, 0xb1, 0xd8, 0xff, 0x52, 0xd2, 0xdb, 0x03, 0x46, 0x9f, 0xdf, + 0xe8, 0x50, 0x50, 0x3f, 0xdd, 0xeb, 0x45, 0xe1, 0x6d, 0x26, 0xe8, 0x92, 0x8a, 0xdd, + 0x25, 0x87, 0x0e, 0x91, ], Core::ScalarNegate => [ - 0x07, 0x05, 0xac, 0xdf, 0xb8, 0x66, 0x40, 0x00, 0x0e, 0x3d, 0x3b, 0xad, 0x50, 0x9a, - 0x14, 0xa7, 0x8c, 0x17, 0x1f, 0x61, 0xed, 0xc0, 0x84, 0x23, 0xb0, 0x42, 0xb9, 0x47, - 0x48, 0x43, 0x9c, 0xf8, + 0x1d, 0xbf, 0x8b, 0x49, 0x1e, 0xc6, 0x65, 0x80, 0x3f, 0x63, 0x33, 0x30, 0xd3, 0xff, + 0xb0, 0xe7, 0x81, 0xe6, 0x7c, 0x18, 0x01, 0xac, 0x9d, 0x49, 0xbb, 0xf4, 0x35, 0x89, + 0xab, 0xf7, 0x82, 0xbf, ], Core::ScalarNormalize => [ - 0xa0, 0x61, 0xe1, 0x9d, 0x75, 0xc3, 0x25, 0xa2, 0x6d, 0x56, 0x5a, 0xad, 0x7e, 0x3f, - 0x9a, 0xe2, 0x6b, 0x22, 0x2f, 0x25, 0xe8, 0x02, 0x17, 0x4f, 0x6b, 0xac, 0xd5, 0x11, - 0x27, 0x7a, 0xea, 0xa5, + 0x46, 0x33, 0x18, 0x0e, 0xa0, 0x2c, 0x4d, 0xf7, 0x81, 0x9d, 0x3d, 0x54, 0xa4, 0x01, + 0x73, 0x4f, 0x96, 0x5b, 0x31, 0xac, 0xc7, 0x84, 0x05, 0x4e, 0xbf, 0xb7, 0x31, 0x68, + 0x16, 0xb0, 0x29, 0xec, ], Core::ScalarSquare => [ - 0x49, 0xf7, 0x34, 0xa2, 0x65, 0x9c, 0xa0, 0xab, 0x7c, 0x9e, 0x67, 0xfc, 0xfc, 0x3c, - 0x0d, 0x72, 0xaf, 0x0f, 0x91, 0x7c, 0x9e, 0xdc, 0xb9, 0x92, 0x9d, 0x17, 0x7a, 0x0f, - 0x0d, 0xe8, 0x9d, 0x59, + 0x8a, 0x27, 0x9e, 0x6f, 0x61, 0x3a, 0xa9, 0xe9, 0x34, 0xf2, 0xf2, 0xa3, 0x43, 0xc0, + 0xd3, 0x29, 0x1c, 0x36, 0x70, 0xe2, 0x97, 0xdd, 0xae, 0x20, 0x52, 0x9e, 0x82, 0x50, + 0x69, 0xef, 0xea, 0x0e, ], Core::Scale => [ - 0xc0, 0x45, 0x43, 0xdc, 0x85, 0xef, 0x11, 0x37, 0x4a, 0x93, 0x0f, 0x4a, 0x94, 0x8e, - 0xb7, 0x35, 0xa6, 0x50, 0x0a, 0x1a, 0x71, 0x58, 0xd5, 0x73, 0x12, 0x3f, 0x07, 0x21, - 0x71, 0x75, 0xf3, 0x18, + 0x12, 0x6e, 0x22, 0x12, 0x5b, 0xac, 0x80, 0xb9, 0x9b, 0x7b, 0x73, 0x43, 0xb4, 0xe5, + 0xe5, 0x86, 0x60, 0x82, 0x16, 0x10, 0x5d, 0x4d, 0xe6, 0xf7, 0x94, 0xad, 0xd3, 0x4e, + 0x23, 0xb1, 0x95, 0xca, ], Core::Sha256Block => [ - 0x0c, 0x97, 0xa0, 0x08, 0xad, 0xe8, 0x7b, 0xb1, 0xe0, 0xac, 0x06, 0xb7, 0xd0, 0x31, - 0x30, 0x23, 0x36, 0x28, 0x58, 0xef, 0x90, 0xec, 0x14, 0xec, 0x9c, 0xb9, 0x5f, 0x0d, - 0xa9, 0x64, 0xe0, 0x08, + 0x45, 0x35, 0xf3, 0xe1, 0xab, 0x9f, 0x1b, 0x75, 0x7a, 0x06, 0x91, 0x37, 0xe1, 0xd5, + 0xb1, 0xca, 0xad, 0x8e, 0x31, 0xf7, 0x8d, 0xc5, 0xfb, 0xd0, 0x73, 0x46, 0x49, 0xf9, + 0x40, 0xa7, 0xfc, 0x96, ], Core::Sha256Ctx8Add1 => [ - 0x37, 0x06, 0x6c, 0x67, 0xad, 0x95, 0x24, 0x9d, 0x4b, 0xa6, 0xe1, 0x81, 0x44, 0xca, - 0x0a, 0x41, 0x5d, 0x9c, 0x83, 0x2a, 0xa6, 0xb6, 0x06, 0x28, 0xe9, 0x7c, 0x96, 0x7e, - 0xb1, 0x79, 0x33, 0x83, + 0x9a, 0x47, 0x11, 0xb8, 0xc5, 0x69, 0x0e, 0x58, 0x7e, 0x5f, 0x79, 0xe6, 0x8d, 0x6e, + 0xca, 0x04, 0x74, 0x58, 0xaa, 0x63, 0xb8, 0xbc, 0x9e, 0xe5, 0x68, 0x08, 0x6a, 0x4a, + 0x1b, 0x56, 0xd8, 0x34, ], Core::Sha256Ctx8Add128 => [ - 0x2d, 0xcf, 0x48, 0x4c, 0x25, 0x7f, 0x67, 0x94, 0x0c, 0xa3, 0x75, 0xba, 0x98, 0xe8, - 0x3c, 0xe0, 0xe2, 0xa7, 0x1e, 0x16, 0xda, 0x50, 0x51, 0xd1, 0xbb, 0x19, 0xfb, 0x5f, - 0x34, 0x6f, 0x15, 0x4f, + 0x1c, 0xb1, 0xdb, 0x8a, 0x05, 0x5b, 0x31, 0x97, 0xac, 0xf0, 0xf0, 0x8c, 0xe9, 0xc6, + 0x35, 0xad, 0xd6, 0x95, 0xb6, 0x0f, 0x23, 0x4b, 0x18, 0xe0, 0xb3, 0x23, 0xc9, 0x37, + 0xb0, 0x38, 0x5a, 0xea, ], Core::Sha256Ctx8Add16 => [ - 0x82, 0x99, 0x25, 0x20, 0x40, 0xcb, 0x39, 0xe3, 0x26, 0xa2, 0x48, 0xd5, 0xc7, 0x88, - 0xf9, 0x51, 0x6d, 0x15, 0xa2, 0xff, 0x41, 0x45, 0xbb, 0x64, 0xad, 0x65, 0x77, 0xae, - 0x1a, 0x3e, 0xf7, 0x27, + 0xe0, 0x84, 0x54, 0x75, 0xeb, 0xb9, 0x01, 0x40, 0xfa, 0x4e, 0x01, 0xaf, 0x8a, 0x94, + 0x35, 0x99, 0x1a, 0xd8, 0x7a, 0xf9, 0x8c, 0x08, 0xae, 0xce, 0x11, 0x0e, 0x99, 0xcb, + 0xce, 0xcd, 0xee, 0x79, ], Core::Sha256Ctx8Add2 => [ - 0x8b, 0xae, 0x3e, 0x7e, 0x1e, 0xd4, 0xdc, 0xba, 0x6e, 0x64, 0x5a, 0xa1, 0x43, 0x41, - 0xbb, 0xae, 0x0d, 0xbb, 0x3a, 0xe2, 0x1b, 0xb6, 0x3d, 0xc0, 0x30, 0xca, 0x0e, 0x44, - 0x7a, 0x85, 0x7e, 0xc2, + 0x7d, 0x69, 0x13, 0x8f, 0x1c, 0x94, 0x2b, 0xee, 0x2f, 0xdf, 0x60, 0x0c, 0xe4, 0x4b, + 0x36, 0xff, 0x97, 0x83, 0x9d, 0xc2, 0xbb, 0xda, 0xfb, 0xd5, 0xfa, 0xb4, 0xdf, 0xbc, + 0x3c, 0x97, 0x6f, 0x29, ], Core::Sha256Ctx8Add256 => [ - 0x44, 0xb7, 0x17, 0xe1, 0x97, 0x09, 0x99, 0xb6, 0x6b, 0x69, 0x3d, 0x8c, 0x9d, 0x1d, - 0x3b, 0x06, 0x05, 0xc2, 0xb7, 0xa6, 0x21, 0x3e, 0x6b, 0xa5, 0x6c, 0x69, 0xaf, 0x8d, - 0x7f, 0xae, 0x16, 0x86, + 0x4f, 0x5c, 0x29, 0xd5, 0x36, 0x86, 0xc0, 0x60, 0x62, 0xb3, 0x83, 0x24, 0xf8, 0xaf, + 0xf1, 0x7e, 0xc5, 0x56, 0xa2, 0x95, 0xff, 0x09, 0x8b, 0x10, 0xe7, 0x05, 0xdd, 0x22, + 0xe1, 0x3b, 0xc3, 0xc9, ], Core::Sha256Ctx8Add32 => [ - 0x39, 0x23, 0x9a, 0x43, 0xa8, 0x4b, 0xac, 0x6f, 0x29, 0x69, 0xbf, 0xa9, 0x5b, 0xfe, - 0x6a, 0x04, 0xfc, 0xba, 0x80, 0x92, 0x89, 0x59, 0x39, 0xf1, 0x2a, 0x1c, 0xe0, 0xe2, - 0x63, 0x21, 0xec, 0x10, + 0xd5, 0x7b, 0x67, 0xb1, 0x74, 0xe7, 0x8e, 0x38, 0xf9, 0xbc, 0xa8, 0xe0, 0x7a, 0xdd, + 0x61, 0xc7, 0x53, 0xe2, 0xc1, 0x56, 0xd8, 0xe9, 0x83, 0x2a, 0xa6, 0x62, 0x04, 0x55, + 0x00, 0xf5, 0x1a, 0x80, ], Core::Sha256Ctx8Add4 => [ - 0xd7, 0xd7, 0x45, 0x61, 0x4b, 0x37, 0xa7, 0xe0, 0x7d, 0xce, 0x22, 0xf6, 0x4e, 0x7b, - 0x1e, 0xdf, 0xe2, 0x3b, 0xed, 0xa8, 0x51, 0xf1, 0xe7, 0x6f, 0x1a, 0x6b, 0x02, 0x8f, - 0xcc, 0x5e, 0x9f, 0xc0, + 0x95, 0xda, 0x32, 0x99, 0x3f, 0x5c, 0x7d, 0x00, 0x83, 0x06, 0x4c, 0xdf, 0xf1, 0xbe, + 0xc3, 0xb9, 0x36, 0xc6, 0x38, 0x33, 0x7a, 0xde, 0xc5, 0x47, 0x48, 0x7a, 0xf2, 0x32, + 0xd6, 0x9f, 0xdf, 0x65, ], Core::Sha256Ctx8Add512 => [ - 0xbe, 0x36, 0x80, 0x32, 0xd8, 0x6e, 0xbc, 0xf2, 0x13, 0xca, 0x45, 0xba, 0x6e, 0xca, - 0xb5, 0x4c, 0xb1, 0xf2, 0x66, 0x1d, 0x40, 0x3d, 0xa0, 0x59, 0x06, 0x30, 0x0b, 0xc5, - 0x11, 0x37, 0xaa, 0xb5, + 0x4a, 0xcb, 0x16, 0x3a, 0xa4, 0x8f, 0x09, 0xd5, 0xf2, 0x6d, 0x2b, 0x2a, 0xb1, 0x88, + 0xa6, 0xc6, 0xb6, 0xc4, 0xae, 0xdf, 0x23, 0xc9, 0x19, 0x00, 0x1c, 0x02, 0xee, 0x15, + 0xb3, 0x37, 0xa9, 0x6e, ], Core::Sha256Ctx8Add64 => [ - 0xfd, 0xc4, 0x34, 0xce, 0x83, 0xdb, 0xdc, 0xe0, 0x78, 0x2a, 0xa3, 0x6d, 0x41, 0x8d, - 0xef, 0x7f, 0x99, 0xaf, 0x82, 0x93, 0xaf, 0xb2, 0x9e, 0x83, 0x9f, 0xe4, 0x94, 0x8f, - 0x62, 0x34, 0xf7, 0x7f, + 0x52, 0xe5, 0x3e, 0xc5, 0x77, 0x0f, 0x9b, 0xe4, 0x06, 0x9a, 0xee, 0xfc, 0xb2, 0x13, + 0x22, 0xb1, 0x3a, 0xb6, 0xe3, 0x94, 0x1f, 0xdc, 0x2c, 0x85, 0xf4, 0xb4, 0x1b, 0xe6, + 0x7d, 0x38, 0xea, 0x7e, ], Core::Sha256Ctx8Add8 => [ - 0x9c, 0x98, 0x83, 0x30, 0x79, 0x9a, 0x68, 0x0b, 0xfe, 0x73, 0xd7, 0xca, 0xa3, 0x68, - 0x9f, 0xe4, 0xe4, 0x83, 0xda, 0x4e, 0xe6, 0xd8, 0x18, 0x58, 0x79, 0x27, 0xc7, 0xf4, - 0x33, 0x92, 0xde, 0xf7, + 0xc2, 0x6b, 0x28, 0xaf, 0xe5, 0xe8, 0x66, 0xd8, 0x46, 0x16, 0x81, 0x4d, 0x1a, 0x13, + 0xfb, 0x86, 0x30, 0xb9, 0xe8, 0x4e, 0x5d, 0x78, 0x15, 0x56, 0xc6, 0xd8, 0x23, 0x6e, + 0xfb, 0x45, 0xdf, 0xf9, ], Core::Sha256Ctx8AddBuffer511 => [ - 0xc0, 0x27, 0xe1, 0x06, 0x29, 0x96, 0xae, 0x94, 0xac, 0x39, 0x71, 0xa2, 0xc4, 0xfa, - 0xe5, 0x49, 0x97, 0xeb, 0xf0, 0x9b, 0x9f, 0x7d, 0xa5, 0x75, 0x63, 0x9b, 0xe6, 0x17, - 0x16, 0x7f, 0x02, 0xe3, + 0xad, 0x69, 0x90, 0x46, 0x48, 0xa8, 0x23, 0x8d, 0x00, 0xd8, 0x51, 0x63, 0xfc, 0xe8, + 0x19, 0x63, 0xa0, 0x04, 0x7a, 0xb5, 0x82, 0xbe, 0x97, 0xa4, 0x14, 0x00, 0x65, 0x59, + 0x79, 0xcf, 0xdd, 0x28, ], Core::Sha256Ctx8Finalize => [ - 0xcb, 0xba, 0x1f, 0x1d, 0x8a, 0x97, 0xab, 0x4d, 0x1f, 0xa9, 0x68, 0x6e, 0x7a, 0xee, - 0xf0, 0x66, 0xfb, 0x5b, 0xf2, 0x90, 0x71, 0x6e, 0xae, 0x10, 0xe7, 0x0b, 0x61, 0x99, - 0x96, 0xc5, 0x95, 0x94, + 0x8e, 0x45, 0xbd, 0xc3, 0x87, 0xd4, 0xed, 0xfa, 0x73, 0x35, 0x25, 0xf3, 0xab, 0x19, + 0xe4, 0x2b, 0x58, 0xec, 0xb1, 0xb5, 0xf6, 0xdc, 0xcf, 0x94, 0xed, 0xbf, 0x59, 0x95, + 0x8a, 0xe3, 0xe1, 0x16, ], Core::Sha256Ctx8Init => [ - 0xa5, 0x3c, 0x76, 0x79, 0xe3, 0xae, 0x03, 0x47, 0xd4, 0xd7, 0x91, 0x26, 0xa7, 0xc7, - 0xe4, 0x9a, 0xc0, 0xde, 0xc9, 0x0c, 0xdf, 0x93, 0x57, 0x99, 0xcd, 0xdb, 0x58, 0xda, - 0x8f, 0x44, 0x96, 0xe4, + 0x63, 0x5f, 0x64, 0x05, 0x84, 0x86, 0x85, 0xc0, 0x11, 0xfe, 0xbd, 0x41, 0xfa, 0xac, + 0x87, 0x4b, 0xbb, 0xf5, 0xb2, 0x4d, 0x5f, 0xb1, 0x2f, 0xed, 0xbc, 0xb6, 0xcb, 0xff, + 0x95, 0xa0, 0xf3, 0x66, ], Core::Sha256Iv => [ - 0x73, 0x89, 0xf0, 0x02, 0x53, 0x05, 0xdc, 0xe8, 0x28, 0xd4, 0xa1, 0xfe, 0x83, 0x74, - 0x30, 0x46, 0xa3, 0x67, 0xc9, 0x23, 0xf1, 0x8a, 0xbf, 0x36, 0x5e, 0x39, 0x1e, 0x5b, - 0x04, 0xaf, 0x1a, 0x47, + 0x12, 0xe4, 0x59, 0x37, 0x51, 0xc9, 0x46, 0x3b, 0x56, 0x25, 0x03, 0xc1, 0x40, 0xd7, + 0x8b, 0x3b, 0x75, 0x7a, 0x1f, 0x4f, 0x16, 0x32, 0x1d, 0x28, 0x62, 0xd3, 0x25, 0x43, + 0x85, 0x38, 0x97, 0x1b, ], Core::Some1 => [ - 0xfb, 0xda, 0xd6, 0xb0, 0x22, 0xa0, 0xc7, 0x8f, 0xf3, 0x56, 0x04, 0xaa, 0xfa, 0xcd, - 0x27, 0xcc, 0x10, 0xf5, 0x1e, 0xe0, 0x69, 0x8c, 0x41, 0xf1, 0xad, 0xa9, 0x03, 0x97, - 0x61, 0x8d, 0x52, 0x6f, + 0x15, 0xca, 0x4e, 0x4b, 0x82, 0xc2, 0xf9, 0x1b, 0x9a, 0x79, 0x29, 0x92, 0xcd, 0xc1, + 0xb2, 0x92, 0xab, 0x86, 0xa2, 0xd2, 0x93, 0x9c, 0x9a, 0x64, 0xb5, 0x0b, 0xe6, 0x0b, + 0xda, 0x6a, 0xb4, 0xca, ], Core::Some16 => [ - 0x7e, 0x2c, 0xcd, 0xbf, 0xc2, 0x4d, 0xd8, 0xd8, 0xa9, 0x04, 0xb0, 0x17, 0xdd, 0x4f, - 0x57, 0xe7, 0xc8, 0x74, 0x96, 0x34, 0x8a, 0xca, 0x7d, 0x04, 0x58, 0xc9, 0xd1, 0x6b, - 0x68, 0xbc, 0xda, 0x1c, + 0xa9, 0xdf, 0xbb, 0xea, 0xb5, 0x9d, 0xf7, 0x2a, 0x45, 0xfc, 0x3f, 0xc7, 0xac, 0x58, + 0x1e, 0xc8, 0xda, 0x71, 0x3f, 0x2f, 0x81, 0x03, 0xf7, 0x87, 0xaa, 0x1c, 0xee, 0x4e, + 0x0b, 0xa6, 0x48, 0x66, ], Core::Some32 => [ - 0x45, 0x36, 0xae, 0xb1, 0x21, 0xc4, 0x27, 0x3f, 0xfc, 0x2a, 0x48, 0xfe, 0xd9, 0xee, - 0xd0, 0x31, 0x2e, 0xbd, 0x97, 0x2d, 0xec, 0x56, 0x81, 0xf4, 0x7e, 0xad, 0x0f, 0x62, - 0xd9, 0x54, 0x45, 0x2a, + 0x46, 0x33, 0xa3, 0x97, 0x74, 0x2e, 0xf4, 0x82, 0xbe, 0x2f, 0xa3, 0xfb, 0x64, 0x10, + 0xec, 0x79, 0xc3, 0x73, 0x83, 0x65, 0x69, 0xfb, 0xbc, 0xb1, 0xf9, 0x48, 0xec, 0x32, + 0x48, 0x73, 0x78, 0xb7, ], Core::Some64 => [ - 0x7f, 0x0b, 0xbd, 0x9d, 0x66, 0x31, 0xc1, 0x30, 0x9f, 0x90, 0x1c, 0x2f, 0x0d, 0x7a, - 0x0d, 0x28, 0x4a, 0x34, 0x41, 0x6c, 0xf7, 0x50, 0xdb, 0x1f, 0xe2, 0xb9, 0xf3, 0xd6, - 0xed, 0x70, 0x94, 0x09, + 0x1d, 0xc2, 0x45, 0xac, 0x6f, 0x5b, 0x42, 0x2b, 0xd1, 0x88, 0x6e, 0xf5, 0x14, 0x4c, + 0x4d, 0xc7, 0x2c, 0x96, 0x73, 0x15, 0x59, 0x66, 0x07, 0x6c, 0xd8, 0x39, 0x68, 0x1d, + 0x9e, 0xc7, 0xf8, 0xf5, ], Core::Some8 => [ - 0x2d, 0x8c, 0x8f, 0x71, 0xee, 0x5e, 0x75, 0x82, 0xf0, 0xed, 0x65, 0xf5, 0x26, 0xc0, - 0x26, 0x05, 0xdc, 0xb9, 0x3c, 0x0b, 0xdd, 0xb9, 0x43, 0x3a, 0xff, 0x3f, 0x25, 0xc2, - 0x28, 0xac, 0xda, 0x8a, + 0x33, 0xaf, 0xb9, 0xc6, 0x45, 0x4e, 0x59, 0x0e, 0xc1, 0x3e, 0xd7, 0x5e, 0x1b, 0x7d, + 0x9c, 0x3a, 0x3d, 0xe6, 0x75, 0x2b, 0xcc, 0x7c, 0x1d, 0x4c, 0xb3, 0x63, 0xfa, 0x51, + 0x82, 0x8b, 0xcb, 0x74, ], Core::Subtract16 => [ - 0x56, 0x9e, 0x6c, 0x6b, 0x39, 0xe7, 0xd8, 0x12, 0x65, 0x9b, 0x67, 0xaa, 0xc0, 0x8a, - 0xd1, 0x50, 0x99, 0xee, 0xad, 0x79, 0x8f, 0xd1, 0xd4, 0x2d, 0xa1, 0x7e, 0xe3, 0xf0, - 0xd4, 0xd4, 0x49, 0x2a, + 0x4e, 0x06, 0xec, 0x31, 0x37, 0x62, 0x22, 0xe2, 0x5e, 0x27, 0xd0, 0x15, 0x9d, 0xc1, + 0xc0, 0x71, 0x4a, 0x44, 0xca, 0x6a, 0xac, 0xf9, 0x50, 0x5c, 0xaa, 0xd2, 0x80, 0xe9, + 0x73, 0xfb, 0x5c, 0xab, ], Core::Subtract32 => [ - 0x19, 0xd3, 0x5e, 0x0a, 0xf1, 0xe1, 0x65, 0x14, 0xa6, 0xdf, 0xc2, 0x9a, 0x91, 0x41, - 0x87, 0x13, 0x39, 0x64, 0xc4, 0x80, 0xf6, 0x60, 0xe7, 0xeb, 0x92, 0x4e, 0xe1, 0x6d, - 0xba, 0xa2, 0x49, 0xcb, + 0xb9, 0xc0, 0xf3, 0x6e, 0x75, 0x22, 0xa8, 0xd9, 0x49, 0x05, 0x0d, 0x51, 0x6a, 0x05, + 0xce, 0x20, 0x3a, 0x1f, 0x9a, 0x9e, 0x37, 0x2f, 0xd2, 0x63, 0xde, 0x38, 0xb0, 0xe9, + 0x03, 0x13, 0x41, 0x98, ], Core::Subtract64 => [ - 0x52, 0x3e, 0x11, 0x86, 0x28, 0xbf, 0x3a, 0xc1, 0xa6, 0xbe, 0x5a, 0x72, 0xbd, 0xb1, - 0x14, 0x1b, 0x89, 0xe0, 0xe0, 0x01, 0xe4, 0x02, 0xad, 0xda, 0x82, 0x58, 0x79, 0x00, - 0x03, 0xf8, 0x8a, 0xd8, + 0x1c, 0xdb, 0x5c, 0x74, 0xad, 0xd1, 0x02, 0xf5, 0x0f, 0x93, 0x8e, 0xd8, 0x86, 0xf4, + 0x96, 0xe5, 0xba, 0xb2, 0x75, 0x5c, 0x3c, 0x48, 0x4e, 0x88, 0x87, 0x90, 0x3d, 0x2f, + 0x6a, 0x57, 0xf3, 0xaa, ], Core::Subtract8 => [ - 0x40, 0x95, 0x0b, 0x86, 0xf6, 0xf1, 0xf9, 0x93, 0x55, 0xde, 0xe1, 0x1f, 0x77, 0xda, - 0xf2, 0x79, 0xa0, 0xcb, 0x6c, 0x6d, 0x15, 0x6a, 0xe4, 0x4b, 0x7d, 0x5d, 0x25, 0x71, - 0x64, 0xb2, 0x67, 0xc5, + 0x4f, 0x21, 0x17, 0xa0, 0xe8, 0x10, 0x59, 0xff, 0x0c, 0xd6, 0x4d, 0x84, 0x88, 0x65, + 0x42, 0xe5, 0x75, 0xea, 0x8d, 0x6e, 0xc0, 0x31, 0x08, 0xfd, 0x0b, 0x50, 0x8b, 0x39, + 0x20, 0x8c, 0xd0, 0xef, ], Core::Swu => [ - 0xab, 0xf7, 0x0b, 0xe0, 0x0b, 0x30, 0xf5, 0x77, 0xf9, 0x87, 0xcb, 0x50, 0x48, 0x89, - 0x96, 0xba, 0x35, 0x96, 0xdb, 0xf9, 0xc1, 0xe8, 0x44, 0xa8, 0xb1, 0xb8, 0xb7, 0x10, - 0x85, 0x3b, 0x65, 0xeb, + 0x00, 0xf5, 0x1f, 0x4f, 0x4b, 0xec, 0xe7, 0x90, 0x03, 0xec, 0xad, 0x48, 0x1a, 0x12, + 0x5a, 0xf7, 0x17, 0x6e, 0x4d, 0xe9, 0x8c, 0x33, 0x92, 0x42, 0x5c, 0xb9, 0x14, 0x66, + 0x26, 0xc1, 0x3b, 0x3b, ], Core::TapdataInit => [ - 0x6c, 0x67, 0xe5, 0xc1, 0x07, 0x35, 0x30, 0x5e, 0xe7, 0xde, 0xb5, 0x9a, 0x6c, 0x6a, - 0xc2, 0xef, 0xfc, 0xab, 0x4f, 0xf7, 0xbb, 0x47, 0x9e, 0xa7, 0x00, 0x81, 0x60, 0x6e, - 0x60, 0x48, 0x4c, 0xa7, + 0xa4, 0xd0, 0x22, 0xef, 0x5c, 0xf4, 0x67, 0xbc, 0xa0, 0x32, 0x5e, 0x46, 0x3f, 0xca, + 0xce, 0x7c, 0xbd, 0xd6, 0x4f, 0xf8, 0xf7, 0x1c, 0x5c, 0x7f, 0x63, 0xe6, 0x07, 0x84, + 0xaa, 0x0a, 0xc4, 0x86, ], Core::Verify => [ - 0x34, 0x3e, 0x6d, 0xc1, 0x6b, 0x3f, 0x52, 0xe8, 0x3e, 0x3b, 0x4c, 0xcc, 0x99, 0xb8, - 0xc6, 0xf9, 0x6a, 0x07, 0x4f, 0xe3, 0x99, 0x32, 0x7a, 0xf3, 0x64, 0xbc, 0x28, 0x5e, - 0x29, 0x97, 0x45, 0xa2, + 0xcd, 0xca, 0x2a, 0x05, 0xe5, 0x2c, 0xef, 0xa5, 0x9d, 0xc7, 0xa5, 0xb0, 0xda, 0xe2, + 0x20, 0x98, 0xfb, 0x89, 0x6e, 0x39, 0x13, 0xbf, 0xdd, 0x44, 0x6b, 0x59, 0x4e, 0x1f, + 0x92, 0x50, 0x78, 0x3e, ], Core::Xor1 => [ - 0x9d, 0xc9, 0xfe, 0x42, 0xf7, 0xeb, 0x34, 0x64, 0x9f, 0x1c, 0x72, 0xd2, 0xe5, 0xdd, - 0x16, 0x7d, 0xb2, 0x1b, 0xe5, 0x32, 0x13, 0x72, 0xd5, 0xca, 0x7f, 0x6a, 0x18, 0x4f, - 0x93, 0xe0, 0x5e, 0xe3, + 0x8c, 0x4e, 0x4e, 0x6e, 0xbf, 0x46, 0x30, 0xb2, 0x9b, 0x5a, 0x57, 0xea, 0x79, 0xf0, + 0xc9, 0xaf, 0x6b, 0xff, 0x54, 0xc4, 0xd2, 0xd7, 0x69, 0xbf, 0x51, 0x59, 0x47, 0x74, + 0xa5, 0x2b, 0x99, 0xc9, ], Core::Xor16 => [ - 0x1f, 0xca, 0xf4, 0x0b, 0xde, 0xdd, 0x72, 0xe7, 0x97, 0xb0, 0x9f, 0xe7, 0x87, 0x53, - 0xb0, 0xab, 0x27, 0x87, 0x2c, 0x0b, 0xd1, 0x2b, 0x03, 0x49, 0x55, 0xfb, 0xfa, 0xc2, - 0x38, 0x12, 0xef, 0x26, + 0xd9, 0xf0, 0xaf, 0x3f, 0xe3, 0xfd, 0x24, 0x7c, 0x1d, 0xf3, 0x4a, 0x25, 0x27, 0x13, + 0xb2, 0xe9, 0x33, 0xa9, 0x45, 0xa5, 0x67, 0x19, 0x48, 0x7f, 0x8e, 0xd7, 0xf5, 0x63, + 0xea, 0x86, 0x1a, 0xb5, ], Core::Xor32 => [ - 0x1d, 0x49, 0xfc, 0x94, 0xf2, 0x2b, 0x5d, 0x31, 0xb7, 0xf9, 0xef, 0xb5, 0x37, 0x8e, - 0x5f, 0x8a, 0x42, 0x62, 0x6a, 0xed, 0x4e, 0x92, 0x79, 0x93, 0x48, 0xd6, 0xb7, 0x88, - 0xdf, 0xe8, 0x6b, 0x1c, + 0xd5, 0xae, 0x27, 0x12, 0xed, 0xea, 0xf6, 0x76, 0x52, 0x0f, 0xa3, 0xba, 0x0f, 0x40, + 0xbf, 0x4a, 0x16, 0x57, 0x43, 0x7e, 0xff, 0xbd, 0x99, 0x86, 0xd0, 0x6a, 0xe8, 0x1b, + 0x29, 0xa4, 0xf9, 0x8c, ], Core::Xor64 => [ - 0x7a, 0x3f, 0x3f, 0x55, 0x20, 0x47, 0x83, 0x65, 0x33, 0x44, 0x31, 0x1d, 0x1d, 0xc5, - 0x09, 0xd3, 0x5b, 0x66, 0x39, 0xc0, 0xd8, 0xb9, 0x67, 0xa2, 0x07, 0x80, 0x6c, 0xd8, - 0x7d, 0x31, 0xd6, 0xe6, + 0xc4, 0xdf, 0x1c, 0xcf, 0x33, 0x3e, 0xde, 0xbd, 0xd4, 0x0d, 0xea, 0x9a, 0x0e, 0x6c, + 0xbb, 0x83, 0x06, 0x31, 0xe8, 0x3a, 0x94, 0xbb, 0x77, 0x9f, 0xe6, 0x00, 0x7b, 0xc6, + 0xcb, 0x53, 0xa5, 0x44, ], Core::Xor8 => [ - 0xd8, 0x33, 0x5f, 0x48, 0x90, 0xc1, 0xd8, 0xed, 0x76, 0x6c, 0x71, 0x35, 0x90, 0x2e, - 0x01, 0xa0, 0x09, 0x4e, 0x3a, 0x98, 0x16, 0xf7, 0x0c, 0x84, 0x7c, 0xc3, 0xd7, 0xc0, - 0x00, 0x40, 0x6e, 0xfe, + 0x4a, 0xb1, 0x4a, 0x81, 0x4a, 0x39, 0x52, 0x8a, 0x80, 0xfd, 0xb4, 0x30, 0x58, 0x9b, + 0xa4, 0x50, 0x10, 0x4b, 0x9c, 0x72, 0x09, 0xaa, 0x2f, 0xe2, 0x85, 0xcd, 0x60, 0xc0, + 0x90, 0x43, 0x11, 0x4a, ], Core::XorXor1 => [ - 0x1e, 0x10, 0x7b, 0x05, 0xff, 0x94, 0x1d, 0x31, 0xd7, 0x57, 0x8b, 0x43, 0x73, 0x28, - 0xba, 0x52, 0xf3, 0xff, 0x20, 0xa0, 0x68, 0xc0, 0xd2, 0xbd, 0xef, 0x08, 0x76, 0x80, - 0x93, 0xcc, 0x7c, 0x63, + 0x18, 0xb9, 0x44, 0x6a, 0x41, 0x66, 0xa3, 0xfe, 0xe2, 0xbc, 0xb2, 0x54, 0x5b, 0xb9, + 0x01, 0x18, 0xdc, 0xf0, 0xe8, 0xf8, 0x86, 0xa1, 0x07, 0x6d, 0x4c, 0x38, 0x60, 0x06, + 0x0c, 0xde, 0x1a, 0x51, ], Core::XorXor16 => [ - 0xb7, 0x76, 0x98, 0x9d, 0xa5, 0x09, 0x5c, 0x4b, 0xe9, 0x4b, 0x1a, 0xef, 0x75, 0x94, - 0x66, 0xe1, 0x1f, 0x63, 0x9c, 0x19, 0x39, 0x47, 0x1f, 0xa1, 0x8e, 0x36, 0xe7, 0xe4, - 0x90, 0xc3, 0x89, 0x61, + 0x94, 0x6c, 0xde, 0x87, 0x2e, 0x30, 0xe6, 0x50, 0x9d, 0xaf, 0xf4, 0x05, 0xf0, 0xe0, + 0xfe, 0xfe, 0x27, 0x55, 0x47, 0xb4, 0x0e, 0xb2, 0x03, 0x84, 0xaf, 0xe9, 0xa8, 0x63, + 0x60, 0xfc, 0x80, 0xef, ], Core::XorXor32 => [ - 0xd1, 0x68, 0xfa, 0xc1, 0xac, 0x7f, 0xc4, 0x83, 0x57, 0xbe, 0x1b, 0x65, 0x33, 0x75, - 0xec, 0x5e, 0x3f, 0x05, 0x82, 0x3a, 0xae, 0x6a, 0xc9, 0x85, 0xe9, 0x40, 0x3e, 0xea, - 0xb1, 0x2b, 0xb9, 0xf8, + 0x65, 0x27, 0xdf, 0x67, 0xa5, 0x0d, 0x14, 0x8d, 0xb4, 0xfc, 0x8f, 0xee, 0xc7, 0x84, + 0x55, 0x64, 0x99, 0xa8, 0xc7, 0xf0, 0xfa, 0x7d, 0x28, 0xe6, 0x27, 0x8e, 0x99, 0x7f, + 0x49, 0x59, 0xbe, 0x39, ], Core::XorXor64 => [ - 0x36, 0x1c, 0x57, 0x93, 0x0e, 0xf9, 0x7d, 0x49, 0xcb, 0xc6, 0x79, 0xfa, 0xef, 0x1e, - 0x3b, 0xcf, 0xfb, 0x78, 0x79, 0x95, 0xb9, 0x61, 0xe5, 0x53, 0x7d, 0x2b, 0x1e, 0xeb, - 0xc9, 0xc9, 0xa6, 0xe8, + 0xf1, 0x62, 0xf9, 0xe6, 0x56, 0x63, 0xa6, 0x9a, 0xc5, 0xf9, 0x2a, 0x5e, 0xb5, 0x2c, + 0x03, 0x32, 0x39, 0x2e, 0xdd, 0x1e, 0xd1, 0xba, 0x35, 0x5e, 0x6f, 0x19, 0x40, 0x6e, + 0xab, 0xe3, 0xf6, 0xed, ], Core::XorXor8 => [ - 0xc2, 0xda, 0x6e, 0x9c, 0xa6, 0x4d, 0x8a, 0x73, 0xc1, 0x77, 0x26, 0x67, 0xb3, 0xd7, - 0xa0, 0x93, 0x8b, 0xcb, 0x8a, 0x6c, 0x43, 0xfd, 0x04, 0x73, 0xee, 0xc7, 0x1b, 0x77, - 0x49, 0x4a, 0xad, 0x94, + 0xe0, 0x6d, 0x69, 0x4c, 0x5b, 0x40, 0x7d, 0xda, 0xd7, 0xaa, 0x1f, 0x88, 0x07, 0x16, + 0xbc, 0xb7, 0x0a, 0xcd, 0xba, 0x75, 0x85, 0xca, 0x40, 0x09, 0x9a, 0x0a, 0x0a, 0x61, + 0xf3, 0xad, 0x2d, 0xb5, ], }; @@ -3255,7 +3262,9 @@ impl Jet for Core { Core::Or64 => b"l", Core::Or8 => b"***22*22**22*22", Core::ParseLock => b"+ii", - Core::ParseSequence => b"+1+****22*22**22*22***22*22**22*22****22*22**22*22***22*22**22*22", + Core::ParseSequence => { + b"+1+****22*22**22*22***22*22**22*22****22*22**22*22***22*22**22*22" + } Core::PointVerify1 => b"1", Core::RightExtend16_32 => b"i", Core::RightExtend16_64 => b"l", @@ -3323,19 +3332,43 @@ impl Jet for Core { Core::ScalarSquare => b"h", Core::Scale => b"**hhh", Core::Sha256Block => b"h", - Core::Sha256Ctx8Add1 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8Add128 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8Add16 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8Add2 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8Add256 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8Add32 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8Add4 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8Add512 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8Add64 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8Add8 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Core::Sha256Ctx8AddBuffer511 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Core::Sha256Ctx8Add1 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8Add128 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8Add16 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8Add2 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8Add256 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8Add32 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8Add4 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8Add512 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8Add64 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8Add8 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Core::Sha256Ctx8AddBuffer511 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Core::Sha256Ctx8Finalize => b"h", - Core::Sha256Ctx8Init => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Core::Sha256Ctx8Init => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Core::Sha256Iv => b"h", Core::Some1 => b"2", Core::Some16 => b"2", @@ -3347,7 +3380,9 @@ impl Jet for Core { Core::Subtract64 => b"*2l", Core::Subtract8 => b"*2***22*22**22*22", Core::Swu => b"*hh", - Core::TapdataInit => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Core::TapdataInit => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Core::Verify => b"1", Core::Xor1 => b"2", Core::Xor16 => b"****22*22**22*22***22*22**22*22", @@ -6098,14 +6133,20 @@ impl Jet for Core { Core::FullLeftShift16_4 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_4, Core::FullLeftShift16_8 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_8, Core::FullLeftShift32_1 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_1, - Core::FullLeftShift32_16 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_16, + Core::FullLeftShift32_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_16 + } Core::FullLeftShift32_2 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_2, Core::FullLeftShift32_4 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_4, Core::FullLeftShift32_8 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_8, Core::FullLeftShift64_1 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_1, - Core::FullLeftShift64_16 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_16, + Core::FullLeftShift64_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_16 + } Core::FullLeftShift64_2 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_2, - Core::FullLeftShift64_32 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_32, + Core::FullLeftShift64_32 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_32 + } Core::FullLeftShift64_4 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_4, Core::FullLeftShift64_8 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_8, Core::FullLeftShift8_1 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_1, @@ -6115,21 +6156,51 @@ impl Jet for Core { Core::FullMultiply32 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_32, Core::FullMultiply64 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_64, Core::FullMultiply8 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_8, - Core::FullRightShift16_1 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_1, - Core::FullRightShift16_2 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_2, - Core::FullRightShift16_4 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_4, - Core::FullRightShift16_8 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_8, - Core::FullRightShift32_1 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_1, - Core::FullRightShift32_16 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_16, - Core::FullRightShift32_2 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_2, - Core::FullRightShift32_4 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_4, - Core::FullRightShift32_8 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_8, - Core::FullRightShift64_1 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_1, - Core::FullRightShift64_16 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_16, - Core::FullRightShift64_2 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_2, - Core::FullRightShift64_32 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_32, - Core::FullRightShift64_4 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_4, - Core::FullRightShift64_8 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_8, + Core::FullRightShift16_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_1 + } + Core::FullRightShift16_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_2 + } + Core::FullRightShift16_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_4 + } + Core::FullRightShift16_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_8 + } + Core::FullRightShift32_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_1 + } + Core::FullRightShift32_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_16 + } + Core::FullRightShift32_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_2 + } + Core::FullRightShift32_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_4 + } + Core::FullRightShift32_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_8 + } + Core::FullRightShift64_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_1 + } + Core::FullRightShift64_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_16 + } + Core::FullRightShift64_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_2 + } + Core::FullRightShift64_32 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_32 + } + Core::FullRightShift64_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_4 + } + Core::FullRightShift64_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_8 + } Core::FullRightShift8_1 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_1, Core::FullRightShift8_2 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_2, Core::FullRightShift8_4 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_4, @@ -6348,7 +6419,9 @@ impl Jet for Core { Core::ScalarInvert => &simplicity_sys::c_jets::jets_wrapper::scalar_invert, Core::ScalarIsZero => &simplicity_sys::c_jets::jets_wrapper::scalar_is_zero, Core::ScalarMultiply => &simplicity_sys::c_jets::jets_wrapper::scalar_multiply, - Core::ScalarMultiplyLambda => &simplicity_sys::c_jets::jets_wrapper::scalar_multiply_lambda, + Core::ScalarMultiplyLambda => { + &simplicity_sys::c_jets::jets_wrapper::scalar_multiply_lambda + } Core::ScalarNegate => &simplicity_sys::c_jets::jets_wrapper::scalar_negate, Core::ScalarNormalize => &simplicity_sys::c_jets::jets_wrapper::scalar_normalize, Core::ScalarSquare => &simplicity_sys::c_jets::jets_wrapper::scalar_square, @@ -6364,8 +6437,12 @@ impl Jet for Core { Core::Sha256Ctx8Add512 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_512, Core::Sha256Ctx8Add64 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_64, Core::Sha256Ctx8Add8 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_8, - Core::Sha256Ctx8AddBuffer511 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_buffer_511, - Core::Sha256Ctx8Finalize => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_finalize, + Core::Sha256Ctx8AddBuffer511 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_buffer_511 + } + Core::Sha256Ctx8Finalize => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_finalize + } Core::Sha256Ctx8Init => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_init, Core::Sha256Iv => &simplicity_sys::c_jets::jets_wrapper::sha_256_iv, Core::Some1 => &simplicity_sys::c_jets::jets_wrapper::some_1, @@ -6395,374 +6472,374 @@ impl Jet for Core { fn cost(&self) -> Cost { match self { - Core::Add16 => Cost::from_milliweight(108), - Core::Add32 => Cost::from_milliweight(117), - Core::Add64 => Cost::from_milliweight(109), - Core::Add8 => Cost::from_milliweight(112), - Core::All16 => Cost::from_milliweight(62), - Core::All32 => Cost::from_milliweight(65), - Core::All64 => Cost::from_milliweight(79), - Core::All8 => Cost::from_milliweight(76), - Core::And1 => Cost::from_milliweight(79), - Core::And16 => Cost::from_milliweight(88), - Core::And32 => Cost::from_milliweight(94), - Core::And64 => Cost::from_milliweight(93), - Core::And8 => Cost::from_milliweight(91), - Core::Bip0340Verify => Cost::from_milliweight(49087), - Core::Ch1 => Cost::from_milliweight(78), - Core::Ch16 => Cost::from_milliweight(94), - Core::Ch32 => Cost::from_milliweight(91), - Core::Ch64 => Cost::from_milliweight(91), - Core::Ch8 => Cost::from_milliweight(77), + Core::Add16 => Cost::from_milliweight(80), + Core::Add32 => Cost::from_milliweight(92), + Core::Add64 => Cost::from_milliweight(105), + Core::Add8 => Cost::from_milliweight(97), + Core::All16 => Cost::from_milliweight(60), + Core::All32 => Cost::from_milliweight(62), + Core::All64 => Cost::from_milliweight(63), + Core::All8 => Cost::from_milliweight(50), + Core::And1 => Cost::from_milliweight(77), + Core::And16 => Cost::from_milliweight(83), + Core::And32 => Cost::from_milliweight(77), + Core::And64 => Cost::from_milliweight(78), + Core::And8 => Cost::from_milliweight(98), + Core::Bip0340Verify => Cost::from_milliweight(49421), + Core::Ch1 => Cost::from_milliweight(50), + Core::Ch16 => Cost::from_milliweight(83), + Core::Ch32 => Cost::from_milliweight(69), + Core::Ch64 => Cost::from_milliweight(78), + Core::Ch8 => Cost::from_milliweight(86), Core::CheckSigVerify => Cost::from_milliweight(50000), - Core::Complement1 => Cost::from_milliweight(79), - Core::Complement16 => Cost::from_milliweight(75), - Core::Complement32 => Cost::from_milliweight(93), - Core::Complement64 => Cost::from_milliweight(88), - Core::Complement8 => Cost::from_milliweight(80), - Core::Decompress => Cost::from_milliweight(10861), - Core::Decrement16 => Cost::from_milliweight(85), - Core::Decrement32 => Cost::from_milliweight(91), - Core::Decrement64 => Cost::from_milliweight(89), - Core::Decrement8 => Cost::from_milliweight(79), - Core::DivMod128_64 => Cost::from_milliweight(208), - Core::DivMod16 => Cost::from_milliweight(118), - Core::DivMod32 => Cost::from_milliweight(115), - Core::DivMod64 => Cost::from_milliweight(86), - Core::DivMod8 => Cost::from_milliweight(128), - Core::Divide16 => Cost::from_milliweight(98), - Core::Divide32 => Cost::from_milliweight(100), - Core::Divide64 => Cost::from_milliweight(101), - Core::Divide8 => Cost::from_milliweight(108), - Core::Divides16 => Cost::from_milliweight(93), - Core::Divides32 => Cost::from_milliweight(87), - Core::Divides64 => Cost::from_milliweight(91), - Core::Divides8 => Cost::from_milliweight(98), - Core::Eq1 => Cost::from_milliweight(74), - Core::Eq16 => Cost::from_milliweight(84), - Core::Eq256 => Cost::from_milliweight(225), - Core::Eq32 => Cost::from_milliweight(88), - Core::Eq64 => Cost::from_milliweight(100), - Core::Eq8 => Cost::from_milliweight(95), - Core::FeAdd => Cost::from_milliweight(755), - Core::FeInvert => Cost::from_milliweight(3175), - Core::FeIsOdd => Cost::from_milliweight(290), - Core::FeIsZero => Cost::from_milliweight(268), - Core::FeMultiply => Cost::from_milliweight(808), - Core::FeMultiplyBeta => Cost::from_milliweight(579), - Core::FeNegate => Cost::from_milliweight(531), - Core::FeNormalize => Cost::from_milliweight(521), - Core::FeSquare => Cost::from_milliweight(556), - Core::FeSquareRoot => Cost::from_milliweight(10275), - Core::FullAdd16 => Cost::from_milliweight(121), - Core::FullAdd32 => Cost::from_milliweight(119), - Core::FullAdd64 => Cost::from_milliweight(121), - Core::FullAdd8 => Cost::from_milliweight(127), - Core::FullDecrement16 => Cost::from_milliweight(92), - Core::FullDecrement32 => Cost::from_milliweight(107), - Core::FullDecrement64 => Cost::from_milliweight(81), - Core::FullDecrement8 => Cost::from_milliweight(91), - Core::FullIncrement16 => Cost::from_milliweight(89), - Core::FullIncrement32 => Cost::from_milliweight(104), - Core::FullIncrement64 => Cost::from_milliweight(99), - Core::FullIncrement8 => Cost::from_milliweight(72), - Core::FullLeftShift16_1 => Cost::from_milliweight(83), - Core::FullLeftShift16_2 => Cost::from_milliweight(83), - Core::FullLeftShift16_4 => Cost::from_milliweight(89), - Core::FullLeftShift16_8 => Cost::from_milliweight(65), - Core::FullLeftShift32_1 => Cost::from_milliweight(84), - Core::FullLeftShift32_16 => Cost::from_milliweight(81), - Core::FullLeftShift32_2 => Cost::from_milliweight(67), - Core::FullLeftShift32_4 => Cost::from_milliweight(84), - Core::FullLeftShift32_8 => Cost::from_milliweight(91), - Core::FullLeftShift64_1 => Cost::from_milliweight(99), - Core::FullLeftShift64_16 => Cost::from_milliweight(90), - Core::FullLeftShift64_2 => Cost::from_milliweight(94), - Core::FullLeftShift64_32 => Cost::from_milliweight(86), - Core::FullLeftShift64_4 => Cost::from_milliweight(94), - Core::FullLeftShift64_8 => Cost::from_milliweight(86), - Core::FullLeftShift8_1 => Cost::from_milliweight(96), - Core::FullLeftShift8_2 => Cost::from_milliweight(96), - Core::FullLeftShift8_4 => Cost::from_milliweight(85), - Core::FullMultiply16 => Cost::from_milliweight(112), - Core::FullMultiply32 => Cost::from_milliweight(96), - Core::FullMultiply64 => Cost::from_milliweight(127), - Core::FullMultiply8 => Cost::from_milliweight(109), - Core::FullRightShift16_1 => Cost::from_milliweight(80), - Core::FullRightShift16_2 => Cost::from_milliweight(79), - Core::FullRightShift16_4 => Cost::from_milliweight(88), - Core::FullRightShift16_8 => Cost::from_milliweight(57), - Core::FullRightShift32_1 => Cost::from_milliweight(74), - Core::FullRightShift32_16 => Cost::from_milliweight(64), - Core::FullRightShift32_2 => Cost::from_milliweight(63), - Core::FullRightShift32_4 => Cost::from_milliweight(71), - Core::FullRightShift32_8 => Cost::from_milliweight(84), - Core::FullRightShift64_1 => Cost::from_milliweight(99), - Core::FullRightShift64_16 => Cost::from_milliweight(86), - Core::FullRightShift64_2 => Cost::from_milliweight(86), + Core::Complement1 => Cost::from_milliweight(51), + Core::Complement16 => Cost::from_milliweight(86), + Core::Complement32 => Cost::from_milliweight(58), + Core::Complement64 => Cost::from_milliweight(64), + Core::Complement8 => Cost::from_milliweight(62), + Core::Decompress => Cost::from_milliweight(10495), + Core::Decrement16 => Cost::from_milliweight(58), + Core::Decrement32 => Cost::from_milliweight(57), + Core::Decrement64 => Cost::from_milliweight(79), + Core::Decrement8 => Cost::from_milliweight(77), + Core::DivMod128_64 => Cost::from_milliweight(169), + Core::DivMod16 => Cost::from_milliweight(92), + Core::DivMod32 => Cost::from_milliweight(90), + Core::DivMod64 => Cost::from_milliweight(82), + Core::DivMod8 => Cost::from_milliweight(91), + Core::Divide16 => Cost::from_milliweight(85), + Core::Divide32 => Cost::from_milliweight(82), + Core::Divide64 => Cost::from_milliweight(81), + Core::Divide8 => Cost::from_milliweight(85), + Core::Divides16 => Cost::from_milliweight(84), + Core::Divides32 => Cost::from_milliweight(80), + Core::Divides64 => Cost::from_milliweight(67), + Core::Divides8 => Cost::from_milliweight(73), + Core::Eq1 => Cost::from_milliweight(63), + Core::Eq16 => Cost::from_milliweight(68), + Core::Eq256 => Cost::from_milliweight(188), + Core::Eq32 => Cost::from_milliweight(74), + Core::Eq64 => Cost::from_milliweight(82), + Core::Eq8 => Cost::from_milliweight(76), + Core::FeAdd => Cost::from_milliweight(777), + Core::FeInvert => Cost::from_milliweight(3237), + Core::FeIsOdd => Cost::from_milliweight(313), + Core::FeIsZero => Cost::from_milliweight(277), + Core::FeMultiply => Cost::from_milliweight(813), + Core::FeMultiplyBeta => Cost::from_milliweight(607), + Core::FeNegate => Cost::from_milliweight(541), + Core::FeNormalize => Cost::from_milliweight(656), + Core::FeSquare => Cost::from_milliweight(570), + Core::FeSquareRoot => Cost::from_milliweight(10162), + Core::FullAdd16 => Cost::from_milliweight(106), + Core::FullAdd32 => Cost::from_milliweight(96), + Core::FullAdd64 => Cost::from_milliweight(93), + Core::FullAdd8 => Cost::from_milliweight(131), + Core::FullDecrement16 => Cost::from_milliweight(60), + Core::FullDecrement32 => Cost::from_milliweight(71), + Core::FullDecrement64 => Cost::from_milliweight(71), + Core::FullDecrement8 => Cost::from_milliweight(68), + Core::FullIncrement16 => Cost::from_milliweight(70), + Core::FullIncrement32 => Cost::from_milliweight(57), + Core::FullIncrement64 => Cost::from_milliweight(68), + Core::FullIncrement8 => Cost::from_milliweight(73), + Core::FullLeftShift16_1 => Cost::from_milliweight(76), + Core::FullLeftShift16_2 => Cost::from_milliweight(59), + Core::FullLeftShift16_4 => Cost::from_milliweight(68), + Core::FullLeftShift16_8 => Cost::from_milliweight(68), + Core::FullLeftShift32_1 => Cost::from_milliweight(58), + Core::FullLeftShift32_16 => Cost::from_milliweight(52), + Core::FullLeftShift32_2 => Cost::from_milliweight(73), + Core::FullLeftShift32_4 => Cost::from_milliweight(59), + Core::FullLeftShift32_8 => Cost::from_milliweight(60), + Core::FullLeftShift64_1 => Cost::from_milliweight(74), + Core::FullLeftShift64_16 => Cost::from_milliweight(69), + Core::FullLeftShift64_2 => Cost::from_milliweight(70), + Core::FullLeftShift64_32 => Cost::from_milliweight(73), + Core::FullLeftShift64_4 => Cost::from_milliweight(66), + Core::FullLeftShift64_8 => Cost::from_milliweight(68), + Core::FullLeftShift8_1 => Cost::from_milliweight(60), + Core::FullLeftShift8_2 => Cost::from_milliweight(64), + Core::FullLeftShift8_4 => Cost::from_milliweight(72), + Core::FullMultiply16 => Cost::from_milliweight(99), + Core::FullMultiply32 => Cost::from_milliweight(87), + Core::FullMultiply64 => Cost::from_milliweight(103), + Core::FullMultiply8 => Cost::from_milliweight(95), + Core::FullRightShift16_1 => Cost::from_milliweight(55), + Core::FullRightShift16_2 => Cost::from_milliweight(60), + Core::FullRightShift16_4 => Cost::from_milliweight(64), + Core::FullRightShift16_8 => Cost::from_milliweight(55), + Core::FullRightShift32_1 => Cost::from_milliweight(49), + Core::FullRightShift32_16 => Cost::from_milliweight(48), + Core::FullRightShift32_2 => Cost::from_milliweight(66), + Core::FullRightShift32_4 => Cost::from_milliweight(49), + Core::FullRightShift32_8 => Cost::from_milliweight(66), + Core::FullRightShift64_1 => Cost::from_milliweight(60), + Core::FullRightShift64_16 => Cost::from_milliweight(73), + Core::FullRightShift64_2 => Cost::from_milliweight(76), Core::FullRightShift64_32 => Cost::from_milliweight(73), - Core::FullRightShift64_4 => Cost::from_milliweight(93), - Core::FullRightShift64_8 => Cost::from_milliweight(99), - Core::FullRightShift8_1 => Cost::from_milliweight(88), - Core::FullRightShift8_2 => Cost::from_milliweight(86), - Core::FullRightShift8_4 => Cost::from_milliweight(89), - Core::FullSubtract16 => Cost::from_milliweight(121), - Core::FullSubtract32 => Cost::from_milliweight(116), - Core::FullSubtract64 => Cost::from_milliweight(98), - Core::FullSubtract8 => Cost::from_milliweight(126), - Core::GeIsOnCurve => Cost::from_milliweight(642), - Core::GeNegate => Cost::from_milliweight(945), - Core::GejAdd => Cost::from_milliweight(2897), - Core::GejDouble => Cost::from_milliweight(1764), - Core::GejEquiv => Cost::from_milliweight(2220), - Core::GejGeAdd => Cost::from_milliweight(2477), - Core::GejGeAddEx => Cost::from_milliweight(2719), - Core::GejGeEquiv => Cost::from_milliweight(1765), - Core::GejInfinity => Cost::from_milliweight(716), - Core::GejIsInfinity => Cost::from_milliweight(666), - Core::GejIsOnCurve => Cost::from_milliweight(1016), - Core::GejNegate => Cost::from_milliweight(1381), - Core::GejNormalize => Cost::from_milliweight(4099), - Core::GejRescale => Cost::from_milliweight(1908), - Core::GejXEquiv => Cost::from_milliweight(1047), - Core::GejYIsOdd => Cost::from_milliweight(3651), - Core::Generate => Cost::from_milliweight(50071), - Core::HashToCurve => Cost::from_milliweight(68094), - Core::High1 => Cost::from_milliweight(57), - Core::High16 => Cost::from_milliweight(66), - Core::High32 => Cost::from_milliweight(58), - Core::High64 => Cost::from_milliweight(68), + Core::FullRightShift64_4 => Cost::from_milliweight(56), + Core::FullRightShift64_8 => Cost::from_milliweight(68), + Core::FullRightShift8_1 => Cost::from_milliweight(59), + Core::FullRightShift8_2 => Cost::from_milliweight(49), + Core::FullRightShift8_4 => Cost::from_milliweight(51), + Core::FullSubtract16 => Cost::from_milliweight(99), + Core::FullSubtract32 => Cost::from_milliweight(92), + Core::FullSubtract64 => Cost::from_milliweight(109), + Core::FullSubtract8 => Cost::from_milliweight(106), + Core::GeIsOnCurve => Cost::from_milliweight(688), + Core::GeNegate => Cost::from_milliweight(1071), + Core::GejAdd => Cost::from_milliweight(3000), + Core::GejDouble => Cost::from_milliweight(1862), + Core::GejEquiv => Cost::from_milliweight(2376), + Core::GejGeAdd => Cost::from_milliweight(2609), + Core::GejGeAddEx => Cost::from_milliweight(2860), + Core::GejGeEquiv => Cost::from_milliweight(1823), + Core::GejInfinity => Cost::from_milliweight(765), + Core::GejIsInfinity => Cost::from_milliweight(701), + Core::GejIsOnCurve => Cost::from_milliweight(1039), + Core::GejNegate => Cost::from_milliweight(1549), + Core::GejNormalize => Cost::from_milliweight(4184), + Core::GejRescale => Cost::from_milliweight(2011), + Core::GejXEquiv => Cost::from_milliweight(1103), + Core::GejYIsOdd => Cost::from_milliweight(3702), + Core::Generate => Cost::from_milliweight(49851), + Core::HashToCurve => Cost::from_milliweight(69844), + Core::High1 => Cost::from_milliweight(42), + Core::High16 => Cost::from_milliweight(50), + Core::High32 => Cost::from_milliweight(64), + Core::High64 => Cost::from_milliweight(52), Core::High8 => Cost::from_milliweight(59), - Core::Increment16 => Cost::from_milliweight(69), - Core::Increment32 => Cost::from_milliweight(92), - Core::Increment64 => Cost::from_milliweight(87), - Core::Increment8 => Cost::from_milliweight(85), - Core::IsOne16 => Cost::from_milliweight(82), - Core::IsOne32 => Cost::from_milliweight(65), - Core::IsOne64 => Cost::from_milliweight(83), - Core::IsOne8 => Cost::from_milliweight(91), - Core::IsZero16 => Cost::from_milliweight(75), - Core::IsZero32 => Cost::from_milliweight(85), - Core::IsZero64 => Cost::from_milliweight(80), - Core::IsZero8 => Cost::from_milliweight(77), - Core::Le16 => Cost::from_milliweight(112), - Core::Le32 => Cost::from_milliweight(93), - Core::Le64 => Cost::from_milliweight(93), - Core::Le8 => Cost::from_milliweight(109), - Core::LeftExtend16_32 => Cost::from_milliweight(86), - Core::LeftExtend16_64 => Cost::from_milliweight(89), - Core::LeftExtend1_16 => Cost::from_milliweight(67), - Core::LeftExtend1_32 => Cost::from_milliweight(60), - Core::LeftExtend1_64 => Cost::from_milliweight(76), - Core::LeftExtend1_8 => Cost::from_milliweight(65), - Core::LeftExtend32_64 => Cost::from_milliweight(63), - Core::LeftExtend8_16 => Cost::from_milliweight(88), - Core::LeftExtend8_32 => Cost::from_milliweight(90), - Core::LeftExtend8_64 => Cost::from_milliweight(107), - Core::LeftPadHigh16_32 => Cost::from_milliweight(91), - Core::LeftPadHigh16_64 => Cost::from_milliweight(110), - Core::LeftPadHigh1_16 => Cost::from_milliweight(141), - Core::LeftPadHigh1_32 => Cost::from_milliweight(263), - Core::LeftPadHigh1_64 => Cost::from_milliweight(422), - Core::LeftPadHigh1_8 => Cost::from_milliweight(99), - Core::LeftPadHigh32_64 => Cost::from_milliweight(93), - Core::LeftPadHigh8_16 => Cost::from_milliweight(88), - Core::LeftPadHigh8_32 => Cost::from_milliweight(103), - Core::LeftPadHigh8_64 => Cost::from_milliweight(136), - Core::LeftPadLow16_32 => Cost::from_milliweight(69), - Core::LeftPadLow16_64 => Cost::from_milliweight(106), - Core::LeftPadLow1_16 => Cost::from_milliweight(65), - Core::LeftPadLow1_32 => Cost::from_milliweight(63), - Core::LeftPadLow1_64 => Cost::from_milliweight(61), - Core::LeftPadLow1_8 => Cost::from_milliweight(56), - Core::LeftPadLow32_64 => Cost::from_milliweight(91), - Core::LeftPadLow8_16 => Cost::from_milliweight(66), - Core::LeftPadLow8_32 => Cost::from_milliweight(61), - Core::LeftPadLow8_64 => Cost::from_milliweight(112), - Core::LeftRotate16 => Cost::from_milliweight(77), - Core::LeftRotate32 => Cost::from_milliweight(106), - Core::LeftRotate64 => Cost::from_milliweight(98), - Core::LeftRotate8 => Cost::from_milliweight(88), - Core::LeftShift16 => Cost::from_milliweight(72), - Core::LeftShift32 => Cost::from_milliweight(78), - Core::LeftShift64 => Cost::from_milliweight(82), - Core::LeftShift8 => Cost::from_milliweight(91), - Core::LeftShiftWith16 => Cost::from_milliweight(83), - Core::LeftShiftWith32 => Cost::from_milliweight(95), - Core::LeftShiftWith64 => Cost::from_milliweight(103), - Core::LeftShiftWith8 => Cost::from_milliweight(107), - Core::Leftmost16_1 => Cost::from_milliweight(93), - Core::Leftmost16_2 => Cost::from_milliweight(90), - Core::Leftmost16_4 => Cost::from_milliweight(75), - Core::Leftmost16_8 => Cost::from_milliweight(71), - Core::Leftmost32_1 => Cost::from_milliweight(77), - Core::Leftmost32_16 => Cost::from_milliweight(102), - Core::Leftmost32_2 => Cost::from_milliweight(66), - Core::Leftmost32_4 => Cost::from_milliweight(52), - Core::Leftmost32_8 => Cost::from_milliweight(103), - Core::Leftmost64_1 => Cost::from_milliweight(78), - Core::Leftmost64_16 => Cost::from_milliweight(88), - Core::Leftmost64_2 => Cost::from_milliweight(71), - Core::Leftmost64_32 => Cost::from_milliweight(90), - Core::Leftmost64_4 => Cost::from_milliweight(79), - Core::Leftmost64_8 => Cost::from_milliweight(86), - Core::Leftmost8_1 => Cost::from_milliweight(90), - Core::Leftmost8_2 => Cost::from_milliweight(90), - Core::Leftmost8_4 => Cost::from_milliweight(87), - Core::LinearCombination1 => Cost::from_milliweight(84674), - Core::LinearVerify1 => Cost::from_milliweight(43364), - Core::Low1 => Cost::from_milliweight(38), - Core::Low16 => Cost::from_milliweight(69), - Core::Low32 => Cost::from_milliweight(62), - Core::Low64 => Cost::from_milliweight(47), - Core::Low8 => Cost::from_milliweight(47), - Core::Lt16 => Cost::from_milliweight(123), - Core::Lt32 => Cost::from_milliweight(107), - Core::Lt64 => Cost::from_milliweight(76), - Core::Lt8 => Cost::from_milliweight(107), - Core::Maj1 => Cost::from_milliweight(62), - Core::Maj16 => Cost::from_milliweight(80), - Core::Maj32 => Cost::from_milliweight(96), - Core::Maj64 => Cost::from_milliweight(93), - Core::Maj8 => Cost::from_milliweight(94), - Core::Max16 => Cost::from_milliweight(114), - Core::Max32 => Cost::from_milliweight(92), - Core::Max64 => Cost::from_milliweight(104), - Core::Max8 => Cost::from_milliweight(96), - Core::Median16 => Cost::from_milliweight(123), - Core::Median32 => Cost::from_milliweight(101), - Core::Median64 => Cost::from_milliweight(109), - Core::Median8 => Cost::from_milliweight(122), - Core::Min16 => Cost::from_milliweight(97), - Core::Min32 => Cost::from_milliweight(113), - Core::Min64 => Cost::from_milliweight(102), - Core::Min8 => Cost::from_milliweight(99), - Core::Modulo16 => Cost::from_milliweight(103), - Core::Modulo32 => Cost::from_milliweight(102), - Core::Modulo64 => Cost::from_milliweight(85), - Core::Modulo8 => Cost::from_milliweight(102), - Core::Multiply16 => Cost::from_milliweight(90), - Core::Multiply32 => Cost::from_milliweight(90), - Core::Multiply64 => Cost::from_milliweight(85), - Core::Multiply8 => Cost::from_milliweight(93), - Core::Negate16 => Cost::from_milliweight(70), - Core::Negate32 => Cost::from_milliweight(85), - Core::Negate64 => Cost::from_milliweight(94), - Core::Negate8 => Cost::from_milliweight(91), - Core::One16 => Cost::from_milliweight(60), - Core::One32 => Cost::from_milliweight(59), - Core::One64 => Cost::from_milliweight(59), - Core::One8 => Cost::from_milliweight(62), - Core::Or1 => Cost::from_milliweight(77), - Core::Or16 => Cost::from_milliweight(94), - Core::Or32 => Cost::from_milliweight(105), - Core::Or64 => Cost::from_milliweight(99), - Core::Or8 => Cost::from_milliweight(93), - Core::ParseLock => Cost::from_milliweight(97), - Core::ParseSequence => Cost::from_milliweight(116), - Core::PointVerify1 => Cost::from_milliweight(41494), - Core::RightExtend16_32 => Cost::from_milliweight(74), - Core::RightExtend16_64 => Cost::from_milliweight(82), - Core::RightExtend32_64 => Cost::from_milliweight(94), - Core::RightExtend8_16 => Cost::from_milliweight(76), - Core::RightExtend8_32 => Cost::from_milliweight(106), - Core::RightExtend8_64 => Cost::from_milliweight(124), - Core::RightPadHigh16_32 => Cost::from_milliweight(70), - Core::RightPadHigh16_64 => Cost::from_milliweight(88), - Core::RightPadHigh1_16 => Cost::from_milliweight(143), - Core::RightPadHigh1_32 => Cost::from_milliweight(223), - Core::RightPadHigh1_64 => Cost::from_milliweight(476), - Core::RightPadHigh1_8 => Cost::from_milliweight(107), - Core::RightPadHigh32_64 => Cost::from_milliweight(94), - Core::RightPadHigh8_16 => Cost::from_milliweight(89), - Core::RightPadHigh8_32 => Cost::from_milliweight(110), - Core::RightPadHigh8_64 => Cost::from_milliweight(107), - Core::RightPadLow16_32 => Cost::from_milliweight(71), - Core::RightPadLow16_64 => Cost::from_milliweight(96), - Core::RightPadLow1_16 => Cost::from_milliweight(81), - Core::RightPadLow1_32 => Cost::from_milliweight(75), - Core::RightPadLow1_64 => Cost::from_milliweight(73), - Core::RightPadLow1_8 => Cost::from_milliweight(68), - Core::RightPadLow32_64 => Cost::from_milliweight(80), - Core::RightPadLow8_16 => Cost::from_milliweight(75), - Core::RightPadLow8_32 => Cost::from_milliweight(77), - Core::RightPadLow8_64 => Cost::from_milliweight(82), - Core::RightRotate16 => Cost::from_milliweight(99), - Core::RightRotate32 => Cost::from_milliweight(92), - Core::RightRotate64 => Cost::from_milliweight(93), - Core::RightRotate8 => Cost::from_milliweight(75), - Core::RightShift16 => Cost::from_milliweight(84), - Core::RightShift32 => Cost::from_milliweight(88), - Core::RightShift64 => Cost::from_milliweight(91), - Core::RightShift8 => Cost::from_milliweight(88), - Core::RightShiftWith16 => Cost::from_milliweight(105), - Core::RightShiftWith32 => Cost::from_milliweight(92), - Core::RightShiftWith64 => Cost::from_milliweight(97), - Core::RightShiftWith8 => Cost::from_milliweight(103), + Core::Increment16 => Cost::from_milliweight(56), + Core::Increment32 => Cost::from_milliweight(73), + Core::Increment64 => Cost::from_milliweight(64), + Core::Increment8 => Cost::from_milliweight(69), + Core::IsOne16 => Cost::from_milliweight(64), + Core::IsOne32 => Cost::from_milliweight(64), + Core::IsOne64 => Cost::from_milliweight(66), + Core::IsOne8 => Cost::from_milliweight(47), + Core::IsZero16 => Cost::from_milliweight(52), + Core::IsZero32 => Cost::from_milliweight(58), + Core::IsZero64 => Cost::from_milliweight(68), + Core::IsZero8 => Cost::from_milliweight(59), + Core::Le16 => Cost::from_milliweight(83), + Core::Le32 => Cost::from_milliweight(99), + Core::Le64 => Cost::from_milliweight(79), + Core::Le8 => Cost::from_milliweight(93), + Core::LeftExtend16_32 => Cost::from_milliweight(72), + Core::LeftExtend16_64 => Cost::from_milliweight(69), + Core::LeftExtend1_16 => Cost::from_milliweight(50), + Core::LeftExtend1_32 => Cost::from_milliweight(48), + Core::LeftExtend1_64 => Cost::from_milliweight(49), + Core::LeftExtend1_8 => Cost::from_milliweight(46), + Core::LeftExtend32_64 => Cost::from_milliweight(69), + Core::LeftExtend8_16 => Cost::from_milliweight(58), + Core::LeftExtend8_32 => Cost::from_milliweight(86), + Core::LeftExtend8_64 => Cost::from_milliweight(98), + Core::LeftPadHigh16_32 => Cost::from_milliweight(71), + Core::LeftPadHigh16_64 => Cost::from_milliweight(82), + Core::LeftPadHigh1_16 => Cost::from_milliweight(106), + Core::LeftPadHigh1_32 => Cost::from_milliweight(220), + Core::LeftPadHigh1_64 => Cost::from_milliweight(302), + Core::LeftPadHigh1_8 => Cost::from_milliweight(73), + Core::LeftPadHigh32_64 => Cost::from_milliweight(69), + Core::LeftPadHigh8_16 => Cost::from_milliweight(65), + Core::LeftPadHigh8_32 => Cost::from_milliweight(105), + Core::LeftPadHigh8_64 => Cost::from_milliweight(113), + Core::LeftPadLow16_32 => Cost::from_milliweight(65), + Core::LeftPadLow16_64 => Cost::from_milliweight(68), + Core::LeftPadLow1_16 => Cost::from_milliweight(59), + Core::LeftPadLow1_32 => Cost::from_milliweight(47), + Core::LeftPadLow1_64 => Cost::from_milliweight(46), + Core::LeftPadLow1_8 => Cost::from_milliweight(48), + Core::LeftPadLow32_64 => Cost::from_milliweight(62), + Core::LeftPadLow8_16 => Cost::from_milliweight(56), + Core::LeftPadLow8_32 => Cost::from_milliweight(75), + Core::LeftPadLow8_64 => Cost::from_milliweight(116), + Core::LeftRotate16 => Cost::from_milliweight(88), + Core::LeftRotate32 => Cost::from_milliweight(62), + Core::LeftRotate64 => Cost::from_milliweight(68), + Core::LeftRotate8 => Cost::from_milliweight(66), + Core::LeftShift16 => Cost::from_milliweight(109), + Core::LeftShift32 => Cost::from_milliweight(79), + Core::LeftShift64 => Cost::from_milliweight(70), + Core::LeftShift8 => Cost::from_milliweight(72), + Core::LeftShiftWith16 => Cost::from_milliweight(72), + Core::LeftShiftWith32 => Cost::from_milliweight(87), + Core::LeftShiftWith64 => Cost::from_milliweight(97), + Core::LeftShiftWith8 => Cost::from_milliweight(104), + Core::Leftmost16_1 => Cost::from_milliweight(68), + Core::Leftmost16_2 => Cost::from_milliweight(58), + Core::Leftmost16_4 => Cost::from_milliweight(51), + Core::Leftmost16_8 => Cost::from_milliweight(62), + Core::Leftmost32_1 => Cost::from_milliweight(53), + Core::Leftmost32_16 => Cost::from_milliweight(63), + Core::Leftmost32_2 => Cost::from_milliweight(62), + Core::Leftmost32_4 => Cost::from_milliweight(61), + Core::Leftmost32_8 => Cost::from_milliweight(60), + Core::Leftmost64_1 => Cost::from_milliweight(65), + Core::Leftmost64_16 => Cost::from_milliweight(62), + Core::Leftmost64_2 => Cost::from_milliweight(61), + Core::Leftmost64_32 => Cost::from_milliweight(77), + Core::Leftmost64_4 => Cost::from_milliweight(80), + Core::Leftmost64_8 => Cost::from_milliweight(54), + Core::Leftmost8_1 => Cost::from_milliweight(54), + Core::Leftmost8_2 => Cost::from_milliweight(71), + Core::Leftmost8_4 => Cost::from_milliweight(65), + Core::LinearCombination1 => Cost::from_milliweight(85743), + Core::LinearVerify1 => Cost::from_milliweight(43579), + Core::Low1 => Cost::from_milliweight(40), + Core::Low16 => Cost::from_milliweight(60), + Core::Low32 => Cost::from_milliweight(52), + Core::Low64 => Cost::from_milliweight(50), + Core::Low8 => Cost::from_milliweight(45), + Core::Lt16 => Cost::from_milliweight(83), + Core::Lt32 => Cost::from_milliweight(89), + Core::Lt64 => Cost::from_milliweight(71), + Core::Lt8 => Cost::from_milliweight(86), + Core::Maj1 => Cost::from_milliweight(54), + Core::Maj16 => Cost::from_milliweight(85), + Core::Maj32 => Cost::from_milliweight(73), + Core::Maj64 => Cost::from_milliweight(79), + Core::Maj8 => Cost::from_milliweight(64), + Core::Max16 => Cost::from_milliweight(80), + Core::Max32 => Cost::from_milliweight(70), + Core::Max64 => Cost::from_milliweight(75), + Core::Max8 => Cost::from_milliweight(79), + Core::Median16 => Cost::from_milliweight(80), + Core::Median32 => Cost::from_milliweight(77), + Core::Median64 => Cost::from_milliweight(89), + Core::Median8 => Cost::from_milliweight(77), + Core::Min16 => Cost::from_milliweight(83), + Core::Min32 => Cost::from_milliweight(96), + Core::Min64 => Cost::from_milliweight(82), + Core::Min8 => Cost::from_milliweight(78), + Core::Modulo16 => Cost::from_milliweight(85), + Core::Modulo32 => Cost::from_milliweight(81), + Core::Modulo64 => Cost::from_milliweight(71), + Core::Modulo8 => Cost::from_milliweight(85), + Core::Multiply16 => Cost::from_milliweight(79), + Core::Multiply32 => Cost::from_milliweight(78), + Core::Multiply64 => Cost::from_milliweight(72), + Core::Multiply8 => Cost::from_milliweight(79), + Core::Negate16 => Cost::from_milliweight(69), + Core::Negate32 => Cost::from_milliweight(56), + Core::Negate64 => Cost::from_milliweight(56), + Core::Negate8 => Cost::from_milliweight(69), + Core::One16 => Cost::from_milliweight(45), + Core::One32 => Cost::from_milliweight(45), + Core::One64 => Cost::from_milliweight(45), + Core::One8 => Cost::from_milliweight(46), + Core::Or1 => Cost::from_milliweight(56), + Core::Or16 => Cost::from_milliweight(78), + Core::Or32 => Cost::from_milliweight(80), + Core::Or64 => Cost::from_milliweight(71), + Core::Or8 => Cost::from_milliweight(81), + Core::ParseLock => Cost::from_milliweight(82), + Core::ParseSequence => Cost::from_milliweight(93), + Core::PointVerify1 => Cost::from_milliweight(41394), + Core::RightExtend16_32 => Cost::from_milliweight(73), + Core::RightExtend16_64 => Cost::from_milliweight(70), + Core::RightExtend32_64 => Cost::from_milliweight(62), + Core::RightExtend8_16 => Cost::from_milliweight(63), + Core::RightExtend8_32 => Cost::from_milliweight(69), + Core::RightExtend8_64 => Cost::from_milliweight(141), + Core::RightPadHigh16_32 => Cost::from_milliweight(66), + Core::RightPadHigh16_64 => Cost::from_milliweight(81), + Core::RightPadHigh1_16 => Cost::from_milliweight(114), + Core::RightPadHigh1_32 => Cost::from_milliweight(220), + Core::RightPadHigh1_64 => Cost::from_milliweight(313), + Core::RightPadHigh1_8 => Cost::from_milliweight(73), + Core::RightPadHigh32_64 => Cost::from_milliweight(62), + Core::RightPadHigh8_16 => Cost::from_milliweight(75), + Core::RightPadHigh8_32 => Cost::from_milliweight(81), + Core::RightPadHigh8_64 => Cost::from_milliweight(118), + Core::RightPadLow16_32 => Cost::from_milliweight(62), + Core::RightPadLow16_64 => Cost::from_milliweight(98), + Core::RightPadLow1_16 => Cost::from_milliweight(60), + Core::RightPadLow1_32 => Cost::from_milliweight(47), + Core::RightPadLow1_64 => Cost::from_milliweight(57), + Core::RightPadLow1_8 => Cost::from_milliweight(48), + Core::RightPadLow32_64 => Cost::from_milliweight(74), + Core::RightPadLow8_16 => Cost::from_milliweight(62), + Core::RightPadLow8_32 => Cost::from_milliweight(69), + Core::RightPadLow8_64 => Cost::from_milliweight(98), + Core::RightRotate16 => Cost::from_milliweight(67), + Core::RightRotate32 => Cost::from_milliweight(77), + Core::RightRotate64 => Cost::from_milliweight(64), + Core::RightRotate8 => Cost::from_milliweight(72), + Core::RightShift16 => Cost::from_milliweight(60), + Core::RightShift32 => Cost::from_milliweight(69), + Core::RightShift64 => Cost::from_milliweight(68), + Core::RightShift8 => Cost::from_milliweight(63), + Core::RightShiftWith16 => Cost::from_milliweight(83), + Core::RightShiftWith32 => Cost::from_milliweight(78), + Core::RightShiftWith64 => Cost::from_milliweight(72), + Core::RightShiftWith8 => Cost::from_milliweight(71), Core::Rightmost16_1 => Cost::from_milliweight(70), - Core::Rightmost16_2 => Cost::from_milliweight(82), - Core::Rightmost16_4 => Cost::from_milliweight(76), + Core::Rightmost16_2 => Cost::from_milliweight(65), + Core::Rightmost16_4 => Cost::from_milliweight(72), Core::Rightmost16_8 => Cost::from_milliweight(69), - Core::Rightmost32_1 => Cost::from_milliweight(90), - Core::Rightmost32_16 => Cost::from_milliweight(64), + Core::Rightmost32_1 => Cost::from_milliweight(70), + Core::Rightmost32_16 => Cost::from_milliweight(56), Core::Rightmost32_2 => Cost::from_milliweight(74), - Core::Rightmost32_4 => Cost::from_milliweight(92), - Core::Rightmost32_8 => Cost::from_milliweight(78), - Core::Rightmost64_1 => Cost::from_milliweight(77), - Core::Rightmost64_16 => Cost::from_milliweight(86), - Core::Rightmost64_2 => Cost::from_milliweight(74), - Core::Rightmost64_32 => Cost::from_milliweight(76), - Core::Rightmost64_4 => Cost::from_milliweight(70), - Core::Rightmost64_8 => Cost::from_milliweight(69), - Core::Rightmost8_1 => Cost::from_milliweight(79), - Core::Rightmost8_2 => Cost::from_milliweight(98), - Core::Rightmost8_4 => Cost::from_milliweight(98), - Core::ScalarAdd => Cost::from_milliweight(739), - Core::ScalarInvert => Cost::from_milliweight(3193), + Core::Rightmost32_4 => Cost::from_milliweight(57), + Core::Rightmost32_8 => Cost::from_milliweight(55), + Core::Rightmost64_1 => Cost::from_milliweight(61), + Core::Rightmost64_16 => Cost::from_milliweight(63), + Core::Rightmost64_2 => Cost::from_milliweight(65), + Core::Rightmost64_32 => Cost::from_milliweight(64), + Core::Rightmost64_4 => Cost::from_milliweight(57), + Core::Rightmost64_8 => Cost::from_milliweight(49), + Core::Rightmost8_1 => Cost::from_milliweight(65), + Core::Rightmost8_2 => Cost::from_milliweight(63), + Core::Rightmost8_4 => Cost::from_milliweight(56), + Core::ScalarAdd => Cost::from_milliweight(778), + Core::ScalarInvert => Cost::from_milliweight(3178), Core::ScalarIsZero => Cost::from_milliweight(271), - Core::ScalarMultiply => Cost::from_milliweight(774), - Core::ScalarMultiplyLambda => Cost::from_milliweight(557), - Core::ScalarNegate => Cost::from_milliweight(490), - Core::ScalarNormalize => Cost::from_milliweight(472), - Core::ScalarSquare => Cost::from_milliweight(575), - Core::Scale => Cost::from_milliweight(72675), - Core::Sha256Block => Cost::from_milliweight(771), - Core::Sha256Ctx8Add1 => Cost::from_milliweight(642), - Core::Sha256Ctx8Add128 => Cost::from_milliweight(1779), - Core::Sha256Ctx8Add16 => Cost::from_milliweight(747), - Core::Sha256Ctx8Add2 => Cost::from_milliweight(661), - Core::Sha256Ctx8Add256 => Cost::from_milliweight(2912), - Core::Sha256Ctx8Add32 => Cost::from_milliweight(896), - Core::Sha256Ctx8Add4 => Cost::from_milliweight(645), - Core::Sha256Ctx8Add512 => Cost::from_milliweight(5299), - Core::Sha256Ctx8Add64 => Cost::from_milliweight(1187), - Core::Sha256Ctx8Add8 => Cost::from_milliweight(674), - Core::Sha256Ctx8AddBuffer511 => Cost::from_milliweight(5060), - Core::Sha256Ctx8Finalize => Cost::from_milliweight(835), - Core::Sha256Ctx8Init => Cost::from_milliweight(118), - Core::Sha256Iv => Cost::from_milliweight(93), - Core::Some1 => Cost::from_milliweight(70), - Core::Some16 => Cost::from_milliweight(63), - Core::Some32 => Cost::from_milliweight(64), - Core::Some64 => Cost::from_milliweight(93), - Core::Some8 => Cost::from_milliweight(75), - Core::Subtract16 => Cost::from_milliweight(113), - Core::Subtract32 => Cost::from_milliweight(118), - Core::Subtract64 => Cost::from_milliweight(115), - Core::Subtract8 => Cost::from_milliweight(109), - Core::Swu => Cost::from_milliweight(32120), - Core::TapdataInit => Cost::from_milliweight(1178), - Core::Verify => Cost::from_milliweight(57), - Core::Xor1 => Cost::from_milliweight(67), - Core::Xor16 => Cost::from_milliweight(83), - Core::Xor32 => Cost::from_milliweight(92), - Core::Xor64 => Cost::from_milliweight(95), - Core::Xor8 => Cost::from_milliweight(85), - Core::XorXor1 => Cost::from_milliweight(72), - Core::XorXor16 => Cost::from_milliweight(79), - Core::XorXor32 => Cost::from_milliweight(96), - Core::XorXor64 => Cost::from_milliweight(93), - Core::XorXor8 => Cost::from_milliweight(98), + Core::ScalarMultiply => Cost::from_milliweight(793), + Core::ScalarMultiplyLambda => Cost::from_milliweight(567), + Core::ScalarNegate => Cost::from_milliweight(516), + Core::ScalarNormalize => Cost::from_milliweight(500), + Core::ScalarSquare => Cost::from_milliweight(571), + Core::Scale => Cost::from_milliweight(73548), + Core::Sha256Block => Cost::from_milliweight(765), + Core::Sha256Ctx8Add1 => Cost::from_milliweight(664), + Core::Sha256Ctx8Add128 => Cost::from_milliweight(1778), + Core::Sha256Ctx8Add16 => Cost::from_milliweight(781), + Core::Sha256Ctx8Add2 => Cost::from_milliweight(674), + Core::Sha256Ctx8Add256 => Cost::from_milliweight(2894), + Core::Sha256Ctx8Add32 => Cost::from_milliweight(928), + Core::Sha256Ctx8Add4 => Cost::from_milliweight(656), + Core::Sha256Ctx8Add512 => Cost::from_milliweight(5161), + Core::Sha256Ctx8Add64 => Cost::from_milliweight(1220), + Core::Sha256Ctx8Add8 => Cost::from_milliweight(694), + Core::Sha256Ctx8AddBuffer511 => Cost::from_milliweight(5137), + Core::Sha256Ctx8Finalize => Cost::from_milliweight(833), + Core::Sha256Ctx8Init => Cost::from_milliweight(123), + Core::Sha256Iv => Cost::from_milliweight(92), + Core::Some1 => Cost::from_milliweight(60), + Core::Some16 => Cost::from_milliweight(52), + Core::Some32 => Cost::from_milliweight(49), + Core::Some64 => Cost::from_milliweight(62), + Core::Some8 => Cost::from_milliweight(57), + Core::Subtract16 => Cost::from_milliweight(93), + Core::Subtract32 => Cost::from_milliweight(87), + Core::Subtract64 => Cost::from_milliweight(125), + Core::Subtract8 => Cost::from_milliweight(96), + Core::Swu => Cost::from_milliweight(32780), + Core::TapdataInit => Cost::from_milliweight(1233), + Core::Verify => Cost::from_milliweight(44), + Core::Xor1 => Cost::from_milliweight(60), + Core::Xor16 => Cost::from_milliweight(73), + Core::Xor32 => Cost::from_milliweight(77), + Core::Xor64 => Cost::from_milliweight(68), + Core::Xor8 => Cost::from_milliweight(80), + Core::XorXor1 => Cost::from_milliweight(50), + Core::XorXor16 => Cost::from_milliweight(82), + Core::XorXor32 => Cost::from_milliweight(82), + Core::XorXor64 => Cost::from_milliweight(80), + Core::XorXor8 => Cost::from_milliweight(86), } } } diff --git a/src/jet/init/elements.rs b/src/jet/init/elements.rs index 323ecb62..caa6da57 100644 --- a/src/jet/init/elements.rs +++ b/src/jet/init/elements.rs @@ -1,17 +1,17 @@ /* This file has been automatically generated. */ +use crate::analysis::Cost; +use crate::decode_bits; +use crate::jet::elements::ElementsEnv; use crate::jet::type_name::TypeName; use crate::jet::Jet; use crate::merkle::cmr::Cmr; -use crate::decode_bits; use crate::{decode, BitIter, BitWriter}; -use crate::analysis::Cost; use hashes::sha256::Midstate; +use simplicity_sys::elements::CTxEnv; use simplicity_sys::CFrameItem; use std::io::Write; -use std::{fmt, str}; -use crate::jet::elements::ElementsEnv; -use simplicity_sys::CElementsTxEnv; +use std::{borrow::Borrow, fmt, str}; /// The Elements jet family. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] @@ -967,11 +967,17 @@ impl Elements { } impl Jet for Elements { + type Transaction = elements::Transaction; + type Environment + = ElementsEnv + where + T: Borrow; + type CJetEnvironment = CTxEnv; - type Environment = ElementsEnv>; - type CJetEnvironment = CElementsTxEnv; - - fn c_jet_env(env: &Self::Environment) -> &Self::CJetEnvironment { + fn c_jet_env(env: &Self::Environment) -> &Self::CJetEnvironment + where + T: Borrow, + { env.c_tx_env() } @@ -3830,8 +3836,12 @@ impl Jet for Elements { Elements::And32 => b"i", Elements::And64 => b"l", Elements::And8 => b"***22*22**22*22", - Elements::AnnexHash => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::AssetAmountHash => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Elements::AnnexHash => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::AssetAmountHash => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Elements::Bip0340Verify => b"1", Elements::BuildTapbranch => b"h", Elements::BuildTapleafSimplicity => b"h", @@ -4137,7 +4147,9 @@ impl Jet for Elements { Elements::Negate64 => b"*2l", Elements::Negate8 => b"*2***22*22**22*22", Elements::NewIssuanceContract => b"+1+1h", - Elements::NonceHash => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Elements::NonceHash => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Elements::NumInputs => b"i", Elements::NumOutputs => b"i", Elements::One16 => b"****22*22**22*22***22*22**22*22", @@ -4149,7 +4161,9 @@ impl Jet for Elements { Elements::Or32 => b"i", Elements::Or64 => b"l", Elements::Or8 => b"***22*22**22*22", - Elements::OutpointHash => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Elements::OutpointHash => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Elements::OutputAmount => b"+1*+*2hh+*2hl", Elements::OutputAmountsHash => b"h", Elements::OutputAsset => b"+1+*2hh", @@ -4166,7 +4180,9 @@ impl Jet for Elements { Elements::OutputSurjectionProofsHash => b"h", Elements::OutputsHash => b"h", Elements::ParseLock => b"+ii", - Elements::ParseSequence => b"+1+****22*22**22*22***22*22**22*22****22*22**22*22***22*22**22*22", + Elements::ParseSequence => { + b"+1+****22*22**22*22***22*22**22*22****22*22**22*22***22*22**22*22" + } Elements::PointVerify1 => b"1", Elements::ReissuanceBlinding => b"+1+1h", Elements::ReissuanceEntropy => b"+1+1h", @@ -4237,19 +4253,43 @@ impl Jet for Elements { Elements::Scale => b"**hhh", Elements::ScriptCMR => b"h", Elements::Sha256Block => b"h", - Elements::Sha256Ctx8Add1 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8Add128 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8Add16 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8Add2 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8Add256 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8Add32 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8Add4 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8Add512 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8Add64 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8Add8 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", - Elements::Sha256Ctx8AddBuffer511 => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Elements::Sha256Ctx8Add1 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8Add128 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8Add16 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8Add2 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8Add256 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8Add32 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8Add4 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8Add512 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8Add64 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8Add8 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } + Elements::Sha256Ctx8AddBuffer511 => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Elements::Sha256Ctx8Finalize => b"h", - Elements::Sha256Ctx8Init => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Elements::Sha256Ctx8Init => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Elements::Sha256Iv => b"h", Elements::SigAllHash => b"h", Elements::Some1 => b"2", @@ -4263,7 +4303,9 @@ impl Jet for Elements { Elements::Subtract8 => b"*2***22*22**22*22", Elements::Swu => b"*hh", Elements::TapEnvHash => b"h", - Elements::TapdataInit => b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh", + Elements::TapdataInit => { + b"**+1h*+1*ll*+1l*+1i*+1****22*22**22*22***22*22**22*22+1***22*22**22*22*lh" + } Elements::TapleafHash => b"h", Elements::TapleafVersion => b"***22*22**22*22", Elements::Tappath => b"+1h", @@ -7446,19 +7488,31 @@ impl Jet for Elements { Elements::AssetAmountHash => &simplicity_sys::c_jets::jets_wrapper::asset_amount_hash, Elements::Bip0340Verify => &simplicity_sys::c_jets::jets_wrapper::bip_0340_verify, Elements::BuildTapbranch => &simplicity_sys::c_jets::jets_wrapper::build_tapbranch, - Elements::BuildTapleafSimplicity => &simplicity_sys::c_jets::jets_wrapper::build_tapleaf_simplicity, + Elements::BuildTapleafSimplicity => { + &simplicity_sys::c_jets::jets_wrapper::build_tapleaf_simplicity + } Elements::BuildTaptweak => &simplicity_sys::c_jets::jets_wrapper::build_taptweak, Elements::CalculateAsset => &simplicity_sys::c_jets::jets_wrapper::calculate_asset, - Elements::CalculateConfidentialToken => &simplicity_sys::c_jets::jets_wrapper::calculate_confidential_token, - Elements::CalculateExplicitToken => &simplicity_sys::c_jets::jets_wrapper::calculate_explicit_token, - Elements::CalculateIssuanceEntropy => &simplicity_sys::c_jets::jets_wrapper::calculate_issuance_entropy, + Elements::CalculateConfidentialToken => { + &simplicity_sys::c_jets::jets_wrapper::calculate_confidential_token + } + Elements::CalculateExplicitToken => { + &simplicity_sys::c_jets::jets_wrapper::calculate_explicit_token + } + Elements::CalculateIssuanceEntropy => { + &simplicity_sys::c_jets::jets_wrapper::calculate_issuance_entropy + } Elements::Ch1 => &simplicity_sys::c_jets::jets_wrapper::ch_1, Elements::Ch16 => &simplicity_sys::c_jets::jets_wrapper::ch_16, Elements::Ch32 => &simplicity_sys::c_jets::jets_wrapper::ch_32, Elements::Ch64 => &simplicity_sys::c_jets::jets_wrapper::ch_64, Elements::Ch8 => &simplicity_sys::c_jets::jets_wrapper::ch_8, - Elements::CheckLockDistance => &simplicity_sys::c_jets::jets_wrapper::check_lock_distance, - Elements::CheckLockDuration => &simplicity_sys::c_jets::jets_wrapper::check_lock_duration, + Elements::CheckLockDistance => { + &simplicity_sys::c_jets::jets_wrapper::check_lock_distance + } + Elements::CheckLockDuration => { + &simplicity_sys::c_jets::jets_wrapper::check_lock_duration + } Elements::CheckLockHeight => &simplicity_sys::c_jets::jets_wrapper::check_lock_height, Elements::CheckLockTime => &simplicity_sys::c_jets::jets_wrapper::check_lock_time, Elements::CheckSigVerify => &simplicity_sys::c_jets::jets_wrapper::check_sig_verify, @@ -7471,17 +7525,37 @@ impl Jet for Elements { Elements::CurrentAnnexHash => &simplicity_sys::c_jets::jets_wrapper::current_annex_hash, Elements::CurrentAsset => &simplicity_sys::c_jets::jets_wrapper::current_asset, Elements::CurrentIndex => &simplicity_sys::c_jets::jets_wrapper::current_index, - Elements::CurrentIssuanceAssetAmount => &simplicity_sys::c_jets::jets_wrapper::current_issuance_asset_amount, - Elements::CurrentIssuanceAssetProof => &simplicity_sys::c_jets::jets_wrapper::current_issuance_asset_proof, - Elements::CurrentIssuanceTokenAmount => &simplicity_sys::c_jets::jets_wrapper::current_issuance_token_amount, - Elements::CurrentIssuanceTokenProof => &simplicity_sys::c_jets::jets_wrapper::current_issuance_token_proof, - Elements::CurrentNewIssuanceContract => &simplicity_sys::c_jets::jets_wrapper::current_new_issuance_contract, + Elements::CurrentIssuanceAssetAmount => { + &simplicity_sys::c_jets::jets_wrapper::current_issuance_asset_amount + } + Elements::CurrentIssuanceAssetProof => { + &simplicity_sys::c_jets::jets_wrapper::current_issuance_asset_proof + } + Elements::CurrentIssuanceTokenAmount => { + &simplicity_sys::c_jets::jets_wrapper::current_issuance_token_amount + } + Elements::CurrentIssuanceTokenProof => { + &simplicity_sys::c_jets::jets_wrapper::current_issuance_token_proof + } + Elements::CurrentNewIssuanceContract => { + &simplicity_sys::c_jets::jets_wrapper::current_new_issuance_contract + } Elements::CurrentPegin => &simplicity_sys::c_jets::jets_wrapper::current_pegin, - Elements::CurrentPrevOutpoint => &simplicity_sys::c_jets::jets_wrapper::current_prev_outpoint, - Elements::CurrentReissuanceBlinding => &simplicity_sys::c_jets::jets_wrapper::current_reissuance_blinding, - Elements::CurrentReissuanceEntropy => &simplicity_sys::c_jets::jets_wrapper::current_reissuance_entropy, - Elements::CurrentScriptHash => &simplicity_sys::c_jets::jets_wrapper::current_script_hash, - Elements::CurrentScriptSigHash => &simplicity_sys::c_jets::jets_wrapper::current_script_sig_hash, + Elements::CurrentPrevOutpoint => { + &simplicity_sys::c_jets::jets_wrapper::current_prev_outpoint + } + Elements::CurrentReissuanceBlinding => { + &simplicity_sys::c_jets::jets_wrapper::current_reissuance_blinding + } + Elements::CurrentReissuanceEntropy => { + &simplicity_sys::c_jets::jets_wrapper::current_reissuance_entropy + } + Elements::CurrentScriptHash => { + &simplicity_sys::c_jets::jets_wrapper::current_script_hash + } + Elements::CurrentScriptSigHash => { + &simplicity_sys::c_jets::jets_wrapper::current_script_sig_hash + } Elements::CurrentSequence => &simplicity_sys::c_jets::jets_wrapper::current_sequence, Elements::Decompress => &simplicity_sys::c_jets::jets_wrapper::decompress, Elements::Decrement16 => &simplicity_sys::c_jets::jets_wrapper::decrement_16, @@ -7529,46 +7603,118 @@ impl Jet for Elements { Elements::FullIncrement32 => &simplicity_sys::c_jets::jets_wrapper::full_increment_32, Elements::FullIncrement64 => &simplicity_sys::c_jets::jets_wrapper::full_increment_64, Elements::FullIncrement8 => &simplicity_sys::c_jets::jets_wrapper::full_increment_8, - Elements::FullLeftShift16_1 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_1, - Elements::FullLeftShift16_2 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_2, - Elements::FullLeftShift16_4 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_4, - Elements::FullLeftShift16_8 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_8, - Elements::FullLeftShift32_1 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_1, - Elements::FullLeftShift32_16 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_16, - Elements::FullLeftShift32_2 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_2, - Elements::FullLeftShift32_4 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_4, - Elements::FullLeftShift32_8 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_8, - Elements::FullLeftShift64_1 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_1, - Elements::FullLeftShift64_16 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_16, - Elements::FullLeftShift64_2 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_2, - Elements::FullLeftShift64_32 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_32, - Elements::FullLeftShift64_4 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_4, - Elements::FullLeftShift64_8 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_8, - Elements::FullLeftShift8_1 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_1, - Elements::FullLeftShift8_2 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_2, - Elements::FullLeftShift8_4 => &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_4, + Elements::FullLeftShift16_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_1 + } + Elements::FullLeftShift16_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_2 + } + Elements::FullLeftShift16_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_4 + } + Elements::FullLeftShift16_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_16_8 + } + Elements::FullLeftShift32_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_1 + } + Elements::FullLeftShift32_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_16 + } + Elements::FullLeftShift32_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_2 + } + Elements::FullLeftShift32_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_4 + } + Elements::FullLeftShift32_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_32_8 + } + Elements::FullLeftShift64_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_1 + } + Elements::FullLeftShift64_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_16 + } + Elements::FullLeftShift64_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_2 + } + Elements::FullLeftShift64_32 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_32 + } + Elements::FullLeftShift64_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_4 + } + Elements::FullLeftShift64_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_64_8 + } + Elements::FullLeftShift8_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_1 + } + Elements::FullLeftShift8_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_2 + } + Elements::FullLeftShift8_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_left_shift_8_4 + } Elements::FullMultiply16 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_16, Elements::FullMultiply32 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_32, Elements::FullMultiply64 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_64, Elements::FullMultiply8 => &simplicity_sys::c_jets::jets_wrapper::full_multiply_8, - Elements::FullRightShift16_1 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_1, - Elements::FullRightShift16_2 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_2, - Elements::FullRightShift16_4 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_4, - Elements::FullRightShift16_8 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_8, - Elements::FullRightShift32_1 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_1, - Elements::FullRightShift32_16 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_16, - Elements::FullRightShift32_2 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_2, - Elements::FullRightShift32_4 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_4, - Elements::FullRightShift32_8 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_8, - Elements::FullRightShift64_1 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_1, - Elements::FullRightShift64_16 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_16, - Elements::FullRightShift64_2 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_2, - Elements::FullRightShift64_32 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_32, - Elements::FullRightShift64_4 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_4, - Elements::FullRightShift64_8 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_8, - Elements::FullRightShift8_1 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_1, - Elements::FullRightShift8_2 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_2, - Elements::FullRightShift8_4 => &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_4, + Elements::FullRightShift16_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_1 + } + Elements::FullRightShift16_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_2 + } + Elements::FullRightShift16_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_4 + } + Elements::FullRightShift16_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_16_8 + } + Elements::FullRightShift32_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_1 + } + Elements::FullRightShift32_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_16 + } + Elements::FullRightShift32_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_2 + } + Elements::FullRightShift32_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_4 + } + Elements::FullRightShift32_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_32_8 + } + Elements::FullRightShift64_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_1 + } + Elements::FullRightShift64_16 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_16 + } + Elements::FullRightShift64_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_2 + } + Elements::FullRightShift64_32 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_32 + } + Elements::FullRightShift64_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_4 + } + Elements::FullRightShift64_8 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_64_8 + } + Elements::FullRightShift8_1 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_1 + } + Elements::FullRightShift8_2 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_2 + } + Elements::FullRightShift8_4 => { + &simplicity_sys::c_jets::jets_wrapper::full_right_shift_8_4 + } Elements::FullSubtract16 => &simplicity_sys::c_jets::jets_wrapper::full_subtract_16, Elements::FullSubtract32 => &simplicity_sys::c_jets::jets_wrapper::full_subtract_32, Elements::FullSubtract64 => &simplicity_sys::c_jets::jets_wrapper::full_subtract_64, @@ -7607,15 +7753,25 @@ impl Jet for Elements { Elements::InputAnnexesHash => &simplicity_sys::c_jets::jets_wrapper::input_annexes_hash, Elements::InputAsset => &simplicity_sys::c_jets::jets_wrapper::input_asset, Elements::InputHash => &simplicity_sys::c_jets::jets_wrapper::input_hash, - Elements::InputOutpointsHash => &simplicity_sys::c_jets::jets_wrapper::input_outpoints_hash, + Elements::InputOutpointsHash => { + &simplicity_sys::c_jets::jets_wrapper::input_outpoints_hash + } Elements::InputPegin => &simplicity_sys::c_jets::jets_wrapper::input_pegin, - Elements::InputPrevOutpoint => &simplicity_sys::c_jets::jets_wrapper::input_prev_outpoint, + Elements::InputPrevOutpoint => { + &simplicity_sys::c_jets::jets_wrapper::input_prev_outpoint + } Elements::InputScriptHash => &simplicity_sys::c_jets::jets_wrapper::input_script_hash, - Elements::InputScriptSigHash => &simplicity_sys::c_jets::jets_wrapper::input_script_sig_hash, - Elements::InputScriptSigsHash => &simplicity_sys::c_jets::jets_wrapper::input_script_sigs_hash, + Elements::InputScriptSigHash => { + &simplicity_sys::c_jets::jets_wrapper::input_script_sig_hash + } + Elements::InputScriptSigsHash => { + &simplicity_sys::c_jets::jets_wrapper::input_script_sigs_hash + } Elements::InputScriptsHash => &simplicity_sys::c_jets::jets_wrapper::input_scripts_hash, Elements::InputSequence => &simplicity_sys::c_jets::jets_wrapper::input_sequence, - Elements::InputSequencesHash => &simplicity_sys::c_jets::jets_wrapper::input_sequences_hash, + Elements::InputSequencesHash => { + &simplicity_sys::c_jets::jets_wrapper::input_sequences_hash + } Elements::InputUtxoHash => &simplicity_sys::c_jets::jets_wrapper::input_utxo_hash, Elements::InputUtxosHash => &simplicity_sys::c_jets::jets_wrapper::input_utxos_hash, Elements::InputsHash => &simplicity_sys::c_jets::jets_wrapper::inputs_hash, @@ -7630,17 +7786,33 @@ impl Jet for Elements { Elements::IsZero8 => &simplicity_sys::c_jets::jets_wrapper::is_zero_8, Elements::Issuance => &simplicity_sys::c_jets::jets_wrapper::issuance, Elements::IssuanceAsset => &simplicity_sys::c_jets::jets_wrapper::issuance_asset, - Elements::IssuanceAssetAmount => &simplicity_sys::c_jets::jets_wrapper::issuance_asset_amount, - Elements::IssuanceAssetAmountsHash => &simplicity_sys::c_jets::jets_wrapper::issuance_asset_amounts_hash, - Elements::IssuanceAssetProof => &simplicity_sys::c_jets::jets_wrapper::issuance_asset_proof, - Elements::IssuanceBlindingEntropyHash => &simplicity_sys::c_jets::jets_wrapper::issuance_blinding_entropy_hash, + Elements::IssuanceAssetAmount => { + &simplicity_sys::c_jets::jets_wrapper::issuance_asset_amount + } + Elements::IssuanceAssetAmountsHash => { + &simplicity_sys::c_jets::jets_wrapper::issuance_asset_amounts_hash + } + Elements::IssuanceAssetProof => { + &simplicity_sys::c_jets::jets_wrapper::issuance_asset_proof + } + Elements::IssuanceBlindingEntropyHash => { + &simplicity_sys::c_jets::jets_wrapper::issuance_blinding_entropy_hash + } Elements::IssuanceEntropy => &simplicity_sys::c_jets::jets_wrapper::issuance_entropy, Elements::IssuanceHash => &simplicity_sys::c_jets::jets_wrapper::issuance_hash, - Elements::IssuanceRangeProofsHash => &simplicity_sys::c_jets::jets_wrapper::issuance_range_proofs_hash, + Elements::IssuanceRangeProofsHash => { + &simplicity_sys::c_jets::jets_wrapper::issuance_range_proofs_hash + } Elements::IssuanceToken => &simplicity_sys::c_jets::jets_wrapper::issuance_token, - Elements::IssuanceTokenAmount => &simplicity_sys::c_jets::jets_wrapper::issuance_token_amount, - Elements::IssuanceTokenAmountsHash => &simplicity_sys::c_jets::jets_wrapper::issuance_token_amounts_hash, - Elements::IssuanceTokenProof => &simplicity_sys::c_jets::jets_wrapper::issuance_token_proof, + Elements::IssuanceTokenAmount => { + &simplicity_sys::c_jets::jets_wrapper::issuance_token_amount + } + Elements::IssuanceTokenAmountsHash => { + &simplicity_sys::c_jets::jets_wrapper::issuance_token_amounts_hash + } + Elements::IssuanceTokenProof => { + &simplicity_sys::c_jets::jets_wrapper::issuance_token_proof + } Elements::IssuancesHash => &simplicity_sys::c_jets::jets_wrapper::issuances_hash, Elements::LbtcAsset => &simplicity_sys::c_jets::jets_wrapper::lbtc_asset, Elements::Le16 => &simplicity_sys::c_jets::jets_wrapper::le_16, @@ -7657,13 +7829,19 @@ impl Jet for Elements { Elements::LeftExtend8_16 => &simplicity_sys::c_jets::jets_wrapper::left_extend_8_16, Elements::LeftExtend8_32 => &simplicity_sys::c_jets::jets_wrapper::left_extend_8_32, Elements::LeftExtend8_64 => &simplicity_sys::c_jets::jets_wrapper::left_extend_8_64, - Elements::LeftPadHigh16_32 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_16_32, - Elements::LeftPadHigh16_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_16_64, + Elements::LeftPadHigh16_32 => { + &simplicity_sys::c_jets::jets_wrapper::left_pad_high_16_32 + } + Elements::LeftPadHigh16_64 => { + &simplicity_sys::c_jets::jets_wrapper::left_pad_high_16_64 + } Elements::LeftPadHigh1_16 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_16, Elements::LeftPadHigh1_32 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_32, Elements::LeftPadHigh1_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_64, Elements::LeftPadHigh1_8 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_1_8, - Elements::LeftPadHigh32_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_32_64, + Elements::LeftPadHigh32_64 => { + &simplicity_sys::c_jets::jets_wrapper::left_pad_high_32_64 + } Elements::LeftPadHigh8_16 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_8_16, Elements::LeftPadHigh8_32 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_8_32, Elements::LeftPadHigh8_64 => &simplicity_sys::c_jets::jets_wrapper::left_pad_high_8_64, @@ -7707,7 +7885,9 @@ impl Jet for Elements { Elements::Leftmost8_1 => &simplicity_sys::c_jets::jets_wrapper::leftmost_8_1, Elements::Leftmost8_2 => &simplicity_sys::c_jets::jets_wrapper::leftmost_8_2, Elements::Leftmost8_4 => &simplicity_sys::c_jets::jets_wrapper::leftmost_8_4, - Elements::LinearCombination1 => &simplicity_sys::c_jets::jets_wrapper::linear_combination_1, + Elements::LinearCombination1 => { + &simplicity_sys::c_jets::jets_wrapper::linear_combination_1 + } Elements::LinearVerify1 => &simplicity_sys::c_jets::jets_wrapper::linear_verify_1, Elements::LockTime => &simplicity_sys::c_jets::jets_wrapper::lock_time, Elements::Low1 => &simplicity_sys::c_jets::jets_wrapper::low_1, @@ -7748,7 +7928,9 @@ impl Jet for Elements { Elements::Negate32 => &simplicity_sys::c_jets::jets_wrapper::negate_32, Elements::Negate64 => &simplicity_sys::c_jets::jets_wrapper::negate_64, Elements::Negate8 => &simplicity_sys::c_jets::jets_wrapper::negate_8, - Elements::NewIssuanceContract => &simplicity_sys::c_jets::jets_wrapper::new_issuance_contract, + Elements::NewIssuanceContract => { + &simplicity_sys::c_jets::jets_wrapper::new_issuance_contract + } Elements::NonceHash => &simplicity_sys::c_jets::jets_wrapper::nonce_hash, Elements::NumInputs => &simplicity_sys::c_jets::jets_wrapper::num_inputs, Elements::NumOutputs => &simplicity_sys::c_jets::jets_wrapper::num_outputs, @@ -7763,7 +7945,9 @@ impl Jet for Elements { Elements::Or8 => &simplicity_sys::c_jets::jets_wrapper::or_8, Elements::OutpointHash => &simplicity_sys::c_jets::jets_wrapper::outpoint_hash, Elements::OutputAmount => &simplicity_sys::c_jets::jets_wrapper::output_amount, - Elements::OutputAmountsHash => &simplicity_sys::c_jets::jets_wrapper::output_amounts_hash, + Elements::OutputAmountsHash => { + &simplicity_sys::c_jets::jets_wrapper::output_amounts_hash + } Elements::OutputAsset => &simplicity_sys::c_jets::jets_wrapper::output_asset, Elements::OutputHash => &simplicity_sys::c_jets::jets_wrapper::output_hash, Elements::OutputIsFee => &simplicity_sys::c_jets::jets_wrapper::output_is_fee, @@ -7771,40 +7955,76 @@ impl Jet for Elements { Elements::OutputNoncesHash => &simplicity_sys::c_jets::jets_wrapper::output_nonces_hash, Elements::OutputNullDatum => &simplicity_sys::c_jets::jets_wrapper::output_null_datum, Elements::OutputRangeProof => &simplicity_sys::c_jets::jets_wrapper::output_range_proof, - Elements::OutputRangeProofsHash => &simplicity_sys::c_jets::jets_wrapper::output_range_proofs_hash, + Elements::OutputRangeProofsHash => { + &simplicity_sys::c_jets::jets_wrapper::output_range_proofs_hash + } Elements::OutputScriptHash => &simplicity_sys::c_jets::jets_wrapper::output_script_hash, - Elements::OutputScriptsHash => &simplicity_sys::c_jets::jets_wrapper::output_scripts_hash, - Elements::OutputSurjectionProof => &simplicity_sys::c_jets::jets_wrapper::output_surjection_proof, - Elements::OutputSurjectionProofsHash => &simplicity_sys::c_jets::jets_wrapper::output_surjection_proofs_hash, + Elements::OutputScriptsHash => { + &simplicity_sys::c_jets::jets_wrapper::output_scripts_hash + } + Elements::OutputSurjectionProof => { + &simplicity_sys::c_jets::jets_wrapper::output_surjection_proof + } + Elements::OutputSurjectionProofsHash => { + &simplicity_sys::c_jets::jets_wrapper::output_surjection_proofs_hash + } Elements::OutputsHash => &simplicity_sys::c_jets::jets_wrapper::outputs_hash, Elements::ParseLock => &simplicity_sys::c_jets::jets_wrapper::parse_lock, Elements::ParseSequence => &simplicity_sys::c_jets::jets_wrapper::parse_sequence, Elements::PointVerify1 => &simplicity_sys::c_jets::jets_wrapper::point_verify_1, - Elements::ReissuanceBlinding => &simplicity_sys::c_jets::jets_wrapper::reissuance_blinding, - Elements::ReissuanceEntropy => &simplicity_sys::c_jets::jets_wrapper::reissuance_entropy, + Elements::ReissuanceBlinding => { + &simplicity_sys::c_jets::jets_wrapper::reissuance_blinding + } + Elements::ReissuanceEntropy => { + &simplicity_sys::c_jets::jets_wrapper::reissuance_entropy + } Elements::RightExtend16_32 => &simplicity_sys::c_jets::jets_wrapper::right_extend_16_32, Elements::RightExtend16_64 => &simplicity_sys::c_jets::jets_wrapper::right_extend_16_64, Elements::RightExtend32_64 => &simplicity_sys::c_jets::jets_wrapper::right_extend_32_64, Elements::RightExtend8_16 => &simplicity_sys::c_jets::jets_wrapper::right_extend_8_16, Elements::RightExtend8_32 => &simplicity_sys::c_jets::jets_wrapper::right_extend_8_32, Elements::RightExtend8_64 => &simplicity_sys::c_jets::jets_wrapper::right_extend_8_64, - Elements::RightPadHigh16_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_16_32, - Elements::RightPadHigh16_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_16_64, - Elements::RightPadHigh1_16 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_16, - Elements::RightPadHigh1_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_32, - Elements::RightPadHigh1_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_64, + Elements::RightPadHigh16_32 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_16_32 + } + Elements::RightPadHigh16_64 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_16_64 + } + Elements::RightPadHigh1_16 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_16 + } + Elements::RightPadHigh1_32 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_32 + } + Elements::RightPadHigh1_64 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_64 + } Elements::RightPadHigh1_8 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_1_8, - Elements::RightPadHigh32_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_32_64, - Elements::RightPadHigh8_16 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_16, - Elements::RightPadHigh8_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_32, - Elements::RightPadHigh8_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_64, - Elements::RightPadLow16_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_16_32, - Elements::RightPadLow16_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_16_64, + Elements::RightPadHigh32_64 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_32_64 + } + Elements::RightPadHigh8_16 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_16 + } + Elements::RightPadHigh8_32 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_32 + } + Elements::RightPadHigh8_64 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_high_8_64 + } + Elements::RightPadLow16_32 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_low_16_32 + } + Elements::RightPadLow16_64 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_low_16_64 + } Elements::RightPadLow1_16 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_16, Elements::RightPadLow1_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_32, Elements::RightPadLow1_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_64, Elements::RightPadLow1_8 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_1_8, - Elements::RightPadLow32_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_32_64, + Elements::RightPadLow32_64 => { + &simplicity_sys::c_jets::jets_wrapper::right_pad_low_32_64 + } Elements::RightPadLow8_16 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_8_16, Elements::RightPadLow8_32 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_8_32, Elements::RightPadLow8_64 => &simplicity_sys::c_jets::jets_wrapper::right_pad_low_8_64, @@ -7816,9 +8036,15 @@ impl Jet for Elements { Elements::RightShift32 => &simplicity_sys::c_jets::jets_wrapper::right_shift_32, Elements::RightShift64 => &simplicity_sys::c_jets::jets_wrapper::right_shift_64, Elements::RightShift8 => &simplicity_sys::c_jets::jets_wrapper::right_shift_8, - Elements::RightShiftWith16 => &simplicity_sys::c_jets::jets_wrapper::right_shift_with_16, - Elements::RightShiftWith32 => &simplicity_sys::c_jets::jets_wrapper::right_shift_with_32, - Elements::RightShiftWith64 => &simplicity_sys::c_jets::jets_wrapper::right_shift_with_64, + Elements::RightShiftWith16 => { + &simplicity_sys::c_jets::jets_wrapper::right_shift_with_16 + } + Elements::RightShiftWith32 => { + &simplicity_sys::c_jets::jets_wrapper::right_shift_with_32 + } + Elements::RightShiftWith64 => { + &simplicity_sys::c_jets::jets_wrapper::right_shift_with_64 + } Elements::RightShiftWith8 => &simplicity_sys::c_jets::jets_wrapper::right_shift_with_8, Elements::Rightmost16_1 => &simplicity_sys::c_jets::jets_wrapper::rightmost_16_1, Elements::Rightmost16_2 => &simplicity_sys::c_jets::jets_wrapper::rightmost_16_2, @@ -7842,7 +8068,9 @@ impl Jet for Elements { Elements::ScalarInvert => &simplicity_sys::c_jets::jets_wrapper::scalar_invert, Elements::ScalarIsZero => &simplicity_sys::c_jets::jets_wrapper::scalar_is_zero, Elements::ScalarMultiply => &simplicity_sys::c_jets::jets_wrapper::scalar_multiply, - Elements::ScalarMultiplyLambda => &simplicity_sys::c_jets::jets_wrapper::scalar_multiply_lambda, + Elements::ScalarMultiplyLambda => { + &simplicity_sys::c_jets::jets_wrapper::scalar_multiply_lambda + } Elements::ScalarNegate => &simplicity_sys::c_jets::jets_wrapper::scalar_negate, Elements::ScalarNormalize => &simplicity_sys::c_jets::jets_wrapper::scalar_normalize, Elements::ScalarSquare => &simplicity_sys::c_jets::jets_wrapper::scalar_square, @@ -7850,17 +8078,33 @@ impl Jet for Elements { Elements::ScriptCMR => &simplicity_sys::c_jets::jets_wrapper::script_cmr, Elements::Sha256Block => &simplicity_sys::c_jets::jets_wrapper::sha_256_block, Elements::Sha256Ctx8Add1 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_1, - Elements::Sha256Ctx8Add128 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_128, - Elements::Sha256Ctx8Add16 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_16, + Elements::Sha256Ctx8Add128 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_128 + } + Elements::Sha256Ctx8Add16 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_16 + } Elements::Sha256Ctx8Add2 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_2, - Elements::Sha256Ctx8Add256 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_256, - Elements::Sha256Ctx8Add32 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_32, + Elements::Sha256Ctx8Add256 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_256 + } + Elements::Sha256Ctx8Add32 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_32 + } Elements::Sha256Ctx8Add4 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_4, - Elements::Sha256Ctx8Add512 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_512, - Elements::Sha256Ctx8Add64 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_64, + Elements::Sha256Ctx8Add512 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_512 + } + Elements::Sha256Ctx8Add64 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_64 + } Elements::Sha256Ctx8Add8 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_8, - Elements::Sha256Ctx8AddBuffer511 => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_buffer_511, - Elements::Sha256Ctx8Finalize => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_finalize, + Elements::Sha256Ctx8AddBuffer511 => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_buffer_511 + } + Elements::Sha256Ctx8Finalize => { + &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_finalize + } Elements::Sha256Ctx8Init => &simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_init, Elements::Sha256Iv => &simplicity_sys::c_jets::jets_wrapper::sha_256_iv, Elements::SigAllHash => &simplicity_sys::c_jets::jets_wrapper::sig_all_hash, diff --git a/src/jet/mod.rs b/src/jet/mod.rs index 688d8ea3..3fcbcfda 100644 --- a/src/jet/mod.rs +++ b/src/jet/mod.rs @@ -33,6 +33,7 @@ use crate::decode; use crate::jet::type_name::TypeName; use crate::merkle::cmr::Cmr; use crate::{BitIter, BitWriter}; +use std::borrow::Borrow; use std::hash::Hash; use std::io::Write; @@ -61,8 +62,11 @@ impl std::error::Error for JetFailed {} pub trait Jet: Copy + Eq + Ord + Hash + std::fmt::Debug + std::fmt::Display + std::str::FromStr + 'static { + type Transaction; /// Environment for jet to read from - type Environment; + type Environment + where + T: Borrow; /// CJetEnvironment to interact with C FFI. type CJetEnvironment; @@ -82,7 +86,9 @@ pub trait Jet: fn decode>(bits: &mut BitIter) -> Result; /// Obtains a C FFI compatible environment for the jet. - fn c_jet_env(env: &Self::Environment) -> &Self::CJetEnvironment; + fn c_jet_env(env: &Self::Environment) -> &Self::CJetEnvironment + where + T: Borrow; /// Obtain the FFI C pointer for the jet. fn c_jet_ptr(&self) -> &dyn Fn(&mut CFrameItem, CFrameItem, &Self::CJetEnvironment) -> bool; diff --git a/src/merkle/amr.rs b/src/merkle/amr.rs index 7c15de97..523b9dd5 100644 --- a/src/merkle/amr.rs +++ b/src/merkle/amr.rs @@ -305,7 +305,7 @@ mod tests { #[rustfmt::skip] assert_eq!( &node.amr().unwrap().to_string(), - "343e6dc16b3f52e83e3b4ccc99b8c6f96a074fe399327af364bc285e299745a2" + "cdca2a05e52cefa59dc7a5b0dae22098fb896e3913bfdd446b594e1f9250783e" ); }); } diff --git a/src/node/commit.rs b/src/node/commit.rs index 5cd393c7..1ff0f63a 100644 --- a/src/node/commit.rs +++ b/src/node/commit.rs @@ -521,7 +521,7 @@ mod tests { 0x00, ], // CMR not checked against C code, since C won't give us any data without witnesses - "e9339a0d715c721bff752aedc02710cdf3399f3f8d86e64456e85a1bc06ecb7c", + "e7661630013b789c535146485c72001cad7eea92d04bc4135dc9c2d9e48093b7", "3O4o5oxBCDgVxiKNtxBGAgA=", ), // Same program but with each `witness` replaced by `comp iden witness`. @@ -543,7 +543,7 @@ mod tests { 0xdc, 0x41, 0x18, 0x08, ], // CMR not checked against C code, since C won't give us any data without witnesses - "d03bf350f406aef3af0d48e6533b3325ff86f18a36e0e73895a5cd6d6692b860", + "774105cb723e00ab3ac48452aa2dd3744999605393f0343eedc8c6387aa5b3c8", "4ChwQ4MAq5oxBCDgVxiKNtxBGAg=", ) ]; diff --git a/src/node/construct.rs b/src/node/construct.rs index eda9b366..8bff2fed 100644 --- a/src/node/construct.rs +++ b/src/node/construct.rs @@ -5,6 +5,7 @@ use crate::jet::Jet; use crate::types::{self, arrow::Arrow}; use crate::{encode, BitIter, BitWriter, Cmr, FailEntropy, FinalizeError, RedeemNode, Value, Word}; +use core::borrow::Borrow; use std::io; use std::marker::PhantomData; use std::sync::Arc; @@ -212,9 +213,9 @@ impl<'brand, J: Jet> ConstructNode<'brand, J> { /// ## See /// /// [`RedeemNode::prune`] - pub fn finalize_pruned( + pub fn finalize_pruned>( &self, - env: &J::Environment, + env: &J::Environment, ) -> Result>, FinalizeError> { let unpruned = self.finalize_unpruned()?; unpruned.prune(env).map_err(FinalizeError::Execution) diff --git a/src/node/redeem.rs b/src/node/redeem.rs index aa0bf45e..c42eaeed 100644 --- a/src/node/redeem.rs +++ b/src/node/redeem.rs @@ -13,6 +13,7 @@ use super::{ Converter, Hide, Inner, Marker, NoDisconnect, NoWitness, Node, }; +use core::borrow::Borrow; use std::collections::HashSet; use std::io; use std::marker::PhantomData; @@ -289,7 +290,10 @@ impl RedeemNode { /// Pruning fails if the original, unpruned program fails to run on the Bit Machine (step 1). /// In this case, the witness data needs to be revised. /// The other pruning steps (2 & 3) never fail. - pub fn prune(&self, env: &J::Environment) -> Result>, ExecutionError> { + pub fn prune(&self, env: &J::Environment) -> Result>, ExecutionError> + where + Tx: Borrow, + { self.prune_with_tracker(env, &mut SetTracker::default()) } @@ -298,9 +302,9 @@ impl RedeemNode { /// /// See [`crate::bit_machine::StderrTracker`] as an example which outputs the IHR of /// each case combinator that we prune a child of. - pub fn prune_with_tracker>( + pub fn prune_with_tracker, Tx: Borrow>( &self, - env: &J::Environment, + env: &J::Environment, tracker: &mut T, ) -> Result>, ExecutionError> { struct Pruner<'brand, 't, J, T> { @@ -755,9 +759,9 @@ mod tests { assert_program_deserializable::( &[0xc9, 0xc4, 0x6d, 0xb8, 0x82, 0x30, 0x10], &[0xde, 0xad, 0xbe, 0xef], - "d7969920eff9a1ed0359aaa8545b239c69969e22c304c645a7b49bcc976a40a8", - "f7acbb077e7661a08384818bc8e3a275ed42ad446252575a35a35f71689fef78", - "3ce4a6390b4e4bda6330acda4800e66e5d2cae0f5a2888564c706f2b910146b8", + "ee2d966aeccfba7f1f1e54bc130237a6ae575db9c1132193d513aeb14b18151a", + "1f98ab7a78af799dc2efd3f4288a5934f288a73502b79db581eaf7342798a415", + "ce44dd4dfa9589ee67ad70fd1122421baf0b37b2b18d244702c93a9cf032dd17", "ycRtuIIwEA==", ); } @@ -963,12 +967,12 @@ mod tests { } #[cfg(feature = "elements")] - fn assert_correct_pruning( + fn assert_correct_pruning>( unpruned_prog: &str, unpruned_wit: &HashMap, Value>, expected_pruned_prog: &str, expected_pruned_wit: &HashMap, Value>, - env: &J::Environment, + env: &J::Environment, ) { let unpruned_program = types::Context::with_context(|ctx| { Forest::::parse(unpruned_prog) @@ -1047,7 +1051,7 @@ main := comp input comp process jet_verify : 1 -> 1"#; Value::product(Value::u64(0), Value::unit()), ), ]); - assert_correct_pruning::( + assert_correct_pruning::( unpruned_prog, &unpruned_wit, pruned_prog, @@ -1075,7 +1079,7 @@ main := comp input comp process jet_verify : 1 -> 1"#; Value::product(Value::unit(), Value::u64(0)), ), ]); - assert_correct_pruning::( + assert_correct_pruning::( unpruned_prog, &unpruned_wit, pruned_prog, @@ -1100,7 +1104,7 @@ process := assertl (take jet_is_zero_64) #{take jet_is_zero_64} : (2^64 + 1) * 1 main := comp input comp process jet_verify : 1 -> 1"#; let pruned_wit = HashMap::from([(Arc::from("wit1"), Value::left(Value::u64(0), Final::unit()))]); - assert_correct_pruning::( + assert_correct_pruning::( prune_sum, &unpruned_wit, pruned_prog, @@ -1121,7 +1125,7 @@ main := comp input comp process jet_verify : 1 -> 1"#; Arc::from("wit1"), Value::right(Final::unit(), Value::u64(0)), )]); - assert_correct_pruning::( + assert_correct_pruning::( prune_sum, &unpruned_wit, pruned_prog, From 319b3abf7540fff3743ac528f8ad2c94b8f8afb6 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Thu, 11 Sep 2025 16:38:08 +0000 Subject: [PATCH 7/9] jet: drop unnecessary Arcs in environments Now that we've updated the Jet trait to allow the transactions in environments to be arbitrary T: Borrow, we don't need to use Arc everywhere. In many cases we can use normal references. --- src/jet/elements/environment.rs | 6 +++--- src/policy/satisfy.rs | 9 +++++---- src/policy/serialize.rs | 4 ++-- 3 files changed, 10 insertions(+), 9 deletions(-) diff --git a/src/jet/elements/environment.rs b/src/jet/elements/environment.rs index dd7834df..29cb6f8b 100644 --- a/src/jet/elements/environment.rs +++ b/src/jet/elements/environment.rs @@ -110,7 +110,7 @@ where } #[cfg(test)] -impl ElementsEnv> { +impl ElementsEnv { /// Return a dummy Elements environment pub fn dummy() -> Self { Self::dummy_with(elements::LockTime::ZERO, elements::Sequence::MAX) @@ -128,7 +128,7 @@ impl ElementsEnv> { ]; ElementsEnv::new( - std::sync::Arc::new(elements::Transaction { + elements::Transaction { version: 2, lock_time, // Enable locktime in dummy txin @@ -141,7 +141,7 @@ impl ElementsEnv> { witness: elements::TxInWitness::default(), }], output: Vec::default(), - }), + }, vec![ElementsUtxo { script_pubkey: elements::Script::new(), asset: confidential::Asset::Null, diff --git a/src/policy/satisfy.rs b/src/policy/satisfy.rs index 7b323961..3beada11 100644 --- a/src/policy/satisfy.rs +++ b/src/policy/satisfy.rs @@ -13,6 +13,7 @@ use elements::taproot::TapLeafHash; use hashes::Hash; use crate::jet::elements::ElementsEnv; +use core::borrow::Borrow; use std::convert::TryFrom; use std::sync::Arc; @@ -274,7 +275,7 @@ impl Policy { pub fn satisfy<'brand, S: Satisfier<'brand, Pk>>( &self, satisfier: &S, - env: &ElementsEnv>, + env: &ElementsEnv>, ) -> Result>, SatisfierError> { let result = self.satisfy_internal(satisfier)?; match result.get_node() { @@ -346,7 +347,7 @@ mod tests { fn get_satisfier<'tx, 'brand>( context: types::Context<'brand>, - env: &'tx ElementsEnv>, + env: &'tx ElementsEnv>, ) -> PolicySatisfier<'tx, 'brand, XOnlyPublicKey> { let mut preimages = HashMap::new(); @@ -385,7 +386,7 @@ mod tests { fn execute_successful( program: Arc>, - env: &ElementsEnv>, + env: &ElementsEnv>, ) { let mut mac = BitMachine::for_program(&program).unwrap(); assert!(mac.exec(&program, env).is_ok()); @@ -393,7 +394,7 @@ mod tests { fn execute_unsuccessful( program: Arc>, - env: &ElementsEnv>, + env: &ElementsEnv>, ) { let mut mac = BitMachine::for_program(&program).unwrap(); assert!(mac.exec(&program, env).is_err()); diff --git a/src/policy/serialize.rs b/src/policy/serialize.rs index a1bf4eac..17030f89 100644 --- a/src/policy/serialize.rs +++ b/src/policy/serialize.rs @@ -285,7 +285,7 @@ mod tests { policy: Policy, ) -> ( Arc>, - ElementsEnv>, + ElementsEnv>, ) { let commit = policy.commit().expect("no asm"); let env = ElementsEnv::dummy(); @@ -296,7 +296,7 @@ mod tests { fn execute_successful( commit: &CommitNode, witness: Vec, - env: &ElementsEnv>, + env: &ElementsEnv>, ) -> bool { let finalized = commit .finalize(&mut SimpleFinalizer::new(witness.into_iter())) From ef147bc52ca596658234203e630c1533ab12ffac Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Wed, 1 Oct 2025 23:38:11 +0000 Subject: [PATCH 8/9] jet: implement Rust bitcoin environment This is a Rust type which can be used, among other things, to construct the transaction environment needed by C jets. Also provides accessors for the underlying transaction and input index, both of which are used (in the Elements version of this struct) in the policy satisfier. --- src/jet/bitcoin/c_env.rs | 84 ++++++++++++++++++++++++++++++++++ src/jet/bitcoin/environment.rs | 37 +++++++++++++-- src/jet/bitcoin/mod.rs | 1 + 3 files changed, 118 insertions(+), 4 deletions(-) create mode 100644 src/jet/bitcoin/c_env.rs diff --git a/src/jet/bitcoin/c_env.rs b/src/jet/bitcoin/c_env.rs new file mode 100644 index 00000000..5dd27a7c --- /dev/null +++ b/src/jet/bitcoin/c_env.rs @@ -0,0 +1,84 @@ +// SPDX-License-Identifier: CC0-1.0 + +use crate::Cmr; + +use bitcoin::hashes::Hash as _; +use bitcoin::taproot::ControlBlock; +use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin; + +pub(super) fn new_tx( + tx: &bitcoin::Transaction, + in_utxos: &[bitcoin::TxOut], +) -> *mut c_bitcoin::CTransaction { + let mut raw_inputs = Vec::with_capacity(tx.input.len()); + let mut raw_outputs = Vec::with_capacity(tx.output.len()); + + for (inp, utxo) in tx.input.iter().zip(in_utxos.iter()) { + raw_inputs.push(c_bitcoin::CRawInput { + // FIXME actually pass the annex in; see https://github.com/BlockstreamResearch/simplicity/issues/311 for some difficulty here. + annex: core::ptr::null(), + prev_txid: inp.previous_output.txid.as_byte_array(), + txo: c_bitcoin::CRawOutput { + value: utxo.value.to_sat(), + script_pubkey: c_bitcoin::CRawBuffer::new(utxo.script_pubkey.as_bytes()), + }, + script_sig: c_bitcoin::CRawBuffer::new(inp.script_sig.as_bytes()), + prev_txout_index: inp.previous_output.vout, + sequence: inp.sequence.to_consensus_u32(), + }); + } + for out in tx.output.iter() { + raw_outputs.push(c_bitcoin::CRawOutput { + value: out.value.to_sat(), + script_pubkey: c_bitcoin::CRawBuffer::new(out.script_pubkey.as_bytes()), + }); + } + let txid = tx.compute_txid(); + + let c_raw_tx = c_bitcoin::CRawTransaction { + txid: txid.as_byte_array(), + inputs: raw_inputs.as_ptr(), + outputs: raw_outputs.as_ptr(), + n_inputs: raw_inputs.len().try_into().expect("sane length"), + n_outputs: raw_outputs.len().try_into().expect("sane length"), + version: tx.version.0 as u32, // in 1.87.0 can use .cast_unsigned + locktime: tx.lock_time.to_consensus_u32(), + }; + unsafe { + // SAFETY: this is a FFI call and we constructed its argument correctly. + c_bitcoin::simplicity_mallocTransaction(&c_raw_tx) + } +} + +pub(super) fn new_tap_env( + control_block: &ControlBlock, + script_cmr: Cmr, +) -> *mut c_bitcoin::CTapEnv { + let cb_ser = control_block.serialize(); + let raw_tap_env = c_bitcoin::CRawTapEnv { + control_block: cb_ser.as_ptr(), + script_cmr: script_cmr.as_ref().as_ptr(), + branch_len: control_block + .merkle_branch + .len() + .try_into() + .expect("sane length"), + }; + + unsafe { + // SAFETY: this is a FFI call and we constructed its argument correctly. + c_bitcoin::simplicity_mallocTapEnv(&raw_tap_env) + } +} + +pub(super) fn new_tx_env( + tx: *const c_bitcoin::CTransaction, + taproot: *const c_bitcoin::CTapEnv, + ix: u32, +) -> c_bitcoin::CTxEnv { + unsafe { + let mut tx_env = std::mem::MaybeUninit::::uninit(); + c_bitcoin::c_set_txEnv(tx_env.as_mut_ptr(), tx, taproot, ix); + tx_env.assume_init() + } +} diff --git a/src/jet/bitcoin/environment.rs b/src/jet/bitcoin/environment.rs index ba0eae40..2980ca18 100644 --- a/src/jet/bitcoin/environment.rs +++ b/src/jet/bitcoin/environment.rs @@ -1,21 +1,50 @@ // SPDX-License-Identifier: CC0-1.0 +use crate::Cmr; + +use bitcoin::taproot::ControlBlock; use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin; +use super::c_env; + /// Environment for Bitcoin Simplicity pub struct BitcoinEnv { - pub tx: T, + /// The CTxEnv struct + c_tx_env: c_bitcoin::CTxEnv, + tx: T, + ix: u32, } impl BitcoinEnv where T: core::borrow::Borrow, { - pub fn new(tx: T) -> Self { - BitcoinEnv { tx } + pub fn new( + tx: T, + utxos: &[bitcoin::TxOut], + ix: u32, + script_cmr: Cmr, + control_block: ControlBlock, + ) -> Self { + let c_tx = c_env::new_tx(tx.borrow(), utxos); + let c_tap_env = c_env::new_tap_env(&control_block, script_cmr); + let c_tx_env = c_env::new_tx_env(c_tx, c_tap_env, ix); + + BitcoinEnv { c_tx_env, tx, ix } + } + + /// The transaction of this environment + pub fn tx(&self) -> &bitcoin::Transaction { + self.tx.borrow() + } + + /// The input index of this environment + pub fn ix(&self) -> u32 { + self.ix } + /// A version of this environment used by the C implementation of the Bit Machine. pub fn c_tx_env(&self) -> &c_bitcoin::CTxEnv { - unimplemented!() + &self.c_tx_env } } diff --git a/src/jet/bitcoin/mod.rs b/src/jet/bitcoin/mod.rs index 560821af..0170f1a6 100644 --- a/src/jet/bitcoin/mod.rs +++ b/src/jet/bitcoin/mod.rs @@ -1,5 +1,6 @@ // SPDX-License-Identifier: CC0-1.0 +mod c_env; mod environment; pub use environment::BitcoinEnv; From 421d62befc697d5fc6a09a4aadf12680b406b7d1 Mon Sep 17 00:00:00 2001 From: Andrew Poelstra Date: Thu, 18 Dec 2025 18:43:48 +0000 Subject: [PATCH 9/9] jet: populate annexes in Bitcoin environment --- src/jet/bitcoin/c_env.rs | 29 ++++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/src/jet/bitcoin/c_env.rs b/src/jet/bitcoin/c_env.rs index 5dd27a7c..1b01d9da 100644 --- a/src/jet/bitcoin/c_env.rs +++ b/src/jet/bitcoin/c_env.rs @@ -12,11 +12,24 @@ pub(super) fn new_tx( ) -> *mut c_bitcoin::CTransaction { let mut raw_inputs = Vec::with_capacity(tx.input.len()); let mut raw_outputs = Vec::with_capacity(tx.output.len()); + // Allocate space for the raw annexes. This dumb `Vec::from_iter` construction is + // equivalent to `vec![None; tx.input.len()]`, but that won't compile because it + // requires Option::::None to be cloneable, which it's not because + // CRawBuffer isn't. - for (inp, utxo) in tx.input.iter().zip(in_utxos.iter()) { + // SAFETY: this allocation *must* live until after the `simplicity_mallocTransaction` + // at the bottom of this function. We convert the vector to a boxed slice to ensure + // it cannot be resized, which would potentially trigger a reallocation. + let mut raw_annexes = Vec::from_iter((0..tx.input.len()).map(|_| None)).into_boxed_slice(); + + for (n, (inp, utxo)) in tx.input.iter().zip(in_utxos.iter()).enumerate() { + raw_annexes[n] = inp.witness.taproot_annex().map(c_bitcoin::CRawBuffer::new); raw_inputs.push(c_bitcoin::CRawInput { - // FIXME actually pass the annex in; see https://github.com/BlockstreamResearch/simplicity/issues/311 for some difficulty here. - annex: core::ptr::null(), + // This `as_ref().map_or()` construction converts an Option<&T> to a nullable *const T. + // In theory it's a no-op. + annex: raw_annexes[n] + .as_ref() + .map_or(core::ptr::null(), |ptr| ptr as *const _), // cast should be changed to ptr::from_ref in rust 1.76 prev_txid: inp.previous_output.txid.as_byte_array(), txo: c_bitcoin::CRawOutput { value: utxo.value.to_sat(), @@ -44,10 +57,16 @@ pub(super) fn new_tx( version: tx.version.0 as u32, // in 1.87.0 can use .cast_unsigned locktime: tx.lock_time.to_consensus_u32(), }; - unsafe { + let ret = unsafe { // SAFETY: this is a FFI call and we constructed its argument correctly. c_bitcoin::simplicity_mallocTransaction(&c_raw_tx) - } + }; + // Explicitly drop raw_annexes so Rust doesn't try any funny business dropping it early. + // Drop raw_inputs first since it contains pointers into raw_annexes and we don't want + // them to dangle. (It'd be safe since they're raw pointers, but still bad mojo.) + drop(raw_inputs); + drop(raw_annexes); + ret } pub(super) fn new_tap_env(