diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs index 14470d74..2b82eb36 100644 --- a/simplicity-sys/build.rs +++ b/simplicity-sys/build.rs @@ -7,56 +7,106 @@ 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)), + ); + bitcoin_files.push("depend/bitcoin_env.c".into()); + + // 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)), + ); + elements_files.push("depend/elements_env.c".into()); + + 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 +116,16 @@ fn main() { build.include("wasm-sysroot"); } - build.compile("ElementsSimplicity"); + let mut bitcoin_build = build.clone(); + let mut elements_build = build; + + // Bitcoin build + bitcoin_build + .files(bitcoin_files) + .compile("BitcoinSimplicity"); + + // Elements build + elements_build + .files(elements_files) + .compile("ElementsSimplicity"); } 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/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 new file mode 100644 index 00000000..53eb970e --- /dev/null +++ b/simplicity-sys/src/c_jets/c_env/bitcoin.rs @@ -0,0 +1,173 @@ +// 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/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, 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/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/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; diff --git a/src/bit_machine/mod.rs b/src/bit_machine/mod.rs index 39c7b35e..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; @@ -697,7 +702,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..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,19 +291,24 @@ 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] 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 @@ -311,7 +317,7 @@ mod tests { main := comp wits_are_equal jet_verify : 1 -> 1 ", &witness, - &(), + &crate::jet::CoreEnv::EMPTY, "Jet failed during execution", ); } @@ -326,42 +332,47 @@ 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] 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 hole := unit ", &empty, - &(), + &crate::jet::CoreEnv::EMPTY, ); } #[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 ", &empty, - &(), + &crate::jet::CoreEnv::EMPTY, "disconnect node had one child (redeem time); must have two", ); } @@ -374,9 +385,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..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,18 +674,18 @@ mod tests { #[test] fn simple_program() { let empty = HashMap::new(); - assert_cmr_witness::( + assert_cmr_witness::( "main := unit", "c40a10263f7436b4160acbef1c36fba4be4d95df181a968afeab5eac247adff7", &empty, - &(), + &crate::jet::CoreEnv::EMPTY, ); let witness = HashMap::from([ (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,9 +693,9 @@ 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/c_env.rs b/src/jet/bitcoin/c_env.rs new file mode 100644 index 00000000..1b01d9da --- /dev/null +++ b/src/jet/bitcoin/c_env.rs @@ -0,0 +1,103 @@ +// 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()); + // 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. + + // 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 { + // 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(), + 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(), + }; + 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( + 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 c530cec6..2980ca18 100644 --- a/src/jet/bitcoin/environment.rs +++ b/src/jet/bitcoin/environment.rs @@ -1,26 +1,50 @@ // SPDX-License-Identifier: CC0-1.0 -use bitcoin::absolute; +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: bitcoin::Transaction, +pub struct BitcoinEnv { + /// The CTxEnv struct + c_tx_env: c_bitcoin::CTxEnv, + tx: T, + ix: u32, } -impl BitcoinEnv { - pub fn new(tx: bitcoin::Transaction) -> Self { - BitcoinEnv { tx } +impl BitcoinEnv +where + T: core::borrow::Borrow, +{ + 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 } -} -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![], - }) + /// A version of this environment used by the C implementation of the Bit Machine. + pub fn c_tx_env(&self) -> &c_bitcoin::CTxEnv { + &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; 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 new file mode 100644 index 00000000..f80dc742 --- /dev/null +++ b/src/jet/core/mod.rs @@ -0,0 +1,10 @@ +// SPDX-License-Identifier: CC0-1.0 + +use core::convert::Infallible; +use core::marker::PhantomData; + +pub struct CoreEnv(PhantomData); + +impl CoreEnv { + pub const EMPTY: Self = Self(PhantomData); +} diff --git a/src/jet/elements/environment.rs b/src/jet/elements/environment.rs index fc3a9433..29cb6f8b 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 @@ -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/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 085b0d12..3fcbcfda 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; @@ -31,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; @@ -59,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; @@ -80,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; @@ -91,7 +99,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; @@ -111,7 +119,7 @@ mod tests { ) .unwrap(); assert_eq!( - BitMachine::test_exec(two_words, &()).expect("executing"), + BitMachine::test_exec(two_words, &CoreEnv::EMPTY).expect("executing"), Value::product( Value::u1(0), // carry bit Value::u32(2 + 16), // result @@ -129,7 +137,7 @@ mod tests { ) .unwrap(); assert_eq!( - BitMachine::test_exec(two_words, &()).expect("executing"), + BitMachine::test_exec(two_words, &CoreEnv::EMPTY).expect("executing"), Value::product(Value::u32(2), Value::u16(16)), ); }); 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 64a89836..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=", ) ]; @@ -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(); } } 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, 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())) 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,