From a0b54351d7303f0ee9339c96411ed33d4c2989a0 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Wed, 3 Sep 2025 18:59:43 +0000
Subject: [PATCH 01/16] simplicity-sys: split up bitcoin and elements build

Don't actually build bitcoin yet; just refactor build.rs
---
 simplicity-sys/build.rs | 138 ++++++++++++++++++++++++++++------------
 1 file changed, 98 insertions(+), 40 deletions(-)

diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs
index 14470d74..065166ce 100644
--- a/simplicity-sys/build.rs
+++ b/simplicity-sys/build.rs
@@ -7,56 +7,105 @@ fn main() {
     // rerun if changes to the C code
     println!("cargo:rerun-if-changed=depend");
     let simplicity_path = Path::new("depend/simplicity");
-    let jet_files: Vec<_> = vec![
-        "frame.c",
-        "jets.c",
-        "jets-secp256k1.c",
-        "rsort.c",
-        "sha256.c",
-        "elements/env.c",
-        "elements/ops.c",
-        "elements/elementsJets.c",
-        "elements/txEnv.c",
-    ]
-    .into_iter()
-    .map(|x| simplicity_path.join(x))
-    .collect();
 
+    let mut files = vec![];
+
+    // 1. Base files.
+    files.extend(
+        [
+            "frame.c",
+            "jets.c",
+            "jets-secp256k1.c",
+            "rsort.c",
+            "sha256.c",
+        ]
+        .into_iter()
+        .map(|x| simplicity_path.join(x)),
+    );
+    // 2. Test files.
+    if cfg!(feature = "test-utils") {
+        files.extend(
+            [
+                "bitstream.c",
+                "dag.c",
+                "deserialize.c",
+                "eval.c",
+                "type.c",
+                "typeInference.c",
+                "ctx8Pruned.c",
+                "ctx8Unpruned.c",
+                "hashBlock.c",
+                "schnorr0.c",
+                "schnorr6.c",
+            ]
+            .into_iter()
+            .map(|x| simplicity_path.join(x)),
+        );
+    }
+
+    // Split into Bitcoin and Elements.
+    let mut elements_files = files.clone();
+    let mut bitcoin_files = files;
+
+    // 3B. Bitcoin base files.
+    bitcoin_files.extend(
+        [
+            "bitcoin/env.c",
+            "bitcoin/ops.c",
+            "bitcoin/bitcoinJets.c",
+            "bitcoin/txEnv.c",
+        ]
+        .into_iter()
+        .map(|x| simplicity_path.join(x)),
+    );
+
+    // 3E. Elements base files.
+    elements_files.extend(
+        [
+            "elements/env.c",
+            "elements/ops.c",
+            "elements/elementsJets.c",
+            "elements/txEnv.c",
+        ]
+        .into_iter()
+        .map(|x| simplicity_path.join(x)),
+    );
+
+    if cfg!(feature = "test-utils") {
+        // 4B. Bitcoin base files.
+        bitcoin_files.extend(
+            [
+                "bitcoin/exec.c",
+                "bitcoin/primitive.c",
+                // "bitcoin/checkSigHashAllTx1.c", // no sighashall test
+            ]
+            .into_iter()
+            .map(|x| simplicity_path.join(x)),
+        );
+
+        // 4E. Elements base files.
+        elements_files.extend(
+            [
+                "elements/exec.c",
+                "elements/primitive.c",
+                "elements/checkSigHashAllTx1.c",
+            ]
+            .into_iter()
+            .map(|x| simplicity_path.join(x)),
+        );
+    }
+
+    // General build
     let mut build = cc::Build::new();
     build
         .std("c11")
         .flag_if_supported("-fno-inline-functions")
         .opt_level(2)
-        .files(jet_files)
         .file(Path::new("depend/wrapper.c"))
         .file(Path::new("depend/env.c"))
         .file(Path::new("depend/jets_wrapper.c"))
         .include(simplicity_path.join("include"));
 
-    if cfg!(feature = "test-utils") {
-        let test_files: Vec<_> = vec![
-            "bitstream.c",
-            "dag.c",
-            "deserialize.c",
-            "eval.c",
-            "type.c",
-            "typeInference.c",
-            "elements/exec.c",
-            "elements/primitive.c",
-            "ctx8Pruned.c",
-            "ctx8Unpruned.c",
-            "hashBlock.c",
-            "schnorr0.c",
-            "schnorr6.c",
-            "elements/checkSigHashAllTx1.c",
-        ]
-        .into_iter()
-        .map(|x| simplicity_path.join(x))
-        .collect();
-
-        build.files(test_files);
-    }
-
     if cfg!(not(fuzzing)) {
         build.define("PRODUCTION", None);
     }
@@ -66,5 +115,14 @@ fn main() {
         build.include("wasm-sysroot");
     }
 
-    build.compile("ElementsSimplicity");
+    let mut _bitcoin_build = build.clone();
+    let mut elements_build = build;
+
+    // Bitcoin build
+    // TODO
+
+    // Elements build
+    elements_build
+        .files(elements_files)
+        .compile("ElementsSimplicity");
 }

From 8607ed8a35ebfee79658b2a54ca2618c84a81b0d Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Wed, 3 Sep 2025 21:02:43 +0000
Subject: [PATCH 02/16] simplicity-sys: split env.c into bitcoin_env.c

For dumb "C polymorphism" reasons we have two structures in the C code named
txEnv. We can call the corresponding Rust structures different things, but
we need to access them from the C file env.c, which provides some C wrappers
for FFI stuff.

Since you can't have two different structs with the same name in one compilation
unit, split it into two: add depend/bitcoin_env.c holding the Bitcoin txEnv
wrappers, alongside the existing depend/env.c for Elements.
---
 simplicity-sys/build.rs             |  3 ++-
 simplicity-sys/depend/bitcoin_env.c | 31 +++++++++++++++++++++++++++++
 2 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 simplicity-sys/depend/bitcoin_env.c

diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs
index 065166ce..4643be4a 100644
--- a/simplicity-sys/build.rs
+++ b/simplicity-sys/build.rs
@@ -58,6 +58,7 @@ fn main() {
         .into_iter()
         .map(|x| simplicity_path.join(x)),
     );
+    bitcoin_files.push("depend/bitcoin_env.c".into());
 
     // 3E. Elements base files.
     elements_files.extend(
@@ -70,6 +71,7 @@ fn main() {
         .into_iter()
         .map(|x| simplicity_path.join(x)),
     );
+    elements_files.push("depend/env.c".into());
 
     if cfg!(feature = "test-utils") {
         // 4B. Bitcoin base files.
@@ -102,7 +104,6 @@ fn main() {
         .flag_if_supported("-fno-inline-functions")
         .opt_level(2)
         .file(Path::new("depend/wrapper.c"))
-        .file(Path::new("depend/env.c"))
         .file(Path::new("depend/jets_wrapper.c"))
         .include(simplicity_path.join("include"));
 
diff --git a/simplicity-sys/depend/bitcoin_env.c b/simplicity-sys/depend/bitcoin_env.c
new file mode 100644
index 00000000..99928e88
--- /dev/null
+++ b/simplicity-sys/depend/bitcoin_env.c
@@ -0,0 +1,31 @@
+#include <stdlib.h>
+#include <stdalign.h>
+#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_8_c_sizeof_rawBitcoinBuffer = sizeof(rawBitcoinBuffer);
+const size_t rustsimplicity_0_8_c_sizeof_rawBitcoinOutput = sizeof(rawBitcoinOutput);
+const size_t rustsimplicity_0_8_c_sizeof_rawBitcoinInput = sizeof(rawBitcoinInput);
+const size_t rustsimplicity_0_8_c_sizeof_rawBitcoinTransaction = sizeof(rawBitcoinTransaction);
+const size_t rustsimplicity_0_8_c_sizeof_rawBitcoinTapEnv = sizeof(rawBitcoinTapEnv);
+const size_t rustsimplicity_0_8_c_sizeof_bitcoinTxEnv = sizeof(txEnv);
+
+const size_t rustsimplicity_0_8_c_alignof_rawBitcoinBuffer = alignof(rawBitcoinBuffer);
+const size_t rustsimplicity_0_8_c_alignof_rawBitcoinOutput = alignof(rawBitcoinOutput);
+const size_t rustsimplicity_0_8_c_alignof_rawBitcoinInput = alignof(rawBitcoinInput);
+const size_t rustsimplicity_0_8_c_alignof_rawBitcoinTransaction = alignof(rawBitcoinTransaction);
+const size_t rustsimplicity_0_8_c_alignof_rawBitcoinTapEnv = alignof(rawBitcoinTapEnv);
+const size_t rustsimplicity_0_8_c_alignof_bitcoinTxEnv = alignof(txEnv);
+
+void rustsimplicity_0_8_c_bitcoin_set_txEnv(txEnv *result, const bitcoinTransaction *tx, const bitcoinTapEnv *taproot, unsigned int ix)
+{
+    *result = rustsimplicity_0_8_bitcoin_build_txEnv(tx, taproot, ix);
+}

From 0182d01e859af2a8fec3b5e859338cc342657b0e Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Wed, 3 Sep 2025 19:56:00 +0000
Subject: [PATCH 03/16] simplicity-sys: define bitcoin transaction environment

---
 simplicity-sys/src/c_jets/c_env/bitcoin.rs | 176 +++++++++++++++++++++
 simplicity-sys/src/c_jets/c_env/mod.rs     |   1 +
 simplicity-sys/src/c_jets/mod.rs           |   2 +-
 simplicity-sys/src/lib.rs                  |   1 +
 4 files changed, 179 insertions(+), 1 deletion(-)
 create mode 100644 simplicity-sys/src/c_jets/c_env/bitcoin.rs

diff --git a/simplicity-sys/src/c_jets/c_env/bitcoin.rs b/simplicity-sys/src/c_jets/c_env/bitcoin.rs
new file mode 100644
index 00000000..dfb3e8a8
--- /dev/null
+++ b/simplicity-sys/src/c_jets/c_env/bitcoin.rs
@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use hashes::sha256;
+
+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_8_c_sizeof_rawBitcoinBuffer"]
+    pub static c_sizeof_rawBuffer: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_sizeof_rawBitcoinOutput"]
+    pub static c_sizeof_rawOutput: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_sizeof_rawBitcoinInput"]
+    pub static c_sizeof_rawInput: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_sizeof_rawBitcoinTransaction"]
+    pub static c_sizeof_rawTransaction: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_sizeof_rawBitcoinTapEnv"]
+    pub static c_sizeof_rawTapEnv: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_sizeof_bitcoinTxEnv"]
+    pub static c_sizeof_txEnv: c_size_t;
+
+    #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinBuffer"]
+    pub static c_alignof_rawBuffer: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinOutput"]
+    pub static c_alignof_rawOutput: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinInput"]
+    pub static c_alignof_rawInput: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinTransaction"]
+    pub static c_alignof_rawTransaction: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_alignof_rawBitcoinTapEnv"]
+    pub static c_alignof_rawTapEnv: c_size_t;
+    #[link_name = "rustsimplicity_0_8_c_alignof_bitcoinTxEnv"]
+    pub static c_alignof_txEnv: c_size_t;
+
+    #[link_name = "rustsimplicity_0_8_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_8_bitcoin_mallocTapEnv"]
+    pub fn simplicity_mallocTapEnv(rawEnv: *const CRawTapEnv) -> *mut CTapEnv;
+    #[link_name = "rustsimplicity_0_8_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_parts().0)
+    }
+}
+
+// Pointer must be manually free after dropping
+impl Drop for CTxEnv {
+    fn drop(&mut self) {
+        unsafe {
+            crate::alloc::rust_0_8_free(self.tx as *mut u8);
+            crate::alloc::rust_0_8_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::<CFrameItem>(), c_sizeof_frameItem);
+            assert_eq!(size_of::<CRawBuffer>(), c_sizeof_rawBuffer);
+            assert_eq!(size_of::<CRawInput>(), c_sizeof_rawInput);
+            assert_eq!(size_of::<CRawOutput>(), c_sizeof_rawOutput);
+            assert_eq!(size_of::<CRawTransaction>(), c_sizeof_rawTransaction);
+            assert_eq!(size_of::<CRawTapEnv>(), c_sizeof_rawTapEnv);
+            assert_eq!(size_of::<CTxEnv>(), c_sizeof_txEnv);
+        }
+    }
+
+    #[test]
+    fn test_aligns() {
+        unsafe {
+            assert_eq!(align_of::<CFrameItem>(), c_alignof_frameItem);
+            assert_eq!(align_of::<CRawBuffer>(), c_alignof_rawBuffer);
+            assert_eq!(align_of::<CRawInput>(), c_alignof_rawInput);
+            assert_eq!(align_of::<CRawOutput>(), c_alignof_rawOutput);
+            assert_eq!(align_of::<CRawTransaction>(), c_alignof_rawTransaction);
+            assert_eq!(align_of::<CRawTapEnv>(), c_alignof_rawTapEnv);
+            assert_eq!(align_of::<CTxEnv>(), c_alignof_txEnv);
+        }
+    }
+}
+*/
diff --git a/simplicity-sys/src/c_jets/c_env/mod.rs b/simplicity-sys/src/c_jets/c_env/mod.rs
index fcca587c..6136d485 100644
--- a/simplicity-sys/src/c_jets/c_env/mod.rs
+++ b/simplicity-sys/src/c_jets/c_env/mod.rs
@@ -1,3 +1,4 @@
 // SPDX-License-Identifier: CC0-1.0
 
+pub mod bitcoin;
 pub mod elements;
diff --git a/simplicity-sys/src/c_jets/mod.rs b/simplicity-sys/src/c_jets/mod.rs
index ae2fc852..a163cf57 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 f032d902..b35f3541 100644
--- a/simplicity-sys/src/lib.rs
+++ b/simplicity-sys/src/lib.rs
@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: CC0-1.0
 
 pub mod c_jets;
+pub use c_jets::bitcoin;
 pub use c_jets::elements;
 pub use c_jets::CFrameItem;
 

From 87549f61737ba96f070fd9641ac2f77b353cdd62 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Thu, 18 Dec 2025 16:49:05 +0000
Subject: [PATCH 04/16] jet: switch from Deref to Borrow for transaction
 environments

This is the more correct trait. When we update the Jet trait we will
be forced to pick one, and we will pick Borrow.
---
 src/jet/bitcoin/environment.rs  | 26 +++++++++++---------------
 src/jet/elements/environment.rs | 10 +++++-----
 src/policy/sighash.rs           |  2 +-
 3 files changed, 17 insertions(+), 21 deletions(-)

diff --git a/src/jet/bitcoin/environment.rs b/src/jet/bitcoin/environment.rs
index c530cec6..22c9f85a 100644
--- a/src/jet/bitcoin/environment.rs
+++ b/src/jet/bitcoin/environment.rs
@@ -1,26 +1,22 @@
 // SPDX-License-Identifier: CC0-1.0
 
-use bitcoin::absolute;
+use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin;
 
 /// Environment for Bitcoin Simplicity
-pub struct BitcoinEnv {
-    pub tx: bitcoin::Transaction,
+// In later commit, when we update Jet trait, will remove default type.
+pub struct BitcoinEnv<T = bitcoin::Transaction> {
+    pub tx: T,
 }
 
-impl BitcoinEnv {
-    pub fn new(tx: bitcoin::Transaction) -> Self {
+impl<T> BitcoinEnv<T>
+where
+    T: core::borrow::Borrow<bitcoin::Transaction>,
+{
+    pub fn new(tx: T) -> Self {
         BitcoinEnv { tx }
     }
-}
 
-impl Default for BitcoinEnv {
-    fn default() -> Self {
-        // FIXME: Review and check if the defaults make sense
-        BitcoinEnv::new(bitcoin::Transaction {
-            version: bitcoin::transaction::Version::TWO,
-            lock_time: absolute::LockTime::ZERO,
-            input: vec![],
-            output: vec![],
-        })
+    pub fn c_tx_env(&self) -> &c_bitcoin::CTxEnv {
+        unimplemented!()
     }
 }
diff --git a/src/jet/elements/environment.rs b/src/jet/elements/environment.rs
index 202582c4..812bf388 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<elements::TxOut> for ElementsUtxo {
 /// The order of `utxos` must be same as of the order of inputs in the
 /// transaction.
 #[derive(Debug)]
-pub struct ElementsEnv<T: Deref<Target = elements::Transaction>> {
+pub struct ElementsEnv<T: Borrow<elements::Transaction>> {
     /// The CTxEnv struct
     c_tx_env: c_elements::CTxEnv,
     /// The elements transaction
@@ -54,7 +54,7 @@ pub struct ElementsEnv<T: Deref<Target = elements::Transaction>> {
 
 impl<T> ElementsEnv<T>
 where
-    T: Deref<Target = elements::Transaction>,
+    T: Borrow<elements::Transaction>,
 {
     pub fn new(
         tx: T,
@@ -65,7 +65,7 @@ where
         annex: Option<Vec<u8>>,
         genesis_hash: elements::BlockHash,
     ) -> Self {
-        let c_tx = c_env::new_tx(&tx, &utxos);
+        let c_tx = c_env::new_tx(tx.borrow(), &utxos);
         let c_tap_env = c_env::new_tap_env(&control_block, script_cmr);
         let c_tx_env = c_env::new_tx_env(c_tx, c_tap_env, genesis_hash, ix);
         ElementsEnv {
@@ -85,7 +85,7 @@ where
 
     /// Returns the transaction of this environment
     pub fn tx(&self) -> &elements::Transaction {
-        &self.tx
+        self.tx.borrow()
     }
 
     /// Returns the input index of this environment
diff --git a/src/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<T: Deref<Target = elements::Transaction> + Clone> SighashCache<T> {
             .collect();
 
         let simplicity_env = crate::jet::elements::ElementsEnv::new(
-            self.tx.clone(),
+            (*self.tx).borrow(),
             utxos,
             input_index as u32,
             script_cmr,

From a5ff0797080f36c97f1d3fa44a59120595399af0 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Wed, 3 Sep 2025 18:47:15 +0000
Subject: [PATCH 05/16] simplicity-sys: update libsimplicity to bitcoin branch

Updates to https://github.com/BlockstreamResearch/simplicity/pull/324

This PR does a couple things simultaneously:

* Runs vendor-simplicity.sh and update-jets.sh
* Updates the `Jet` trait to have associated transaction and environment types,
  and for the environment to be paramterized by the transaction type.
* Changes the Core environment from () to CoreEnv::<Infallible>
* Updates some fixed Core CMR/IHR vectors (this update to libsimplicity changes
  the benchmarks for the Core jets and thus changes these vectors)
* Uncomments the commented-out symbols in simplicity-sys/src/c_jets/c_env/bitcoin.rs
* Adds the "build bitcoin" lines to simplicity-sys/build.rs

The update to the `Jet` trait is a bit noisy but ultimately mechanical: everywhere
that we're generic over all J: Jet, we now also have to be generic over all
T: Borrow<J::Transaction>, which leads to some extra line noise especially in
unit tests where we have assert_* helper functions.

The last four points are tiny diffs, thanks to the previous preparatory commits.

The use of CoreEnv::<Infallible> as the core environment type is kinda fun. It
means that it is impossible to execute any code which attempts to access the
transaction in the environment. (No such code exists, since it would be nonsensical,
but now we have some assurance that it won't exist by accident in the future.)

Unfortunately this mixes mechanical and non-mechanical things in one commit. But
the mechanical changes are exclusively in simplicity-sys/depend/ and src/jet/init/
and the non-mechanical changes are exclusively outside of those files, so it
should be possible to review this.
---
 simplicity-sys/build.rs                       |  32 ++++-
 .../depend/simplicity/CMakeLists.txt          |  36 +++++
 .../depend/simplicity/bitcoin/cmr.c           |  22 +++
 .../depend/simplicity/bitcoin/exec.c          | 136 ++++++++++++++++++
 simplicity-sys/depend/simplicity/cmr.c        |  41 ++++++
 simplicity-sys/depend/simplicity/cmr.h        |  24 ++++
 .../include/simplicity/bitcoin/cmr.h          |  23 +++
 .../include/simplicity/bitcoin/exec.h         |  41 ++++++
 simplicity-sys/src/c_jets/c_env/bitcoin.rs    |   5 +-
 src/jet/bitcoin/environment.rs                |   3 +-
 src/jet/bitcoin/mod.rs                        |   2 +-
 src/jet/core/environment.rs                   |   1 +
 12 files changed, 352 insertions(+), 14 deletions(-)
 create mode 100644 simplicity-sys/depend/simplicity/CMakeLists.txt
 create mode 100644 simplicity-sys/depend/simplicity/bitcoin/cmr.c
 create mode 100644 simplicity-sys/depend/simplicity/bitcoin/exec.c
 create mode 100644 simplicity-sys/depend/simplicity/cmr.c
 create mode 100644 simplicity-sys/depend/simplicity/cmr.h
 create mode 100644 simplicity-sys/depend/simplicity/include/simplicity/bitcoin/cmr.h
 create mode 100644 simplicity-sys/depend/simplicity/include/simplicity/bitcoin/exec.h
 create mode 100644 src/jet/core/environment.rs

diff --git a/simplicity-sys/build.rs b/simplicity-sys/build.rs
index 4643be4a..7873473d 100644
--- a/simplicity-sys/build.rs
+++ b/simplicity-sys/build.rs
@@ -43,11 +43,17 @@ fn main() {
         );
     }
 
-    // Split into Bitcoin and Elements.
-    let mut elements_files = files.clone();
-    let mut bitcoin_files = files;
+    // Common files are compiled once into their own static library; Bitcoin
+    // and Elements each get their own library with only the chain-specific
+    // files. Duplicating the common files into both the Bitcoin and Elements
+    // libraries (as before) builds fine on stable (the linker only pulls the
+    // archive members it needs), but MSRV (1.74.0) forces `--whole-archive`
+    // on every native static lib, which pulls every object from both copies
+    // and fails with "multiple definition of" for every common symbol.
+    let common_files = files;
 
     // 3B. Bitcoin base files.
+    let mut bitcoin_files = vec![];
     bitcoin_files.extend(
         [
             "bitcoin/env.c",
@@ -61,6 +67,7 @@ fn main() {
     bitcoin_files.push("depend/bitcoin_env.c".into());
 
     // 3E. Elements base files.
+    let mut elements_files = vec![];
     elements_files.extend(
         [
             "elements/env.c",
@@ -103,8 +110,6 @@ fn main() {
         .std("c11")
         .flag_if_supported("-fno-inline-functions")
         .opt_level(2)
-        .file(Path::new("depend/wrapper.c"))
-        .file(Path::new("depend/jets_wrapper.c"))
         .include(simplicity_path.join("include"));
 
     if cfg!(not(fuzzing)) {
@@ -116,11 +121,24 @@ fn main() {
         build.include("wasm-sysroot");
     }
 
-    let mut _bitcoin_build = build.clone();
+    let mut common_build = build.clone();
+    let mut bitcoin_build = build.clone();
     let mut elements_build = build;
 
+    // Common build: files shared between Bitcoin and Elements, including the
+    // wrapper files. Compiled once into its own static library so neither
+    // the Bitcoin nor the Elements library contains these object files --
+    // see the comment above `common_files` for why that matters.
+    common_build
+        .file(Path::new("depend/wrapper.c"))
+        .file(Path::new("depend/jets_wrapper.c"))
+        .files(common_files)
+        .compile("RustSimplicityCommon");
+
     // Bitcoin build
-    // TODO
+    bitcoin_build
+        .files(bitcoin_files)
+        .compile("BitcoinSimplicity");
 
     // Elements build
     elements_build
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
+                           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+                           $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+                          )
diff --git a/simplicity-sys/depend/simplicity/bitcoin/cmr.c b/simplicity-sys/depend/simplicity/bitcoin/cmr.c
new file mode 100644
index 00000000..e230cd93
--- /dev/null
+++ b/simplicity-sys/depend/simplicity/bitcoin/cmr.c
@@ -0,0 +1,22 @@
+#include <simplicity/bitcoin/cmr.h>
+
+#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_8_bitcoin_computeCmr( simplicity_err* error, unsigned char* cmr
+                                   , const unsigned char* program, size_t program_len) {
+  return rustsimplicity_0_8_computeCmr(error, cmr, rustsimplicity_0_8_bitcoin_decodeJet, program, program_len);
+}
diff --git a/simplicity-sys/depend/simplicity/bitcoin/exec.c b/simplicity-sys/depend/simplicity/bitcoin/exec.c
new file mode 100644
index 00000000..bbe3f5a3
--- /dev/null
+++ b/simplicity-sys/depend/simplicity/bitcoin/exec.c
@@ -0,0 +1,136 @@
+#include <simplicity/bitcoin/exec.h>
+
+#include <stdalign.h>
+#include <string.h>
+#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_8_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_8_assert(NULL != error);
+  rustsimplicity_0_8_assert(NULL != tx);
+  rustsimplicity_0_8_assert(NULL != taproot);
+  rustsimplicity_0_8_assert(0 <= minCost);
+  rustsimplicity_0_8_assert(minCost <= budget);
+  rustsimplicity_0_8_assert(NULL != program || 0 == program_len);
+  rustsimplicity_0_8_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_8_decodeMallocDag(&dag, rustsimplicity_0_8_bitcoin_decodeJet, &census, &stream);
+    if (dag_len <= 0) {
+      rustsimplicity_0_8_assert(dag_len < 0);
+      *error = (simplicity_err)dag_len;
+      return IS_PERMANENT(*error);
+    }
+    rustsimplicity_0_8_assert(NULL != dag);
+    rustsimplicity_0_8_assert((uint_fast32_t)dag_len <= DAG_LEN_MAX);
+    *error = rustsimplicity_0_8_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_8_mallocTypeInference(&type_dag, rustsimplicity_0_8_bitcoin_mallocBoundVars, dag, (uint_fast32_t)dag_len, &census);
+    if (IS_OK(*error)) {
+      rustsimplicity_0_8_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_8_fillWitnessData(dag, type_dag, (uint_fast32_t)dag_len, &witness_stream);
+      if (IS_OK(*error)) {
+        *error = rustsimplicity_0_8_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_8_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_8_malloc((size_t)dag_len * sizeof(analyses));
+      if (analysis) {
+        rustsimplicity_0_8_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_8_free(analysis);
+    }
+    if (IS_OK(*error)) {
+      txEnv env = rustsimplicity_0_8_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_8_free(type_dag);
+  }
+
+  rustsimplicity_0_8_free(dag);
+  return IS_PERMANENT(*error);
+}
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 <stdbool.h>
+#include <stddef.h>
+#include <simplicity/errorCodes.h>
+#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/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 <stdbool.h>
+#include <stddef.h>
+#include <simplicity/errorCodes.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_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/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 <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <simplicity/errorCodes.h>
+#include <simplicity/bitcoin/env.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.
+ *
+ * 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/src/c_jets/c_env/bitcoin.rs b/simplicity-sys/src/c_jets/c_env/bitcoin.rs
index dfb3e8a8..b1517268 100644
--- a/simplicity-sys/src/c_jets/c_env/bitcoin.rs
+++ b/simplicity-sys/src/c_jets/c_env/bitcoin.rs
@@ -68,7 +68,6 @@ pub struct CTapEnv {
     _data: (),
 }
 
-/*
 // Will uncomment in a later commit; need to update libsimplicity first so these
 // symbols have something to link against.
 extern "C" {
@@ -110,7 +109,7 @@ extern "C" {
     #[link_name = "rustsimplicity_0_8_bitcoin_mallocTransaction"]
     pub fn simplicity_mallocTransaction(rawTx: *const CRawTransaction) -> *mut CTransaction;
 }
-*/
+
 impl CTxEnv {
     pub fn sighash_all(&self) -> sha256::Hash {
         let midstate: sha256::Midstate = self.sighash_all.into();
@@ -137,7 +136,6 @@ impl CRawBuffer {
     }
 }
 
-/*
 // Will uncomment in a later commit; need to update libsimplicity first.
 #[cfg(test)]
 mod tests {
@@ -173,4 +171,3 @@ mod tests {
         }
     }
 }
-*/
diff --git a/src/jet/bitcoin/environment.rs b/src/jet/bitcoin/environment.rs
index 22c9f85a..ba0eae40 100644
--- a/src/jet/bitcoin/environment.rs
+++ b/src/jet/bitcoin/environment.rs
@@ -3,8 +3,7 @@
 use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin;
 
 /// Environment for Bitcoin Simplicity
-// In later commit, when we update Jet trait, will remove default type.
-pub struct BitcoinEnv<T = bitcoin::Transaction> {
+pub struct BitcoinEnv<T> {
     pub tx: T,
 }
 
diff --git a/src/jet/bitcoin/mod.rs b/src/jet/bitcoin/mod.rs
index d4faa7ae..357908ff 100644
--- a/src/jet/bitcoin/mod.rs
+++ b/src/jet/bitcoin/mod.rs
@@ -8,7 +8,7 @@ use super::init::bitcoin::Bitcoin;
 use super::JetEnvironment;
 use simplicity_sys::c_jets::frame_ffi::CFrameItem;
 
-impl JetEnvironment for BitcoinEnv {
+impl<T: core::borrow::Borrow<bitcoin::Transaction>> JetEnvironment for BitcoinEnv<T> {
     type Jet = Bitcoin;
     type CJetEnvironment = ();
 
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 @@
+

From 179a9c516b2a673499f69a86637b109d70b8ce37 Mon Sep 17 00:00:00 2001
From: Byron Hambly <bhambly@blockstream.com>
Date: Mon, 7 Sep 2026 14:40:12 +0200
Subject: [PATCH 06/16] jet: generalize JetEnvironment impls to use Borrow<T>

Change the JetEnvironment impl for BitcoinEnv and ElementsEnv to be
generic over T: Borrow<Transaction> instead of fixed to Arc<Transaction>.
Update Policy::satisfy, get_satisfier, execute_successful,
execute_unsuccessful, and serialize test helpers to accept
ElementsEnv<impl Borrow<Transaction>>.

This allows callers to construct environments without Arc overhead (for
example, using a plain reference or owned value), and is required so
that BitcoinEnv::c_jet_env can return a real CTxEnv from a borrowed
transaction.
---
 src/jet/elements/mod.rs |  2 +-
 src/policy/satisfy.rs   | 16 +++++++++-------
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/jet/elements/mod.rs b/src/jet/elements/mod.rs
index c36ed73a..35a4ae33 100644
--- a/src/jet/elements/mod.rs
+++ b/src/jet/elements/mod.rs
@@ -15,7 +15,7 @@ use simplicity_sys::CElementsTxEnv;
 /// Type alias for the Elements transaction environment.
 pub type ElementsTxEnv = ElementsEnv<std::sync::Arc<elements::Transaction>>;
 
-impl JetEnvironment for ElementsTxEnv {
+impl<T: core::borrow::Borrow<elements::Transaction>> JetEnvironment for ElementsEnv<T> {
     type Jet = Elements;
     type CJetEnvironment = CElementsTxEnv;
 
diff --git a/src/policy/satisfy.rs b/src/policy/satisfy.rs
index 534c5b5a..52c0713e 100644
--- a/src/policy/satisfy.rs
+++ b/src/policy/satisfy.rs
@@ -268,7 +268,7 @@ impl<Pk: ToXOnlyPubkey> Policy<Pk> {
     pub fn satisfy<'brand, S: Satisfier<'brand, Pk>>(
         &self,
         satisfier: &S,
-        env: &ElementsEnv<Arc<elements::Transaction>>,
+        env: &ElementsEnv<impl core::borrow::Borrow<elements::Transaction>>,
     ) -> Result<Arc<RedeemNode>, SatisfierError> {
         let result = self.satisfy_internal(satisfier)?;
         match result.into_node() {
@@ -332,10 +332,9 @@ mod tests {
         }
     }
 
-    fn get_satisfier<'tx, 'brand>(
+    fn get_satisfier<'tx, 'brand, T: core::borrow::Borrow<elements::Transaction>>(
         context: types::Context<'brand>,
-
-        env: &'tx ElementsEnv<Arc<elements::Transaction>>,
+        env: &'tx ElementsEnv<T>,
     ) -> PolicySatisfier<'tx, 'brand, XOnlyPublicKey> {
         let mut preimages = HashMap::new();
 
@@ -372,14 +371,17 @@ mod tests {
         }
     }
 
-    fn execute_successful(program: Arc<RedeemNode>, env: &ElementsEnv<Arc<elements::Transaction>>) {
+    fn execute_successful<T: core::borrow::Borrow<elements::Transaction>>(
+        program: Arc<RedeemNode>,
+        env: &ElementsEnv<T>,
+    ) {
         let mut mac = BitMachine::for_program(&program).unwrap();
         assert!(mac.exec(&program, env).is_ok());
     }
 
-    fn execute_unsuccessful(
+    fn execute_unsuccessful<T: core::borrow::Borrow<elements::Transaction>>(
         program: Arc<RedeemNode>,
-        env: &ElementsEnv<Arc<elements::Transaction>>,
+        env: &ElementsEnv<T>,
     ) {
         let mut mac = BitMachine::for_program(&program).unwrap();
         assert!(mac.exec(&program, env).is_err());

From 1dfdf0f4c151fdd0ec77f7aed6dfb9ec50bfd2b0 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Thu, 11 Sep 2025 16:38:08 +0000
Subject: [PATCH 07/16] jet: drop unnecessary Arcs in environments

Now that we've updated the Jet trait to allow the transactions in environments
to be arbitrary T: Borrow<Transaction>, we don't need to use Arc everywhere.
In many cases we can use normal references.
---
 src/human_encoding/parse/mod.rs |  5 ++---
 src/jet/elements/environment.rs |  6 +++---
 src/node/redeem.rs              | 10 +++++-----
 src/policy/serialize.rs         |  4 ++--
 4 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/src/human_encoding/parse/mod.rs b/src/human_encoding/parse/mod.rs
index 64045a77..d42d7647 100644
--- a/src/human_encoding/parse/mod.rs
+++ b/src/human_encoding/parse/mod.rs
@@ -713,11 +713,10 @@ mod tests {
     #[cfg(feature = "elements")]
     fn bip340_program() {
         use crate::jet::elements::ElementsEnv;
-        use crate::jet::ElementsTxEnv;
 
         let empty = HashMap::new();
         let dummy = ElementsEnv::dummy();
-        assert_cmr_witness::<ElementsTxEnv>(
+        assert_cmr_witness::<ElementsEnv<elements::Transaction>>(
             "main := unit",
             "c40a10263f7436b4160acbef1c36fba4be4d95df181a968afeab5eac247adff7",
             &empty,
@@ -734,7 +733,7 @@ mod tests {
         ];
 
         let signature = HashMap::from([(Arc::from("wit1"), Value::u512(sig))]);
-        assert_cmr_witness::<ElementsTxEnv>(
+        assert_cmr_witness::<ElementsEnv<elements::Transaction>>(
             "
                 -- Witnesses
                 wit1 := witness : 1 -> 2^512
diff --git a/src/jet/elements/environment.rs b/src/jet/elements/environment.rs
index 812bf388..e022753c 100644
--- a/src/jet/elements/environment.rs
+++ b/src/jet/elements/environment.rs
@@ -110,7 +110,7 @@ where
 }
 
 #[cfg(test)]
-impl ElementsEnv<std::sync::Arc<elements::Transaction>> {
+impl ElementsEnv<elements::Transaction> {
     /// Return a dummy Elements environment
     pub fn dummy() -> Self {
         Self::dummy_with(elements::LockTime::ZERO, elements::Sequence::MAX)
@@ -127,7 +127,7 @@ impl ElementsEnv<std::sync::Arc<elements::Transaction>> {
         ];
 
         ElementsEnv::new(
-            std::sync::Arc::new(elements::Transaction {
+            elements::Transaction {
                 version: 2,
                 lock_time,
                 // Enable locktime in dummy txin
@@ -140,7 +140,7 @@ impl ElementsEnv<std::sync::Arc<elements::Transaction>> {
                     witness: elements::TxInWitness::default(),
                 }],
                 output: Vec::default(),
-            }),
+            },
             vec![ElementsUtxo {
                 script_pubkey: elements::Script::new(),
                 asset: confidential::Asset::Null,
diff --git a/src/node/redeem.rs b/src/node/redeem.rs
index c8748217..89202b5d 100644
--- a/src/node/redeem.rs
+++ b/src/node/redeem.rs
@@ -1050,7 +1050,7 @@ mod tests {
     #[test]
     #[cfg(all(feature = "elements", feature = "human_encoding"))]
     fn prune() {
-        use crate::jet::ElementsTxEnv;
+        use crate::jet::elements::ElementsEnv;
 
         let env = crate::jet::elements::ElementsEnv::dummy();
 
@@ -1083,7 +1083,7 @@ main := comp input comp process jet_verify : 1 -> 1"#;
                 Value::product(Value::u64(0), Value::unit()),
             ),
         ]);
-        assert_correct_pruning::<ElementsTxEnv>(
+        assert_correct_pruning::<ElementsEnv<elements::Transaction>>(
             unpruned_prog,
             &unpruned_wit,
             pruned_prog,
@@ -1111,7 +1111,7 @@ main := comp input comp process jet_verify : 1 -> 1"#;
                 Value::product(Value::unit(), Value::u64(0)),
             ),
         ]);
-        assert_correct_pruning::<ElementsTxEnv>(
+        assert_correct_pruning::<ElementsEnv<elements::Transaction>>(
             unpruned_prog,
             &unpruned_wit,
             pruned_prog,
@@ -1136,7 +1136,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::<ElementsTxEnv>(
+        assert_correct_pruning::<ElementsEnv<elements::Transaction>>(
             prune_sum,
             &unpruned_wit,
             pruned_prog,
@@ -1157,7 +1157,7 @@ main := comp input comp process jet_verify : 1 -> 1"#;
             Arc::from("wit1"),
             Value::right(Final::unit(), Value::u64(0)),
         )]);
-        assert_correct_pruning::<ElementsTxEnv>(
+        assert_correct_pruning::<ElementsEnv<elements::Transaction>>(
             prune_sum,
             &unpruned_wit,
             pruned_prog,
diff --git a/src/policy/serialize.rs b/src/policy/serialize.rs
index b56ca453..ae5c376a 100644
--- a/src/policy/serialize.rs
+++ b/src/policy/serialize.rs
@@ -257,7 +257,7 @@ mod tests {
 
     fn compile(
         policy: Policy<XOnlyPublicKey>,
-    ) -> (Arc<CommitNode>, ElementsEnv<Arc<elements::Transaction>>) {
+    ) -> (Arc<CommitNode>, ElementsEnv<elements::Transaction>) {
         let commit = policy.commit();
         let env = ElementsEnv::dummy();
 
@@ -267,7 +267,7 @@ mod tests {
     fn execute_successful(
         commit: &CommitNode,
         witness: Vec<Value>,
-        env: &ElementsEnv<Arc<elements::Transaction>>,
+        env: &ElementsEnv<elements::Transaction>,
     ) -> bool {
         let finalized = commit
             .finalize(&mut SimpleFinalizer::new(witness.into_iter()))

From e85d8f576c82c8058ff9e346d9cc4973f3f02456 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Wed, 1 Oct 2025 23:38:11 +0000
Subject: [PATCH 08/16] jet: implement Rust bitcoin environment

This is a Rust type which can be used, among other things, to construct
the transaction environment needed by C jets.

Also provides accessors for the underlying transaction and input index,
both of which are used (in the Elements version of this struct) in the
policy satisfier.
---
 src/jet/bitcoin/c_env.rs       | 84 ++++++++++++++++++++++++++++++++++
 src/jet/bitcoin/environment.rs | 37 +++++++++++++--
 src/jet/bitcoin/mod.rs         |  1 +
 3 files changed, 118 insertions(+), 4 deletions(-)
 create mode 100644 src/jet/bitcoin/c_env.rs

diff --git a/src/jet/bitcoin/c_env.rs b/src/jet/bitcoin/c_env.rs
new file mode 100644
index 00000000..5dd27a7c
--- /dev/null
+++ b/src/jet/bitcoin/c_env.rs
@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: CC0-1.0
+
+use crate::Cmr;
+
+use bitcoin::hashes::Hash as _;
+use bitcoin::taproot::ControlBlock;
+use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin;
+
+pub(super) fn new_tx(
+    tx: &bitcoin::Transaction,
+    in_utxos: &[bitcoin::TxOut],
+) -> *mut c_bitcoin::CTransaction {
+    let mut raw_inputs = Vec::with_capacity(tx.input.len());
+    let mut raw_outputs = Vec::with_capacity(tx.output.len());
+
+    for (inp, utxo) in tx.input.iter().zip(in_utxos.iter()) {
+        raw_inputs.push(c_bitcoin::CRawInput {
+            // FIXME actually pass the annex in; see https://github.com/BlockstreamResearch/simplicity/issues/311 for some difficulty here.
+            annex: core::ptr::null(),
+            prev_txid: inp.previous_output.txid.as_byte_array(),
+            txo: c_bitcoin::CRawOutput {
+                value: utxo.value.to_sat(),
+                script_pubkey: c_bitcoin::CRawBuffer::new(utxo.script_pubkey.as_bytes()),
+            },
+            script_sig: c_bitcoin::CRawBuffer::new(inp.script_sig.as_bytes()),
+            prev_txout_index: inp.previous_output.vout,
+            sequence: inp.sequence.to_consensus_u32(),
+        });
+    }
+    for out in tx.output.iter() {
+        raw_outputs.push(c_bitcoin::CRawOutput {
+            value: out.value.to_sat(),
+            script_pubkey: c_bitcoin::CRawBuffer::new(out.script_pubkey.as_bytes()),
+        });
+    }
+    let txid = tx.compute_txid();
+
+    let c_raw_tx = c_bitcoin::CRawTransaction {
+        txid: txid.as_byte_array(),
+        inputs: raw_inputs.as_ptr(),
+        outputs: raw_outputs.as_ptr(),
+        n_inputs: raw_inputs.len().try_into().expect("sane length"),
+        n_outputs: raw_outputs.len().try_into().expect("sane length"),
+        version: tx.version.0 as u32, // in 1.87.0 can use .cast_unsigned
+        locktime: tx.lock_time.to_consensus_u32(),
+    };
+    unsafe {
+        // SAFETY: this is a FFI call and we constructed its argument correctly.
+        c_bitcoin::simplicity_mallocTransaction(&c_raw_tx)
+    }
+}
+
+pub(super) fn new_tap_env(
+    control_block: &ControlBlock,
+    script_cmr: Cmr,
+) -> *mut c_bitcoin::CTapEnv {
+    let cb_ser = control_block.serialize();
+    let raw_tap_env = c_bitcoin::CRawTapEnv {
+        control_block: cb_ser.as_ptr(),
+        script_cmr: script_cmr.as_ref().as_ptr(),
+        branch_len: control_block
+            .merkle_branch
+            .len()
+            .try_into()
+            .expect("sane length"),
+    };
+
+    unsafe {
+        // SAFETY: this is a FFI call and we constructed its argument correctly.
+        c_bitcoin::simplicity_mallocTapEnv(&raw_tap_env)
+    }
+}
+
+pub(super) fn new_tx_env(
+    tx: *const c_bitcoin::CTransaction,
+    taproot: *const c_bitcoin::CTapEnv,
+    ix: u32,
+) -> c_bitcoin::CTxEnv {
+    unsafe {
+        let mut tx_env = std::mem::MaybeUninit::<c_bitcoin::CTxEnv>::uninit();
+        c_bitcoin::c_set_txEnv(tx_env.as_mut_ptr(), tx, taproot, ix);
+        tx_env.assume_init()
+    }
+}
diff --git a/src/jet/bitcoin/environment.rs b/src/jet/bitcoin/environment.rs
index ba0eae40..2980ca18 100644
--- a/src/jet/bitcoin/environment.rs
+++ b/src/jet/bitcoin/environment.rs
@@ -1,21 +1,50 @@
 // SPDX-License-Identifier: CC0-1.0
 
+use crate::Cmr;
+
+use bitcoin::taproot::ControlBlock;
 use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin;
 
+use super::c_env;
+
 /// Environment for Bitcoin Simplicity
 pub struct BitcoinEnv<T> {
-    pub tx: T,
+    /// The CTxEnv struct
+    c_tx_env: c_bitcoin::CTxEnv,
+    tx: T,
+    ix: u32,
 }
 
 impl<T> BitcoinEnv<T>
 where
     T: core::borrow::Borrow<bitcoin::Transaction>,
 {
-    pub fn new(tx: T) -> Self {
-        BitcoinEnv { tx }
+    pub fn new(
+        tx: T,
+        utxos: &[bitcoin::TxOut],
+        ix: u32,
+        script_cmr: Cmr,
+        control_block: ControlBlock,
+    ) -> Self {
+        let c_tx = c_env::new_tx(tx.borrow(), utxos);
+        let c_tap_env = c_env::new_tap_env(&control_block, script_cmr);
+        let c_tx_env = c_env::new_tx_env(c_tx, c_tap_env, ix);
+
+        BitcoinEnv { c_tx_env, tx, ix }
+    }
+
+    /// The transaction of this environment
+    pub fn tx(&self) -> &bitcoin::Transaction {
+        self.tx.borrow()
+    }
+
+    /// The input index of this environment
+    pub fn ix(&self) -> u32 {
+        self.ix
     }
 
+    /// A version of this environment used by the C implementation of the Bit Machine.
     pub fn c_tx_env(&self) -> &c_bitcoin::CTxEnv {
-        unimplemented!()
+        &self.c_tx_env
     }
 }
diff --git a/src/jet/bitcoin/mod.rs b/src/jet/bitcoin/mod.rs
index 357908ff..61b56565 100644
--- a/src/jet/bitcoin/mod.rs
+++ b/src/jet/bitcoin/mod.rs
@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: CC0-1.0
 
+mod c_env;
 mod environment;
 
 pub use environment::BitcoinEnv;

From cae2c23c63756f9d4db0de99b80f80157545f417 Mon Sep 17 00:00:00 2001
From: Andrew Poelstra <apoelstra@wpsoftware.net>
Date: Thu, 18 Dec 2025 18:43:48 +0000
Subject: [PATCH 09/16] jet: populate annexes in Bitcoin environment

---
 src/jet/bitcoin/c_env.rs | 29 ++++++++++++++++++++++++-----
 1 file changed, 24 insertions(+), 5 deletions(-)

diff --git a/src/jet/bitcoin/c_env.rs b/src/jet/bitcoin/c_env.rs
index 5dd27a7c..1b01d9da 100644
--- a/src/jet/bitcoin/c_env.rs
+++ b/src/jet/bitcoin/c_env.rs
@@ -12,11 +12,24 @@ pub(super) fn new_tx(
 ) -> *mut c_bitcoin::CTransaction {
     let mut raw_inputs = Vec::with_capacity(tx.input.len());
     let mut raw_outputs = Vec::with_capacity(tx.output.len());
+    // Allocate space for the raw annexes. This dumb `Vec::from_iter` construction is
+    // equivalent to `vec![None; tx.input.len()]`, but that won't compile because it
+    // requires Option::<CRawBuffer>::None to be cloneable, which it's not because
+    // CRawBuffer isn't.
 
-    for (inp, utxo) in tx.input.iter().zip(in_utxos.iter()) {
+    // SAFETY: this allocation *must* live until after the `simplicity_mallocTransaction`
+    //  at the bottom of this function. We convert the vector to a boxed slice to ensure
+    //  it cannot be resized, which would potentially trigger a reallocation.
+    let mut raw_annexes = Vec::from_iter((0..tx.input.len()).map(|_| None)).into_boxed_slice();
+
+    for (n, (inp, utxo)) in tx.input.iter().zip(in_utxos.iter()).enumerate() {
+        raw_annexes[n] = inp.witness.taproot_annex().map(c_bitcoin::CRawBuffer::new);
         raw_inputs.push(c_bitcoin::CRawInput {
-            // FIXME actually pass the annex in; see https://github.com/BlockstreamResearch/simplicity/issues/311 for some difficulty here.
-            annex: core::ptr::null(),
+            // This `as_ref().map_or()` construction converts an Option<&T> to a nullable *const T.
+            // In theory it's a no-op.
+            annex: raw_annexes[n]
+                .as_ref()
+                .map_or(core::ptr::null(), |ptr| ptr as *const _), // cast should be changed to ptr::from_ref in rust 1.76
             prev_txid: inp.previous_output.txid.as_byte_array(),
             txo: c_bitcoin::CRawOutput {
                 value: utxo.value.to_sat(),
@@ -44,10 +57,16 @@ pub(super) fn new_tx(
         version: tx.version.0 as u32, // in 1.87.0 can use .cast_unsigned
         locktime: tx.lock_time.to_consensus_u32(),
     };
-    unsafe {
+    let ret = unsafe {
         // SAFETY: this is a FFI call and we constructed its argument correctly.
         c_bitcoin::simplicity_mallocTransaction(&c_raw_tx)
-    }
+    };
+    // Explicitly drop raw_annexes so Rust doesn't try any funny business dropping it early.
+    // Drop raw_inputs first since it contains pointers into raw_annexes and we don't want
+    // them to dangle. (It'd be safe since they're raw pointers, but still bad mojo.)
+    drop(raw_inputs);
+    drop(raw_annexes);
+    ret
 }
 
 pub(super) fn new_tap_env(

From 1f91d94d93c6db5ea845d003c902920b55105d99 Mon Sep 17 00:00:00 2001
From: Byron Hambly <bhambly@blockstream.com>
Date: Mon, 7 Sep 2026 14:40:13 +0200
Subject: [PATCH 10/16] bitcoin: extract annex per BIP341 instead of
 Witness::taproot_annex

rust-bitcoin 0.32 removed Witness::taproot_annex. Replace it with an
inline BIP341 annex extraction: the last witness element that begins
with 0x50 is the annex. This matches the Elements c_env helper and the
BIP341 specification.
---
 src/jet/bitcoin/c_env.rs | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/jet/bitcoin/c_env.rs b/src/jet/bitcoin/c_env.rs
index 1b01d9da..53494d91 100644
--- a/src/jet/bitcoin/c_env.rs
+++ b/src/jet/bitcoin/c_env.rs
@@ -3,7 +3,7 @@
 use crate::Cmr;
 
 use bitcoin::hashes::Hash as _;
-use bitcoin::taproot::ControlBlock;
+use bitcoin::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
 use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin;
 
 pub(super) fn new_tx(
@@ -23,7 +23,7 @@ pub(super) fn new_tx(
     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_annexes[n] = get_annex(&inp.witness).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.
@@ -101,3 +101,15 @@ pub(super) fn new_tx_env(
         tx_env.assume_init()
     }
 }
+
+/// Extracts the annex from a taproot witness stack per BIP341: if there are at
+/// least two witness elements and the last one starts with 0x50, it is the annex.
+/// (rust-bitcoin 0.32 removed `Witness::taproot_annex`.)
+fn get_annex(in_witness: &bitcoin::Witness) -> Option<&[u8]> {
+    let last_item = in_witness.last()?;
+    if *last_item.first()? == TAPROOT_ANNEX_PREFIX {
+        Some(last_item)
+    } else {
+        None
+    }
+}

From 85cf69446f57289ab154aa5f93a38425ec18b1d5 Mon Sep 17 00:00:00 2001
From: Byron Hambly <bhambly@blockstream.com>
Date: Mon, 7 Sep 2026 14:40:13 +0200
Subject: [PATCH 11/16] jet: populate Bitcoin CMR table

Replace the unimplemented!() stub in Bitcoin::cmr() with a match table
of 32-byte CMR values. Each entry is derived from the canonical
primitiveJetNode.inc in libsimplicity. The table covers all jets in the
Bitcoin jet set.

The cost() method remains a stub pending a separate commit.
---
 src/jet/init/bitcoin.rs | 2145 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 2144 insertions(+), 1 deletion(-)

diff --git a/src/jet/init/bitcoin.rs b/src/jet/init/bitcoin.rs
index c93f7cfb..93f72901 100644
--- a/src/jet/init/bitcoin.rs
+++ b/src/jet/init/bitcoin.rs
@@ -880,7 +880,2150 @@ impl Bitcoin {
 impl Jet for Bitcoin {
 
     fn cmr(&self) -> Cmr {
-        unimplemented!("Bitcoin jet CMRs weights have not yet been implemented.")
+        let bytes = match self {
+            Bitcoin::Add16 => [
+                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,
+            ],
+            Bitcoin::Add32 => [
+                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,
+            ],
+            Bitcoin::Add64 => [
+                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,
+            ],
+            Bitcoin::Add8 => [
+                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,
+            ],
+            Bitcoin::All16 => [
+                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,
+            ],
+            Bitcoin::All32 => [
+                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,
+            ],
+            Bitcoin::All64 => [
+                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,
+            ],
+            Bitcoin::All8 => [
+                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,
+            ],
+            Bitcoin::And1 => [
+                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,
+            ],
+            Bitcoin::And16 => [
+                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,
+            ],
+            Bitcoin::And32 => [
+                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,
+            ],
+            Bitcoin::And64 => [
+                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,
+            ],
+            Bitcoin::And8 => [
+                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,
+            ],
+            Bitcoin::AnnexHash => [
+                0x51, 0xfa, 0x19, 0x13, 0xa6, 0x29, 0x73, 0x48, 0x4a, 0x70, 0x0a, 0xf3, 0xff, 0x93,
+                0x26, 0x94, 0xd3, 0x89, 0x0a, 0xe0, 0xad, 0x87, 0xa4, 0x55, 0xda, 0xf4, 0x90, 0x6f,
+                0x22, 0x4a, 0x48, 0xd5,
+            ],
+            Bitcoin::Bip0340Verify => [
+                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,
+            ],
+            Bitcoin::BuildTapbranch => [
+                0xef, 0x8e, 0x92, 0x91, 0x9b, 0x26, 0x08, 0xea, 0x6b, 0x5b, 0xcd, 0xd3, 0x9c, 0x51,
+                0x78, 0xe5, 0x46, 0x24, 0x95, 0x53, 0x91, 0x4b, 0x0f, 0x8d, 0x33, 0x73, 0x5d, 0x28,
+                0x86, 0xe1, 0xa5, 0xe8,
+            ],
+            Bitcoin::BuildTapleafSimplicity => [
+                0x22, 0x41, 0x19, 0x09, 0x98, 0x41, 0x47, 0xde, 0x8f, 0x5a, 0x04, 0x28, 0x35, 0x8b,
+                0x47, 0x16, 0xdb, 0x08, 0x76, 0x64, 0xa7, 0x28, 0x56, 0x08, 0x52, 0xb0, 0xe6, 0x16,
+                0xeb, 0xc6, 0x2d, 0x30,
+            ],
+            Bitcoin::BuildTaptweak => [
+                0xf1, 0x92, 0xdb, 0x17, 0x06, 0x60, 0x8d, 0xef, 0x16, 0x5d, 0xbd, 0xda, 0x72, 0xa3,
+                0x8c, 0x88, 0x82, 0xcb, 0x36, 0xc6, 0xda, 0x47, 0x07, 0x0d, 0x8a, 0x5f, 0x58, 0x96,
+                0xfb, 0xda, 0x84, 0x34,
+            ],
+            Bitcoin::Ch1 => [
+                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,
+            ],
+            Bitcoin::Ch16 => [
+                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,
+            ],
+            Bitcoin::Ch32 => [
+                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,
+            ],
+            Bitcoin::Ch64 => [
+                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,
+            ],
+            Bitcoin::Ch8 => [
+                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,
+            ],
+            Bitcoin::CheckLockDistance => [
+                0x38, 0xfd, 0xf7, 0xdd, 0x28, 0x53, 0x86, 0x70, 0xfb, 0x34, 0xc1, 0xbf, 0xe7, 0x2f,
+                0x17, 0xe2, 0xca, 0x57, 0x84, 0xf8, 0x7f, 0xed, 0x88, 0xea, 0xb5, 0x84, 0x79, 0x2b,
+                0x39, 0x74, 0xbd, 0x18,
+            ],
+            Bitcoin::CheckLockDuration => [
+                0x77, 0x50, 0x38, 0x32, 0x6e, 0xae, 0x25, 0xc7, 0x20, 0x9b, 0x24, 0x43, 0x06, 0xea,
+                0xa9, 0xf9, 0x20, 0x4c, 0x7e, 0xce, 0x2d, 0xd6, 0x3b, 0x45, 0x2e, 0x10, 0x01, 0x7f,
+                0xa4, 0xea, 0x53, 0xcf,
+            ],
+            Bitcoin::CheckLockHeight => [
+                0xb9, 0x0f, 0x15, 0x1f, 0x45, 0xb4, 0xeb, 0x37, 0x21, 0x06, 0x21, 0xf9, 0x70, 0x0a,
+                0x36, 0xc8, 0xc5, 0x04, 0xbe, 0xe0, 0x67, 0x77, 0x11, 0x63, 0xa8, 0xb8, 0x3a, 0x77,
+                0x18, 0xe6, 0x68, 0x6a,
+            ],
+            Bitcoin::CheckLockTime => [
+                0xa4, 0x51, 0xeb, 0xb2, 0x25, 0xd6, 0xb1, 0x33, 0xa5, 0xe6, 0x35, 0x39, 0x78, 0x00,
+                0xd4, 0x87, 0xb3, 0x96, 0x8b, 0x0d, 0xe5, 0x5c, 0x96, 0xeb, 0x82, 0xf2, 0x90, 0xec,
+                0xff, 0x9c, 0x25, 0x90,
+            ],
+            Bitcoin::CheckSigVerify => [
+                0xb5, 0x80, 0x15, 0x54, 0x6d, 0x28, 0x52, 0x66, 0x5d, 0xd2, 0x1b, 0xf1, 0x12, 0x66,
+                0x26, 0x70, 0x20, 0xfa, 0x5e, 0x27, 0x50, 0x01, 0xdd, 0x46, 0x18, 0xfa, 0x41, 0x56,
+                0x25, 0x95, 0x2e, 0x68,
+            ],
+            Bitcoin::Complement1 => [
+                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,
+            ],
+            Bitcoin::Complement16 => [
+                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,
+            ],
+            Bitcoin::Complement32 => [
+                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,
+            ],
+            Bitcoin::Complement64 => [
+                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,
+            ],
+            Bitcoin::Complement8 => [
+                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,
+            ],
+            Bitcoin::CurrentAnnexHash => [
+                0xce, 0xd9, 0x02, 0x2e, 0xdc, 0x69, 0x24, 0x1f, 0xe7, 0x07, 0x49, 0xa7, 0xf5, 0xd4,
+                0x89, 0xc3, 0x13, 0x5e, 0xe8, 0xc9, 0x6f, 0xe6, 0x4c, 0x44, 0x64, 0x40, 0x1f, 0x98,
+                0x51, 0xd7, 0xa1, 0x7d,
+            ],
+            Bitcoin::CurrentIndex => [
+                0x0e, 0x8c, 0x96, 0x4c, 0x2f, 0x2b, 0x34, 0x90, 0x36, 0x2f, 0x3b, 0xbc, 0x74, 0x83,
+                0xde, 0xa3, 0x7f, 0xda, 0x81, 0x0b, 0x69, 0x31, 0x4f, 0xf6, 0x64, 0xfe, 0xa0, 0xe3,
+                0x27, 0x08, 0xec, 0x8f,
+            ],
+            Bitcoin::CurrentPrevOutpoint => [
+                0x64, 0x43, 0x39, 0x1b, 0x34, 0x40, 0x86, 0x84, 0x6d, 0x5a, 0x17, 0xa6, 0x2e, 0x3e,
+                0x06, 0x28, 0x2a, 0xd6, 0x96, 0x2c, 0x4d, 0xfc, 0xed, 0x2f, 0x6a, 0x83, 0xd0, 0xdf,
+                0xbf, 0x6a, 0x5c, 0x54,
+            ],
+            Bitcoin::CurrentScriptHash => [
+                0x23, 0x49, 0x8d, 0xd6, 0x64, 0x5e, 0xd1, 0x38, 0xb3, 0x44, 0x93, 0x7c, 0xf6, 0x54,
+                0xaa, 0xff, 0xa6, 0x27, 0xf8, 0x5a, 0x47, 0xca, 0xa6, 0x89, 0x54, 0xf1, 0x3f, 0x4c,
+                0x6a, 0x4d, 0xc7, 0x72,
+            ],
+            Bitcoin::CurrentScriptSigHash => [
+                0x34, 0xa3, 0xc5, 0x5d, 0x14, 0x73, 0x74, 0xd8, 0xf3, 0xa1, 0x76, 0x1b, 0xba, 0xb2,
+                0x86, 0x96, 0x84, 0x55, 0x40, 0x4c, 0x2c, 0xa0, 0x3f, 0x69, 0x39, 0x3f, 0x63, 0x39,
+                0xd0, 0xf5, 0x8b, 0x59,
+            ],
+            Bitcoin::CurrentSequence => [
+                0xc4, 0x9f, 0x76, 0xac, 0x79, 0xf8, 0xf1, 0x5c, 0x40, 0x9b, 0xa8, 0x15, 0xc1, 0x6e,
+                0xdc, 0xb8, 0xd1, 0x1e, 0x9a, 0x07, 0x56, 0x5c, 0x8e, 0x09, 0xb6, 0x3e, 0x7f, 0xdf,
+                0x31, 0x03, 0x00, 0x9f,
+            ],
+            Bitcoin::CurrentValue => [
+                0x91, 0xb9, 0x6e, 0x82, 0x9e, 0x3b, 0x49, 0x72, 0xb0, 0xcb, 0x09, 0x1a, 0x0a, 0x90,
+                0x4b, 0xa4, 0x11, 0x33, 0x8a, 0xbf, 0xc0, 0x8d, 0xa7, 0x86, 0xd5, 0xa8, 0x4f, 0x04,
+                0x9b, 0x5b, 0xa3, 0xb8,
+            ],
+            Bitcoin::Decompress => [
+                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,
+            ],
+            Bitcoin::Decrement16 => [
+                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,
+            ],
+            Bitcoin::Decrement32 => [
+                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,
+            ],
+            Bitcoin::Decrement64 => [
+                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,
+            ],
+            Bitcoin::Decrement8 => [
+                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,
+            ],
+            Bitcoin::DivMod128_64 => [
+                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,
+            ],
+            Bitcoin::DivMod16 => [
+                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,
+            ],
+            Bitcoin::DivMod32 => [
+                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,
+            ],
+            Bitcoin::DivMod64 => [
+                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,
+            ],
+            Bitcoin::DivMod8 => [
+                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,
+            ],
+            Bitcoin::Divide16 => [
+                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,
+            ],
+            Bitcoin::Divide32 => [
+                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,
+            ],
+            Bitcoin::Divide64 => [
+                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,
+            ],
+            Bitcoin::Divide8 => [
+                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,
+            ],
+            Bitcoin::Divides16 => [
+                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,
+            ],
+            Bitcoin::Divides32 => [
+                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,
+            ],
+            Bitcoin::Divides64 => [
+                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,
+            ],
+            Bitcoin::Divides8 => [
+                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,
+            ],
+            Bitcoin::Eq1 => [
+                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,
+            ],
+            Bitcoin::Eq16 => [
+                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,
+            ],
+            Bitcoin::Eq256 => [
+                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,
+            ],
+            Bitcoin::Eq32 => [
+                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,
+            ],
+            Bitcoin::Eq64 => [
+                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,
+            ],
+            Bitcoin::Eq8 => [
+                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,
+            ],
+            Bitcoin::FeAdd => [
+                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,
+            ],
+            Bitcoin::FeInvert => [
+                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,
+            ],
+            Bitcoin::FeIsOdd => [
+                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,
+            ],
+            Bitcoin::FeIsZero => [
+                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,
+            ],
+            Bitcoin::FeMultiply => [
+                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,
+            ],
+            Bitcoin::FeMultiplyBeta => [
+                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,
+            ],
+            Bitcoin::FeNegate => [
+                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,
+            ],
+            Bitcoin::FeNormalize => [
+                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,
+            ],
+            Bitcoin::FeSquare => [
+                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,
+            ],
+            Bitcoin::FeSquareRoot => [
+                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,
+            ],
+            Bitcoin::Fee => [
+                0xfb, 0x9c, 0xa9, 0x39, 0x81, 0x67, 0x3d, 0x1d, 0x23, 0xae, 0xd2, 0x4d, 0x61, 0x2c,
+                0x1f, 0x5d, 0xc7, 0xcd, 0x49, 0xf8, 0x6d, 0x34, 0x8e, 0x67, 0xa1, 0x5b, 0xc4, 0xa7,
+                0x13, 0x0a, 0xe1, 0x85,
+            ],
+            Bitcoin::FullAdd16 => [
+                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,
+            ],
+            Bitcoin::FullAdd32 => [
+                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,
+            ],
+            Bitcoin::FullAdd64 => [
+                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,
+            ],
+            Bitcoin::FullAdd8 => [
+                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,
+            ],
+            Bitcoin::FullDecrement16 => [
+                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,
+            ],
+            Bitcoin::FullDecrement32 => [
+                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,
+            ],
+            Bitcoin::FullDecrement64 => [
+                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,
+            ],
+            Bitcoin::FullDecrement8 => [
+                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,
+            ],
+            Bitcoin::FullIncrement16 => [
+                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,
+            ],
+            Bitcoin::FullIncrement32 => [
+                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,
+            ],
+            Bitcoin::FullIncrement64 => [
+                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,
+            ],
+            Bitcoin::FullIncrement8 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift16_1 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift16_2 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift16_4 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift16_8 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift32_1 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift32_16 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift32_2 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift32_4 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift32_8 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift64_1 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift64_16 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift64_2 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift64_32 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift64_4 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift64_8 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift8_1 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift8_2 => [
+                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,
+            ],
+            Bitcoin::FullLeftShift8_4 => [
+                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,
+            ],
+            Bitcoin::FullMultiply16 => [
+                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,
+            ],
+            Bitcoin::FullMultiply32 => [
+                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,
+            ],
+            Bitcoin::FullMultiply64 => [
+                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,
+            ],
+            Bitcoin::FullMultiply8 => [
+                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,
+            ],
+            Bitcoin::FullRightShift16_1 => [
+                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,
+            ],
+            Bitcoin::FullRightShift16_2 => [
+                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,
+            ],
+            Bitcoin::FullRightShift16_4 => [
+                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,
+            ],
+            Bitcoin::FullRightShift16_8 => [
+                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,
+            ],
+            Bitcoin::FullRightShift32_1 => [
+                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,
+            ],
+            Bitcoin::FullRightShift32_16 => [
+                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,
+            ],
+            Bitcoin::FullRightShift32_2 => [
+                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,
+            ],
+            Bitcoin::FullRightShift32_4 => [
+                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,
+            ],
+            Bitcoin::FullRightShift32_8 => [
+                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,
+            ],
+            Bitcoin::FullRightShift64_1 => [
+                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,
+            ],
+            Bitcoin::FullRightShift64_16 => [
+                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,
+            ],
+            Bitcoin::FullRightShift64_2 => [
+                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,
+            ],
+            Bitcoin::FullRightShift64_32 => [
+                0x35, 0x6f, 0x7d, 0xd4, 0x6b, 0xa3, 0x3f, 0x84, 0xb0, 0x66, 0x72, 0xfd, 0xe9, 0xa2,
+                0x97, 0x2e, 0x80, 0xf3, 0xea, 0x96, 0x5a, 0xe8, 0xbc, 0x0b, 0xff, 0x67, 0xaa, 0x2f,
+                0x69, 0xf1, 0x0b, 0x56,
+            ],
+            Bitcoin::FullRightShift64_4 => [
+                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,
+            ],
+            Bitcoin::FullRightShift64_8 => [
+                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,
+            ],
+            Bitcoin::FullRightShift8_1 => [
+                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,
+            ],
+            Bitcoin::FullRightShift8_2 => [
+                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,
+            ],
+            Bitcoin::FullRightShift8_4 => [
+                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,
+            ],
+            Bitcoin::FullSubtract16 => [
+                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,
+            ],
+            Bitcoin::FullSubtract32 => [
+                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,
+            ],
+            Bitcoin::FullSubtract64 => [
+                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,
+            ],
+            Bitcoin::FullSubtract8 => [
+                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,
+            ],
+            Bitcoin::GeIsOnCurve => [
+                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,
+            ],
+            Bitcoin::GeNegate => [
+                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,
+            ],
+            Bitcoin::GejAdd => [
+                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,
+            ],
+            Bitcoin::GejDouble => [
+                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,
+            ],
+            Bitcoin::GejEquiv => [
+                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,
+            ],
+            Bitcoin::GejGeAdd => [
+                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,
+            ],
+            Bitcoin::GejGeAddEx => [
+                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,
+            ],
+            Bitcoin::GejGeEquiv => [
+                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,
+            ],
+            Bitcoin::GejInfinity => [
+                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,
+            ],
+            Bitcoin::GejIsInfinity => [
+                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,
+            ],
+            Bitcoin::GejIsOnCurve => [
+                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,
+            ],
+            Bitcoin::GejNegate => [
+                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,
+            ],
+            Bitcoin::GejNormalize => [
+                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,
+            ],
+            Bitcoin::GejRescale => [
+                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,
+            ],
+            Bitcoin::GejXEquiv => [
+                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,
+            ],
+            Bitcoin::GejYIsOdd => [
+                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,
+            ],
+            Bitcoin::Generate => [
+                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,
+            ],
+            Bitcoin::HashToCurve => [
+                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,
+            ],
+            Bitcoin::High1 => [
+                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,
+            ],
+            Bitcoin::High16 => [
+                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,
+            ],
+            Bitcoin::High32 => [
+                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,
+            ],
+            Bitcoin::High64 => [
+                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,
+            ],
+            Bitcoin::High8 => [
+                0xcb, 0xd7, 0x8d, 0x50, 0xaf, 0x77, 0x99, 0x85, 0x5a, 0xdc, 0x49, 0x03, 0xdb, 0xbe,
+                0xfc, 0x13, 0x45, 0xd5, 0x14, 0x84, 0xf0, 0x3d, 0x3c, 0x75, 0x5c, 0xaa, 0xa5, 0xca,
+                0xa9, 0x7d, 0x4a, 0x14,
+            ],
+            Bitcoin::Increment16 => [
+                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,
+            ],
+            Bitcoin::Increment32 => [
+                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,
+            ],
+            Bitcoin::Increment64 => [
+                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,
+            ],
+            Bitcoin::Increment8 => [
+                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,
+            ],
+            Bitcoin::InputAnnexHash => [
+                0x94, 0x5b, 0x14, 0x7e, 0x5f, 0x0e, 0xdb, 0x83, 0x2d, 0x62, 0x34, 0x8c, 0xae, 0xea,
+                0xc2, 0x24, 0x56, 0xee, 0xe9, 0x44, 0x65, 0x37, 0x6d, 0xbf, 0x59, 0x6b, 0x9d, 0x62,
+                0x98, 0x5b, 0x01, 0xb6,
+            ],
+            Bitcoin::InputAnnexesHash => [
+                0x89, 0xb6, 0x02, 0x70, 0x44, 0x14, 0x1f, 0x20, 0x65, 0xb6, 0xf2, 0x36, 0xcf, 0xcc,
+                0x13, 0xb9, 0x68, 0x48, 0x5e, 0x00, 0x74, 0x6b, 0x78, 0x59, 0x28, 0x69, 0x03, 0xc6,
+                0x8c, 0x7f, 0x88, 0x0d,
+            ],
+            Bitcoin::InputHash => [
+                0x3a, 0xd2, 0x22, 0x31, 0xd6, 0xb9, 0xdf, 0xf6, 0xa0, 0xb4, 0xdb, 0xcf, 0xf0, 0x44,
+                0xe1, 0x1c, 0x08, 0x2e, 0x04, 0x68, 0x4e, 0x73, 0xce, 0x95, 0xc2, 0x05, 0xe0, 0xc4,
+                0x49, 0x6e, 0x5e, 0xca,
+            ],
+            Bitcoin::InputOutpointsHash => [
+                0x17, 0x59, 0xc6, 0xf4, 0x70, 0xb9, 0xab, 0xa6, 0x2a, 0x31, 0x79, 0x1e, 0xa0, 0x10,
+                0x56, 0xe3, 0x60, 0x8b, 0xdf, 0x22, 0xf5, 0xdd, 0x43, 0xbf, 0x7d, 0xb0, 0x0e, 0xa5,
+                0x82, 0x3f, 0x7c, 0xce,
+            ],
+            Bitcoin::InputPrevOutpoint => [
+                0x5d, 0x17, 0x12, 0x42, 0x09, 0xee, 0x05, 0x21, 0x24, 0xe5, 0x52, 0x38, 0xe0, 0xb6,
+                0xa6, 0xfe, 0x85, 0xa4, 0x86, 0x88, 0xc1, 0xe1, 0x5e, 0x61, 0x81, 0xde, 0x94, 0xf7,
+                0x8d, 0xb0, 0x40, 0x18,
+            ],
+            Bitcoin::InputScriptHash => [
+                0x05, 0x62, 0x41, 0x2f, 0x02, 0x1d, 0xa4, 0x81, 0x9b, 0x01, 0x9c, 0x8c, 0xd8, 0x87,
+                0xd5, 0x30, 0x49, 0x2b, 0x9f, 0x94, 0x2c, 0x4e, 0xbf, 0x21, 0xae, 0x39, 0xed, 0x32,
+                0x33, 0x0d, 0x7c, 0xfe,
+            ],
+            Bitcoin::InputScriptSigHash => [
+                0x1c, 0x7e, 0xfb, 0x37, 0xcb, 0xc4, 0xb9, 0x96, 0xd9, 0xb8, 0xc6, 0x17, 0x08, 0xe6,
+                0x65, 0x73, 0xce, 0x87, 0xc1, 0xf0, 0xaa, 0x05, 0x22, 0xd0, 0x65, 0xba, 0x90, 0x25,
+                0x05, 0x6e, 0x3f, 0x80,
+            ],
+            Bitcoin::InputScriptSigsHash => [
+                0xe7, 0x29, 0xc5, 0xf5, 0x8a, 0x93, 0x89, 0x08, 0x1a, 0x5c, 0xa8, 0x45, 0xf7, 0x6c,
+                0xb9, 0x80, 0xf0, 0x85, 0x99, 0xce, 0xb3, 0xc7, 0xd7, 0xea, 0xe1, 0x14, 0x5b, 0x53,
+                0xa6, 0x0a, 0xe3, 0xd5,
+            ],
+            Bitcoin::InputScriptsHash => [
+                0xf1, 0x77, 0x67, 0x1d, 0x60, 0x96, 0x0e, 0x46, 0x3a, 0x9a, 0x8f, 0x7e, 0x1f, 0x52,
+                0x13, 0xaa, 0xba, 0x91, 0x22, 0xd2, 0xdb, 0x75, 0xfe, 0x91, 0xf8, 0xf1, 0xcf, 0x91,
+                0xbe, 0x00, 0x19, 0x07,
+            ],
+            Bitcoin::InputSequence => [
+                0x5d, 0xd1, 0x7f, 0xe1, 0x55, 0x0f, 0x48, 0xf7, 0xba, 0xed, 0x4d, 0x06, 0x80, 0x08,
+                0xd4, 0xa1, 0xff, 0x98, 0xcb, 0xeb, 0xe2, 0x54, 0x1c, 0x5d, 0xc7, 0x7a, 0xc5, 0x3a,
+                0xd8, 0x3f, 0xa7, 0x79,
+            ],
+            Bitcoin::InputSequencesHash => [
+                0x55, 0x97, 0x3d, 0x64, 0x43, 0x45, 0x74, 0x72, 0x81, 0x37, 0x73, 0x64, 0xba, 0xd2,
+                0xa8, 0x0b, 0x75, 0x8f, 0x45, 0x66, 0x60, 0xc1, 0x8d, 0xe5, 0xc0, 0x1a, 0x38, 0x82,
+                0x07, 0x1d, 0x50, 0xe8,
+            ],
+            Bitcoin::InputUtxoHash => [
+                0x93, 0x1e, 0x4e, 0x95, 0xe0, 0xa6, 0x47, 0x60, 0x27, 0x6e, 0x91, 0xb5, 0xdc, 0x74,
+                0x67, 0x80, 0xd0, 0x69, 0x7d, 0x0a, 0xf5, 0xaa, 0xf5, 0xbb, 0xc8, 0x1d, 0xbe, 0xb3,
+                0x98, 0x59, 0x6a, 0xbb,
+            ],
+            Bitcoin::InputUtxosHash => [
+                0xd6, 0xf9, 0x0c, 0xd1, 0x04, 0xe1, 0xa5, 0xc6, 0x1a, 0x4b, 0x50, 0x00, 0xad, 0x9a,
+                0xba, 0x8d, 0x43, 0x00, 0x4b, 0xf9, 0x43, 0xdf, 0x32, 0x5f, 0xa6, 0x36, 0xd1, 0xa2,
+                0x2b, 0xec, 0xa0, 0xcb,
+            ],
+            Bitcoin::InputValue => [
+                0x7d, 0x3c, 0x3f, 0x95, 0x5b, 0x2c, 0xf0, 0xd0, 0xd1, 0x28, 0x0a, 0x1b, 0xb1, 0x20,
+                0x46, 0x92, 0x92, 0xd1, 0x32, 0x9c, 0x83, 0xa9, 0xc2, 0xff, 0x7e, 0x7e, 0x1e, 0xb3,
+                0xf6, 0x97, 0x83, 0xa3,
+            ],
+            Bitcoin::InputValuesHash => [
+                0x29, 0x83, 0x9e, 0xad, 0x0e, 0xb0, 0x3f, 0xe4, 0x65, 0x42, 0xe3, 0x6d, 0x71, 0xe9,
+                0xe6, 0xaf, 0xdf, 0x96, 0x93, 0x01, 0x53, 0x3d, 0x74, 0xee, 0x09, 0x9b, 0x12, 0x66,
+                0xa2, 0x50, 0x55, 0x2c,
+            ],
+            Bitcoin::InputsHash => [
+                0xab, 0xbf, 0xe1, 0xc7, 0xd1, 0x15, 0xc4, 0x19, 0x1f, 0x50, 0x48, 0x39, 0xf9, 0x8c,
+                0x3f, 0x20, 0x42, 0x2b, 0x84, 0xe7, 0xfa, 0x14, 0xda, 0x14, 0x02, 0x89, 0x6c, 0x4d,
+                0x98, 0xbf, 0xa8, 0xd8,
+            ],
+            Bitcoin::InternalKey => [
+                0x37, 0x48, 0x36, 0x99, 0x28, 0x10, 0x02, 0x2f, 0x88, 0xe0, 0x14, 0x5b, 0xca, 0xd7,
+                0x7f, 0x4a, 0x84, 0x91, 0xfa, 0x80, 0x83, 0xcb, 0x51, 0xc3, 0x01, 0xfc, 0xf7, 0xa1,
+                0x34, 0x78, 0xc2, 0xcc,
+            ],
+            Bitcoin::IsOne16 => [
+                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,
+            ],
+            Bitcoin::IsOne32 => [
+                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,
+            ],
+            Bitcoin::IsOne64 => [
+                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,
+            ],
+            Bitcoin::IsOne8 => [
+                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,
+            ],
+            Bitcoin::IsZero16 => [
+                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,
+            ],
+            Bitcoin::IsZero32 => [
+                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,
+            ],
+            Bitcoin::IsZero64 => [
+                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,
+            ],
+            Bitcoin::IsZero8 => [
+                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,
+            ],
+            Bitcoin::Le16 => [
+                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,
+            ],
+            Bitcoin::Le32 => [
+                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,
+            ],
+            Bitcoin::Le64 => [
+                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,
+            ],
+            Bitcoin::Le8 => [
+                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,
+            ],
+            Bitcoin::LeftExtend16_32 => [
+                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,
+            ],
+            Bitcoin::LeftExtend16_64 => [
+                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,
+            ],
+            Bitcoin::LeftExtend1_16 => [
+                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,
+            ],
+            Bitcoin::LeftExtend1_32 => [
+                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,
+            ],
+            Bitcoin::LeftExtend1_64 => [
+                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,
+            ],
+            Bitcoin::LeftExtend1_8 => [
+                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,
+            ],
+            Bitcoin::LeftExtend32_64 => [
+                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,
+            ],
+            Bitcoin::LeftExtend8_16 => [
+                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,
+            ],
+            Bitcoin::LeftExtend8_32 => [
+                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,
+            ],
+            Bitcoin::LeftExtend8_64 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh16_32 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh16_64 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh1_16 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh1_32 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh1_64 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh1_8 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh32_64 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh8_16 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh8_32 => [
+                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,
+            ],
+            Bitcoin::LeftPadHigh8_64 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow16_32 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow16_64 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow1_16 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow1_32 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow1_64 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow1_8 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow32_64 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow8_16 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow8_32 => [
+                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,
+            ],
+            Bitcoin::LeftPadLow8_64 => [
+                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,
+            ],
+            Bitcoin::LeftRotate16 => [
+                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,
+            ],
+            Bitcoin::LeftRotate32 => [
+                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,
+            ],
+            Bitcoin::LeftRotate64 => [
+                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,
+            ],
+            Bitcoin::LeftRotate8 => [
+                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,
+            ],
+            Bitcoin::LeftShift16 => [
+                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,
+            ],
+            Bitcoin::LeftShift32 => [
+                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,
+            ],
+            Bitcoin::LeftShift64 => [
+                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,
+            ],
+            Bitcoin::LeftShift8 => [
+                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,
+            ],
+            Bitcoin::LeftShiftWith16 => [
+                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,
+            ],
+            Bitcoin::LeftShiftWith32 => [
+                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,
+            ],
+            Bitcoin::LeftShiftWith64 => [
+                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,
+            ],
+            Bitcoin::LeftShiftWith8 => [
+                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,
+            ],
+            Bitcoin::Leftmost16_1 => [
+                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,
+            ],
+            Bitcoin::Leftmost16_2 => [
+                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,
+            ],
+            Bitcoin::Leftmost16_4 => [
+                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,
+            ],
+            Bitcoin::Leftmost16_8 => [
+                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,
+            ],
+            Bitcoin::Leftmost32_1 => [
+                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,
+            ],
+            Bitcoin::Leftmost32_16 => [
+                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,
+            ],
+            Bitcoin::Leftmost32_2 => [
+                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,
+            ],
+            Bitcoin::Leftmost32_4 => [
+                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,
+            ],
+            Bitcoin::Leftmost32_8 => [
+                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,
+            ],
+            Bitcoin::Leftmost64_1 => [
+                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,
+            ],
+            Bitcoin::Leftmost64_16 => [
+                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,
+            ],
+            Bitcoin::Leftmost64_2 => [
+                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,
+            ],
+            Bitcoin::Leftmost64_32 => [
+                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,
+            ],
+            Bitcoin::Leftmost64_4 => [
+                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,
+            ],
+            Bitcoin::Leftmost64_8 => [
+                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,
+            ],
+            Bitcoin::Leftmost8_1 => [
+                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,
+            ],
+            Bitcoin::Leftmost8_2 => [
+                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,
+            ],
+            Bitcoin::Leftmost8_4 => [
+                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,
+            ],
+            Bitcoin::LinearCombination1 => [
+                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,
+            ],
+            Bitcoin::LinearVerify1 => [
+                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,
+            ],
+            Bitcoin::LockTime => [
+                0x9a, 0xe0, 0xac, 0xc3, 0x7b, 0xc2, 0x04, 0x47, 0x79, 0xb0, 0x7c, 0x3d, 0x46, 0x02,
+                0xa5, 0xfd, 0xe8, 0xbc, 0x33, 0xf8, 0x79, 0xf6, 0x6b, 0x73, 0x9b, 0x10, 0xf0, 0x1a,
+                0xeb, 0x11, 0x54, 0xec,
+            ],
+            Bitcoin::Low1 => [
+                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,
+            ],
+            Bitcoin::Low16 => [
+                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,
+            ],
+            Bitcoin::Low32 => [
+                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,
+            ],
+            Bitcoin::Low64 => [
+                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,
+            ],
+            Bitcoin::Low8 => [
+                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,
+            ],
+            Bitcoin::Lt16 => [
+                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,
+            ],
+            Bitcoin::Lt32 => [
+                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,
+            ],
+            Bitcoin::Lt64 => [
+                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,
+            ],
+            Bitcoin::Lt8 => [
+                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,
+            ],
+            Bitcoin::Maj1 => [
+                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,
+            ],
+            Bitcoin::Maj16 => [
+                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,
+            ],
+            Bitcoin::Maj32 => [
+                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,
+            ],
+            Bitcoin::Maj64 => [
+                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,
+            ],
+            Bitcoin::Maj8 => [
+                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,
+            ],
+            Bitcoin::Max16 => [
+                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,
+            ],
+            Bitcoin::Max32 => [
+                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,
+            ],
+            Bitcoin::Max64 => [
+                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,
+            ],
+            Bitcoin::Max8 => [
+                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,
+            ],
+            Bitcoin::Median16 => [
+                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,
+            ],
+            Bitcoin::Median32 => [
+                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,
+            ],
+            Bitcoin::Median64 => [
+                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,
+            ],
+            Bitcoin::Median8 => [
+                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,
+            ],
+            Bitcoin::Min16 => [
+                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,
+            ],
+            Bitcoin::Min32 => [
+                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,
+            ],
+            Bitcoin::Min64 => [
+                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,
+            ],
+            Bitcoin::Min8 => [
+                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,
+            ],
+            Bitcoin::Modulo16 => [
+                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,
+            ],
+            Bitcoin::Modulo32 => [
+                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,
+            ],
+            Bitcoin::Modulo64 => [
+                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,
+            ],
+            Bitcoin::Modulo8 => [
+                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,
+            ],
+            Bitcoin::Multiply16 => [
+                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,
+            ],
+            Bitcoin::Multiply32 => [
+                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,
+            ],
+            Bitcoin::Multiply64 => [
+                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,
+            ],
+            Bitcoin::Multiply8 => [
+                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,
+            ],
+            Bitcoin::Negate16 => [
+                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,
+            ],
+            Bitcoin::Negate32 => [
+                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,
+            ],
+            Bitcoin::Negate64 => [
+                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,
+            ],
+            Bitcoin::Negate8 => [
+                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,
+            ],
+            Bitcoin::NumInputs => [
+                0x5c, 0x5a, 0xc4, 0xff, 0x6d, 0xa5, 0x6c, 0xb3, 0x72, 0xb2, 0x32, 0x66, 0x6e, 0x83,
+                0x34, 0xb9, 0xe2, 0xcf, 0xb0, 0xdc, 0xb4, 0x18, 0xf1, 0x61, 0xbf, 0xf1, 0x49, 0xe8,
+                0x4e, 0xc9, 0x2c, 0x3e,
+            ],
+            Bitcoin::NumOutputs => [
+                0x98, 0xa1, 0xcc, 0xa7, 0x05, 0xdf, 0xcf, 0xaf, 0xd3, 0xa6, 0x9e, 0x9a, 0xdc, 0x05,
+                0xba, 0x47, 0xe1, 0xfe, 0xfa, 0x6a, 0x29, 0xf3, 0x42, 0x86, 0x20, 0x48, 0xe4, 0x96,
+                0x86, 0x48, 0xc3, 0xd7,
+            ],
+            Bitcoin::One16 => [
+                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,
+            ],
+            Bitcoin::One32 => [
+                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,
+            ],
+            Bitcoin::One64 => [
+                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,
+            ],
+            Bitcoin::One8 => [
+                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,
+            ],
+            Bitcoin::Or1 => [
+                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,
+            ],
+            Bitcoin::Or16 => [
+                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,
+            ],
+            Bitcoin::Or32 => [
+                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,
+            ],
+            Bitcoin::Or64 => [
+                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,
+            ],
+            Bitcoin::Or8 => [
+                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,
+            ],
+            Bitcoin::OutpointHash => [
+                0x3a, 0x1a, 0xe9, 0x0e, 0x16, 0x7f, 0xb4, 0x0d, 0x6e, 0x13, 0xb4, 0x51, 0xad, 0x67,
+                0x41, 0x0d, 0x8d, 0xd9, 0x91, 0xc8, 0x7d, 0x6a, 0x4a, 0x59, 0xcc, 0x76, 0xc6, 0x3f,
+                0x3b, 0x9e, 0x5e, 0x56,
+            ],
+            Bitcoin::OutputHash => [
+                0x91, 0x21, 0x1f, 0xc6, 0x01, 0x1a, 0x64, 0x93, 0x00, 0xc6, 0xbe, 0xe9, 0x4f, 0xdd,
+                0x48, 0xa9, 0x7f, 0xa2, 0xa9, 0xb6, 0xf2, 0x84, 0xbe, 0x01, 0x5d, 0x46, 0x2d, 0x17,
+                0xde, 0x66, 0x4a, 0xc3,
+            ],
+            Bitcoin::OutputScriptHash => [
+                0xbd, 0xfd, 0xb2, 0x31, 0xf4, 0xf1, 0xa6, 0x2c, 0x9d, 0x7b, 0x03, 0x93, 0x1e, 0x7f,
+                0x19, 0xa4, 0x54, 0x6a, 0xf2, 0x34, 0x75, 0x4c, 0xbf, 0x70, 0x05, 0x9f, 0xdd, 0x42,
+                0xbb, 0xbc, 0x41, 0x26,
+            ],
+            Bitcoin::OutputScriptsHash => [
+                0xff, 0x20, 0xbc, 0x43, 0x65, 0xe7, 0x17, 0x07, 0x57, 0x1c, 0x6e, 0x17, 0x38, 0xe1,
+                0xed, 0x32, 0x6f, 0x7c, 0x35, 0x1d, 0xe1, 0x30, 0x22, 0xae, 0xa3, 0xd6, 0x40, 0x6b,
+                0x8a, 0xee, 0x8e, 0x3b,
+            ],
+            Bitcoin::OutputValue => [
+                0x93, 0x36, 0x43, 0xb6, 0xc5, 0xa6, 0x22, 0x0a, 0xbb, 0xca, 0x6f, 0x35, 0x09, 0xfe,
+                0xff, 0x6d, 0x13, 0xef, 0xa6, 0xc9, 0xfa, 0xe9, 0x59, 0x24, 0x57, 0x53, 0x64, 0xf2,
+                0xb1, 0x64, 0xd2, 0xbc,
+            ],
+            Bitcoin::OutputValuesHash => [
+                0x22, 0x89, 0x93, 0x79, 0x00, 0x57, 0x06, 0x6f, 0x20, 0x16, 0x97, 0x1d, 0xf5, 0x5e,
+                0x6f, 0x67, 0xd2, 0x52, 0xef, 0xb6, 0xda, 0xab, 0xd0, 0xfc, 0x56, 0x6a, 0x8d, 0x21,
+                0x56, 0xef, 0xbb, 0xfc,
+            ],
+            Bitcoin::OutputsHash => [
+                0xf2, 0xeb, 0x6d, 0x0f, 0x01, 0x8e, 0x6f, 0x15, 0xe3, 0x5b, 0xaa, 0x82, 0xe5, 0x7e,
+                0x14, 0xfe, 0x34, 0x37, 0x96, 0xf2, 0x19, 0x68, 0x26, 0xbe, 0xd7, 0xc7, 0x87, 0x55,
+                0x98, 0xd6, 0x64, 0x1d,
+            ],
+            Bitcoin::ParseLock => [
+                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,
+            ],
+            Bitcoin::ParseSequence => [
+                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,
+            ],
+            Bitcoin::PointVerify1 => [
+                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,
+            ],
+            Bitcoin::RightExtend16_32 => [
+                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,
+            ],
+            Bitcoin::RightExtend16_64 => [
+                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,
+            ],
+            Bitcoin::RightExtend32_64 => [
+                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,
+            ],
+            Bitcoin::RightExtend8_16 => [
+                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,
+            ],
+            Bitcoin::RightExtend8_32 => [
+                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,
+            ],
+            Bitcoin::RightExtend8_64 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh16_32 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh16_64 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh1_16 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh1_32 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh1_64 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh1_8 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh32_64 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh8_16 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh8_32 => [
+                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,
+            ],
+            Bitcoin::RightPadHigh8_64 => [
+                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,
+            ],
+            Bitcoin::RightPadLow16_32 => [
+                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,
+            ],
+            Bitcoin::RightPadLow16_64 => [
+                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,
+            ],
+            Bitcoin::RightPadLow1_16 => [
+                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,
+            ],
+            Bitcoin::RightPadLow1_32 => [
+                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,
+            ],
+            Bitcoin::RightPadLow1_64 => [
+                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,
+            ],
+            Bitcoin::RightPadLow1_8 => [
+                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,
+            ],
+            Bitcoin::RightPadLow32_64 => [
+                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,
+            ],
+            Bitcoin::RightPadLow8_16 => [
+                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,
+            ],
+            Bitcoin::RightPadLow8_32 => [
+                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,
+            ],
+            Bitcoin::RightPadLow8_64 => [
+                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,
+            ],
+            Bitcoin::RightRotate16 => [
+                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,
+            ],
+            Bitcoin::RightRotate32 => [
+                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,
+            ],
+            Bitcoin::RightRotate64 => [
+                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,
+            ],
+            Bitcoin::RightRotate8 => [
+                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,
+            ],
+            Bitcoin::RightShift16 => [
+                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,
+            ],
+            Bitcoin::RightShift32 => [
+                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,
+            ],
+            Bitcoin::RightShift64 => [
+                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,
+            ],
+            Bitcoin::RightShift8 => [
+                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,
+            ],
+            Bitcoin::RightShiftWith16 => [
+                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,
+            ],
+            Bitcoin::RightShiftWith32 => [
+                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,
+            ],
+            Bitcoin::RightShiftWith64 => [
+                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,
+            ],
+            Bitcoin::RightShiftWith8 => [
+                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,
+            ],
+            Bitcoin::Rightmost16_1 => [
+                0x3f, 0x3c, 0x43, 0x46, 0x87, 0x17, 0x42, 0x26, 0x5e, 0x87, 0xf0, 0x01, 0xb4, 0x6d,
+                0xe7, 0xd1, 0x98, 0x75, 0x1b, 0x34, 0xfa, 0xa1, 0x80, 0x18, 0xde, 0x60, 0xc8, 0x46,
+                0x8d, 0x9b, 0x98, 0xa4,
+            ],
+            Bitcoin::Rightmost16_2 => [
+                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,
+            ],
+            Bitcoin::Rightmost16_4 => [
+                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,
+            ],
+            Bitcoin::Rightmost16_8 => [
+                0xee, 0x76, 0x9c, 0x1c, 0xc8, 0xa3, 0xfd, 0xd1, 0x83, 0x8f, 0xc9, 0xf0, 0x49, 0x0c,
+                0xe7, 0x03, 0x93, 0xfd, 0x91, 0xba, 0x3c, 0xbd, 0x4a, 0xbd, 0x08, 0x64, 0x9f, 0xb9,
+                0xc4, 0x43, 0x11, 0xbd,
+            ],
+            Bitcoin::Rightmost32_1 => [
+                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,
+            ],
+            Bitcoin::Rightmost32_16 => [
+                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,
+            ],
+            Bitcoin::Rightmost32_2 => [
+                0x00, 0xb8, 0x81, 0x5a, 0xd7, 0x42, 0x3d, 0xd5, 0x8c, 0xb9, 0x8b, 0xe8, 0x2c, 0xad,
+                0x26, 0x67, 0x5c, 0x3b, 0xf5, 0x4a, 0x0b, 0xed, 0xba, 0xde, 0x34, 0x64, 0xb4, 0xfe,
+                0x5a, 0x4e, 0x8c, 0xe6,
+            ],
+            Bitcoin::Rightmost32_4 => [
+                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,
+            ],
+            Bitcoin::Rightmost32_8 => [
+                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,
+            ],
+            Bitcoin::Rightmost64_1 => [
+                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,
+            ],
+            Bitcoin::Rightmost64_16 => [
+                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,
+            ],
+            Bitcoin::Rightmost64_2 => [
+                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,
+            ],
+            Bitcoin::Rightmost64_32 => [
+                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,
+            ],
+            Bitcoin::Rightmost64_4 => [
+                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,
+            ],
+            Bitcoin::Rightmost64_8 => [
+                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,
+            ],
+            Bitcoin::Rightmost8_1 => [
+                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,
+            ],
+            Bitcoin::Rightmost8_2 => [
+                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,
+            ],
+            Bitcoin::Rightmost8_4 => [
+                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,
+            ],
+            Bitcoin::ScalarAdd => [
+                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,
+            ],
+            Bitcoin::ScalarInvert => [
+                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,
+            ],
+            Bitcoin::ScalarIsZero => [
+                0xf7, 0x5e, 0xda, 0x06, 0xce, 0x6a, 0xf0, 0x9f, 0xae, 0x37, 0xdb, 0x4e, 0x62, 0x25,
+                0xe6, 0xa8, 0xac, 0x86, 0xa2, 0x36, 0x37, 0x62, 0x7d, 0x62, 0x64, 0x09, 0x19, 0x0f,
+                0xf3, 0xb3, 0x9d, 0x90,
+            ],
+            Bitcoin::ScalarMultiply => [
+                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,
+            ],
+            Bitcoin::ScalarMultiplyLambda => [
+                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,
+            ],
+            Bitcoin::ScalarNegate => [
+                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,
+            ],
+            Bitcoin::ScalarNormalize => [
+                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,
+            ],
+            Bitcoin::ScalarSquare => [
+                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,
+            ],
+            Bitcoin::Scale => [
+                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,
+            ],
+            Bitcoin::ScriptCMR => [
+                0xa8, 0xa4, 0xa6, 0x22, 0x10, 0xb5, 0xe4, 0x95, 0x0e, 0x25, 0x34, 0x24, 0x7c, 0x74,
+                0x11, 0xd1, 0xc8, 0xff, 0x22, 0x86, 0x5b, 0x54, 0x56, 0xbb, 0xb2, 0x16, 0x38, 0xe9,
+                0x14, 0xf5, 0xe5, 0x28,
+            ],
+            Bitcoin::Sha256Block => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add1 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add128 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add16 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add2 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add256 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add32 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add4 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add512 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add64 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Add8 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8AddBuffer511 => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Finalize => [
+                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,
+            ],
+            Bitcoin::Sha256Ctx8Init => [
+                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,
+            ],
+            Bitcoin::Sha256Iv => [
+                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,
+            ],
+            Bitcoin::SigAllHash => [
+                0x09, 0x78, 0xb9, 0xe5, 0x0b, 0x9e, 0x8e, 0x09, 0x8b, 0x27, 0xf2, 0xb8, 0xb5, 0x9d,
+                0xe5, 0x4f, 0x62, 0xba, 0x7c, 0x13, 0x33, 0xdf, 0x3b, 0xed, 0x22, 0x1e, 0x26, 0x62,
+                0x68, 0x05, 0xbc, 0x55,
+            ],
+            Bitcoin::Some1 => [
+                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,
+            ],
+            Bitcoin::Some16 => [
+                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,
+            ],
+            Bitcoin::Some32 => [
+                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,
+            ],
+            Bitcoin::Some64 => [
+                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,
+            ],
+            Bitcoin::Some8 => [
+                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,
+            ],
+            Bitcoin::Subtract16 => [
+                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,
+            ],
+            Bitcoin::Subtract32 => [
+                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,
+            ],
+            Bitcoin::Subtract64 => [
+                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,
+            ],
+            Bitcoin::Subtract8 => [
+                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,
+            ],
+            Bitcoin::Swu => [
+                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,
+            ],
+            Bitcoin::TapEnvHash => [
+                0x19, 0xd9, 0x94, 0x4c, 0x4d, 0x45, 0x7c, 0x70, 0xba, 0xbc, 0x45, 0xcc, 0xcb, 0xd5,
+                0x73, 0xb3, 0x9a, 0x51, 0xd0, 0xc9, 0x91, 0x15, 0xb4, 0x12, 0x78, 0x3b, 0x49, 0x00,
+                0x82, 0xfd, 0x0e, 0x58,
+            ],
+            Bitcoin::TapdataInit => [
+                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,
+            ],
+            Bitcoin::TapleafHash => [
+                0x0c, 0x07, 0x16, 0xfe, 0x5d, 0x97, 0x8e, 0xa8, 0xe0, 0xc7, 0x5a, 0xdc, 0x82, 0x10,
+                0xd6, 0x60, 0x06, 0x2e, 0x3d, 0xa0, 0x6f, 0x1a, 0x66, 0x61, 0x31, 0x79, 0x27, 0xd3,
+                0xb8, 0x4b, 0x50, 0x73,
+            ],
+            Bitcoin::TapleafVersion => [
+                0xe2, 0xec, 0xb1, 0xcb, 0x0e, 0xd4, 0xed, 0x93, 0x48, 0x35, 0x45, 0xfd, 0x8a, 0x62,
+                0xf8, 0xaa, 0x10, 0x17, 0x53, 0x49, 0xff, 0xcc, 0x5a, 0xd3, 0xde, 0x7f, 0x34, 0x84,
+                0xea, 0x1f, 0x10, 0x3f,
+            ],
+            Bitcoin::Tappath => [
+                0x99, 0xe8, 0x21, 0x1e, 0x8c, 0x1b, 0xe6, 0xd9, 0xca, 0x98, 0xd3, 0xd4, 0x3d, 0x91,
+                0x42, 0x56, 0x7e, 0x06, 0xa8, 0x40, 0x22, 0x39, 0x33, 0x03, 0xfa, 0xb0, 0xb5, 0x7d,
+                0x39, 0x40, 0x74, 0xe8,
+            ],
+            Bitcoin::TappathHash => [
+                0x02, 0x11, 0x54, 0x6d, 0x07, 0x78, 0xe7, 0x87, 0x14, 0x1e, 0xce, 0x65, 0xdf, 0x6c,
+                0xd1, 0xdb, 0x31, 0x38, 0x8f, 0xc1, 0x42, 0x19, 0x68, 0xc8, 0xcf, 0xd8, 0xd7, 0x59,
+                0x26, 0xdb, 0x47, 0xb3,
+            ],
+            Bitcoin::TotalInputValue => [
+                0x81, 0x28, 0x7a, 0x15, 0x89, 0xdd, 0xc2, 0x17, 0x99, 0x26, 0xb7, 0x06, 0x5e, 0x9b,
+                0x26, 0x77, 0xb7, 0xfb, 0x09, 0x9b, 0x95, 0xf9, 0x47, 0xa7, 0xdd, 0x59, 0x0c, 0xdd,
+                0x4c, 0xcf, 0x4a, 0x56,
+            ],
+            Bitcoin::TotalOutputValue => [
+                0xba, 0x03, 0x2f, 0x3e, 0x62, 0xf8, 0xfc, 0xb0, 0x4b, 0x04, 0x29, 0xa2, 0x53, 0xb5,
+                0xec, 0x57, 0xe4, 0xc8, 0x7a, 0xe2, 0xe9, 0x51, 0xe1, 0x45, 0xd7, 0x65, 0x0e, 0x7f,
+                0x0c, 0x63, 0xe5, 0x55,
+            ],
+            Bitcoin::TransactionId => [
+                0x5c, 0x49, 0xea, 0x98, 0x6b, 0x32, 0x8b, 0xe2, 0xa4, 0xe0, 0xb3, 0x15, 0xb6, 0xb3,
+                0xfe, 0xf2, 0x3c, 0x1f, 0x68, 0x56, 0xbb, 0xc3, 0xb0, 0x56, 0xc9, 0x9c, 0xf5, 0x9f,
+                0xbd, 0x54, 0x6e, 0x65,
+            ],
+            Bitcoin::TxHash => [
+                0x54, 0xe5, 0x3c, 0x99, 0x93, 0xab, 0xd5, 0x5d, 0x1f, 0x85, 0x23, 0xd2, 0xbb, 0x21,
+                0x7b, 0x32, 0xe6, 0xfe, 0x86, 0x1f, 0x84, 0xc9, 0x86, 0xb7, 0xee, 0x8b, 0xdc, 0x68,
+                0x81, 0x06, 0x87, 0x4a,
+            ],
+            Bitcoin::TxIsFinal => [
+                0x7b, 0x0e, 0x4f, 0x4c, 0xa8, 0xe5, 0xaf, 0x61, 0xa1, 0xd3, 0x45, 0x4e, 0x11, 0xef,
+                0x9a, 0xb6, 0x88, 0x70, 0x61, 0x21, 0x1c, 0x00, 0x90, 0xeb, 0xa9, 0x55, 0x3d, 0xa2,
+                0xe4, 0x5d, 0x84, 0x73,
+            ],
+            Bitcoin::TxLockDistance => [
+                0xb6, 0xfb, 0xaa, 0xc2, 0x10, 0xa3, 0x06, 0xbe, 0x8b, 0x58, 0xd0, 0xd7, 0xb1, 0x56,
+                0x3f, 0x62, 0x23, 0x36, 0xd2, 0xae, 0xb5, 0x6c, 0x39, 0x3d, 0x27, 0x64, 0x45, 0xa9,
+                0xa2, 0x2c, 0xc4, 0xa7,
+            ],
+            Bitcoin::TxLockDuration => [
+                0x53, 0x57, 0x28, 0x18, 0xe7, 0xe5, 0xb9, 0x8f, 0x96, 0x8c, 0x9d, 0xa7, 0xdf, 0x50,
+                0x90, 0xd9, 0x82, 0x6f, 0x9b, 0xcf, 0x84, 0xb6, 0x36, 0x39, 0x5e, 0xea, 0x32, 0x1b,
+                0x69, 0x09, 0xec, 0xe9,
+            ],
+            Bitcoin::TxLockHeight => [
+                0x44, 0x9f, 0x61, 0xdf, 0x1a, 0x7b, 0xad, 0x8d, 0x9e, 0x0a, 0x96, 0x67, 0x14, 0x22,
+                0x7e, 0x57, 0x10, 0x07, 0xf9, 0x3c, 0x51, 0x7b, 0x80, 0x5d, 0x61, 0x65, 0x10, 0xe8,
+                0xff, 0x62, 0x17, 0x2b,
+            ],
+            Bitcoin::TxLockTime => [
+                0x31, 0xdf, 0x36, 0x3f, 0x17, 0xb2, 0xcf, 0xc9, 0x7a, 0x1f, 0x93, 0x72, 0xc1, 0x4a,
+                0x32, 0x58, 0x64, 0xd7, 0xcb, 0x13, 0xaa, 0x8d, 0x52, 0x15, 0xfb, 0x25, 0x3d, 0x33,
+                0x10, 0x91, 0x77, 0x62,
+            ],
+            Bitcoin::Verify => [
+                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,
+            ],
+            Bitcoin::Version => [
+                0x83, 0x73, 0x58, 0x64, 0x00, 0xb6, 0x79, 0x0b, 0x46, 0xab, 0x04, 0x10, 0x52, 0x3c,
+                0xf0, 0x1e, 0xb7, 0x4d, 0x10, 0xfa, 0xf4, 0x8a, 0x3a, 0xcc, 0x86, 0xc4, 0xc5, 0x1d,
+                0x06, 0xa5, 0x2c, 0x49,
+            ],
+            Bitcoin::Xor1 => [
+                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,
+            ],
+            Bitcoin::Xor16 => [
+                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,
+            ],
+            Bitcoin::Xor32 => [
+                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,
+            ],
+            Bitcoin::Xor64 => [
+                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,
+            ],
+            Bitcoin::Xor8 => [
+                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,
+            ],
+            Bitcoin::XorXor1 => [
+                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,
+            ],
+            Bitcoin::XorXor16 => [
+                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,
+            ],
+            Bitcoin::XorXor32 => [
+                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,
+            ],
+            Bitcoin::XorXor64 => [
+                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,
+            ],
+            Bitcoin::XorXor8 => [
+                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,
+            ],
+        };
+
+        Cmr::from_byte_array(bytes)
     }
 
     fn source_ty(&self) -> TypeName {

From dfd65b8d15a56eb7027c739d7ca84cc9f3288e9c Mon Sep 17 00:00:00 2001
From: Byron Hambly <bhambly@blockstream.com>
Date: Mon, 7 Sep 2026 14:40:13 +0200
Subject: [PATCH 12/16] jet: implement Bitcoin jet cost table; add CMR/cost
 self-check tests

Replace the unimplemented!() cost() stub for Bitcoin jets with a match
table derived from primitiveJetNode.inc (.cost values, milliweight).

Add a #[cfg(test)] module that asserts every Bitcoin jet's cmr() matches
the 32-byte CMR recorded in primitiveJetNode.inc, and checks
representative cost() values. These guard the hardcoded tables against
drift from the canonical C source.
---
 src/jet/init/bitcoin.rs | 882 +++++++++++++++++++++++++++++++++++++++-
 1 file changed, 881 insertions(+), 1 deletion(-)

diff --git a/src/jet/init/bitcoin.rs b/src/jet/init/bitcoin.rs
index 93f72901..99ff5270 100644
--- a/src/jet/init/bitcoin.rs
+++ b/src/jet/init/bitcoin.rs
@@ -6841,7 +6841,436 @@ impl Jet for Bitcoin {
     }
 
     fn cost(&self) -> Cost {
-        unimplemented!("Unspecified cost of Bitcoin jets")
+        match self {
+            Bitcoin::Add16 => Cost::from_milliweight(80),
+            Bitcoin::Add32 => Cost::from_milliweight(92),
+            Bitcoin::Add64 => Cost::from_milliweight(105),
+            Bitcoin::Add8 => Cost::from_milliweight(97),
+            Bitcoin::All16 => Cost::from_milliweight(60),
+            Bitcoin::All32 => Cost::from_milliweight(62),
+            Bitcoin::All64 => Cost::from_milliweight(63),
+            Bitcoin::All8 => Cost::from_milliweight(50),
+            Bitcoin::And1 => Cost::from_milliweight(77),
+            Bitcoin::And16 => Cost::from_milliweight(83),
+            Bitcoin::And32 => Cost::from_milliweight(77),
+            Bitcoin::And64 => Cost::from_milliweight(78),
+            Bitcoin::And8 => Cost::from_milliweight(98),
+            Bitcoin::AnnexHash => Cost::from_milliweight(1491),
+            Bitcoin::Bip0340Verify => Cost::from_milliweight(49421),
+            Bitcoin::BuildTapbranch => Cost::from_milliweight(2554),
+            Bitcoin::BuildTapleafSimplicity => Cost::from_milliweight(1927),
+            Bitcoin::BuildTaptweak => Cost::from_milliweight(77780),
+            Bitcoin::CheckLockDistance => Cost::from_milliweight(84),
+            Bitcoin::CheckLockDuration => Cost::from_milliweight(78),
+            Bitcoin::CheckLockHeight => Cost::from_milliweight(108),
+            Bitcoin::CheckLockTime => Cost::from_milliweight(123),
+            Bitcoin::CheckSigVerify => Cost::from_milliweight(50000),
+            Bitcoin::Ch1 => Cost::from_milliweight(50),
+            Bitcoin::Ch16 => Cost::from_milliweight(83),
+            Bitcoin::Ch32 => Cost::from_milliweight(69),
+            Bitcoin::Ch64 => Cost::from_milliweight(78),
+            Bitcoin::Ch8 => Cost::from_milliweight(86),
+            Bitcoin::Complement1 => Cost::from_milliweight(51),
+            Bitcoin::Complement16 => Cost::from_milliweight(86),
+            Bitcoin::Complement32 => Cost::from_milliweight(58),
+            Bitcoin::Complement64 => Cost::from_milliweight(64),
+            Bitcoin::Complement8 => Cost::from_milliweight(62),
+            Bitcoin::CurrentAnnexHash => Cost::from_milliweight(74),
+            Bitcoin::CurrentIndex => Cost::from_milliweight(66),
+            Bitcoin::CurrentPrevOutpoint => Cost::from_milliweight(130),
+            Bitcoin::CurrentScriptHash => Cost::from_milliweight(127),
+            Bitcoin::CurrentScriptSigHash => Cost::from_milliweight(126),
+            Bitcoin::CurrentSequence => Cost::from_milliweight(66),
+            Bitcoin::CurrentValue => Cost::from_milliweight(85),
+            Bitcoin::Decompress => Cost::from_milliweight(10495),
+            Bitcoin::Decrement16 => Cost::from_milliweight(58),
+            Bitcoin::Decrement32 => Cost::from_milliweight(57),
+            Bitcoin::Decrement64 => Cost::from_milliweight(79),
+            Bitcoin::Decrement8 => Cost::from_milliweight(77),
+            Bitcoin::Divides16 => Cost::from_milliweight(84),
+            Bitcoin::Divides32 => Cost::from_milliweight(80),
+            Bitcoin::Divides64 => Cost::from_milliweight(67),
+            Bitcoin::Divides8 => Cost::from_milliweight(73),
+            Bitcoin::Divide16 => Cost::from_milliweight(85),
+            Bitcoin::Divide32 => Cost::from_milliweight(82),
+            Bitcoin::Divide64 => Cost::from_milliweight(81),
+            Bitcoin::Divide8 => Cost::from_milliweight(85),
+            Bitcoin::DivMod128_64 => Cost::from_milliweight(169),
+            Bitcoin::DivMod16 => Cost::from_milliweight(92),
+            Bitcoin::DivMod32 => Cost::from_milliweight(90),
+            Bitcoin::DivMod64 => Cost::from_milliweight(82),
+            Bitcoin::DivMod8 => Cost::from_milliweight(91),
+            Bitcoin::Eq1 => Cost::from_milliweight(63),
+            Bitcoin::Eq16 => Cost::from_milliweight(68),
+            Bitcoin::Eq256 => Cost::from_milliweight(188),
+            Bitcoin::Eq32 => Cost::from_milliweight(74),
+            Bitcoin::Eq64 => Cost::from_milliweight(82),
+            Bitcoin::Eq8 => Cost::from_milliweight(76),
+            Bitcoin::Fee => Cost::from_milliweight(65),
+            Bitcoin::FeAdd => Cost::from_milliweight(777),
+            Bitcoin::FeInvert => Cost::from_milliweight(3237),
+            Bitcoin::FeIsOdd => Cost::from_milliweight(313),
+            Bitcoin::FeIsZero => Cost::from_milliweight(277),
+            Bitcoin::FeMultiply => Cost::from_milliweight(813),
+            Bitcoin::FeMultiplyBeta => Cost::from_milliweight(607),
+            Bitcoin::FeNegate => Cost::from_milliweight(541),
+            Bitcoin::FeNormalize => Cost::from_milliweight(656),
+            Bitcoin::FeSquare => Cost::from_milliweight(570),
+            Bitcoin::FeSquareRoot => Cost::from_milliweight(10162),
+            Bitcoin::FullAdd16 => Cost::from_milliweight(106),
+            Bitcoin::FullAdd32 => Cost::from_milliweight(96),
+            Bitcoin::FullAdd64 => Cost::from_milliweight(93),
+            Bitcoin::FullAdd8 => Cost::from_milliweight(131),
+            Bitcoin::FullDecrement16 => Cost::from_milliweight(60),
+            Bitcoin::FullDecrement32 => Cost::from_milliweight(71),
+            Bitcoin::FullDecrement64 => Cost::from_milliweight(71),
+            Bitcoin::FullDecrement8 => Cost::from_milliweight(68),
+            Bitcoin::FullIncrement16 => Cost::from_milliweight(70),
+            Bitcoin::FullIncrement32 => Cost::from_milliweight(57),
+            Bitcoin::FullIncrement64 => Cost::from_milliweight(68),
+            Bitcoin::FullIncrement8 => Cost::from_milliweight(73),
+            Bitcoin::FullLeftShift16_1 => Cost::from_milliweight(76),
+            Bitcoin::FullLeftShift16_2 => Cost::from_milliweight(59),
+            Bitcoin::FullLeftShift16_4 => Cost::from_milliweight(68),
+            Bitcoin::FullLeftShift16_8 => Cost::from_milliweight(68),
+            Bitcoin::FullLeftShift32_1 => Cost::from_milliweight(58),
+            Bitcoin::FullLeftShift32_16 => Cost::from_milliweight(52),
+            Bitcoin::FullLeftShift32_2 => Cost::from_milliweight(73),
+            Bitcoin::FullLeftShift32_4 => Cost::from_milliweight(59),
+            Bitcoin::FullLeftShift32_8 => Cost::from_milliweight(60),
+            Bitcoin::FullLeftShift64_1 => Cost::from_milliweight(74),
+            Bitcoin::FullLeftShift64_16 => Cost::from_milliweight(69),
+            Bitcoin::FullLeftShift64_2 => Cost::from_milliweight(70),
+            Bitcoin::FullLeftShift64_32 => Cost::from_milliweight(73),
+            Bitcoin::FullLeftShift64_4 => Cost::from_milliweight(66),
+            Bitcoin::FullLeftShift64_8 => Cost::from_milliweight(68),
+            Bitcoin::FullLeftShift8_1 => Cost::from_milliweight(60),
+            Bitcoin::FullLeftShift8_2 => Cost::from_milliweight(64),
+            Bitcoin::FullLeftShift8_4 => Cost::from_milliweight(72),
+            Bitcoin::FullMultiply16 => Cost::from_milliweight(99),
+            Bitcoin::FullMultiply32 => Cost::from_milliweight(87),
+            Bitcoin::FullMultiply64 => Cost::from_milliweight(103),
+            Bitcoin::FullMultiply8 => Cost::from_milliweight(95),
+            Bitcoin::FullRightShift16_1 => Cost::from_milliweight(55),
+            Bitcoin::FullRightShift16_2 => Cost::from_milliweight(60),
+            Bitcoin::FullRightShift16_4 => Cost::from_milliweight(64),
+            Bitcoin::FullRightShift16_8 => Cost::from_milliweight(55),
+            Bitcoin::FullRightShift32_1 => Cost::from_milliweight(49),
+            Bitcoin::FullRightShift32_16 => Cost::from_milliweight(48),
+            Bitcoin::FullRightShift32_2 => Cost::from_milliweight(66),
+            Bitcoin::FullRightShift32_4 => Cost::from_milliweight(49),
+            Bitcoin::FullRightShift32_8 => Cost::from_milliweight(66),
+            Bitcoin::FullRightShift64_1 => Cost::from_milliweight(60),
+            Bitcoin::FullRightShift64_16 => Cost::from_milliweight(73),
+            Bitcoin::FullRightShift64_2 => Cost::from_milliweight(76),
+            Bitcoin::FullRightShift64_32 => Cost::from_milliweight(73),
+            Bitcoin::FullRightShift64_4 => Cost::from_milliweight(56),
+            Bitcoin::FullRightShift64_8 => Cost::from_milliweight(68),
+            Bitcoin::FullRightShift8_1 => Cost::from_milliweight(59),
+            Bitcoin::FullRightShift8_2 => Cost::from_milliweight(49),
+            Bitcoin::FullRightShift8_4 => Cost::from_milliweight(51),
+            Bitcoin::FullSubtract16 => Cost::from_milliweight(99),
+            Bitcoin::FullSubtract32 => Cost::from_milliweight(92),
+            Bitcoin::FullSubtract64 => Cost::from_milliweight(109),
+            Bitcoin::FullSubtract8 => Cost::from_milliweight(106),
+            Bitcoin::GejAdd => Cost::from_milliweight(3000),
+            Bitcoin::GejDouble => Cost::from_milliweight(1862),
+            Bitcoin::GejEquiv => Cost::from_milliweight(2376),
+            Bitcoin::GejGeAdd => Cost::from_milliweight(2609),
+            Bitcoin::GejGeAddEx => Cost::from_milliweight(2860),
+            Bitcoin::GejGeEquiv => Cost::from_milliweight(1823),
+            Bitcoin::GejInfinity => Cost::from_milliweight(765),
+            Bitcoin::GejIsInfinity => Cost::from_milliweight(701),
+            Bitcoin::GejIsOnCurve => Cost::from_milliweight(1039),
+            Bitcoin::GejNegate => Cost::from_milliweight(1549),
+            Bitcoin::GejNormalize => Cost::from_milliweight(4184),
+            Bitcoin::GejRescale => Cost::from_milliweight(2011),
+            Bitcoin::GejXEquiv => Cost::from_milliweight(1103),
+            Bitcoin::GejYIsOdd => Cost::from_milliweight(3702),
+            Bitcoin::Generate => Cost::from_milliweight(49851),
+            Bitcoin::GeIsOnCurve => Cost::from_milliweight(688),
+            Bitcoin::GeNegate => Cost::from_milliweight(1071),
+            Bitcoin::HashToCurve => Cost::from_milliweight(69844),
+            Bitcoin::High1 => Cost::from_milliweight(42),
+            Bitcoin::High16 => Cost::from_milliweight(50),
+            Bitcoin::High32 => Cost::from_milliweight(64),
+            Bitcoin::High64 => Cost::from_milliweight(52),
+            Bitcoin::High8 => Cost::from_milliweight(59),
+            Bitcoin::Increment16 => Cost::from_milliweight(56),
+            Bitcoin::Increment32 => Cost::from_milliweight(73),
+            Bitcoin::Increment64 => Cost::from_milliweight(64),
+            Bitcoin::Increment8 => Cost::from_milliweight(69),
+            Bitcoin::InputsHash => Cost::from_milliweight(122),
+            Bitcoin::InputAnnexesHash => Cost::from_milliweight(124),
+            Bitcoin::InputAnnexHash => Cost::from_milliweight(77),
+            Bitcoin::InputHash => Cost::from_milliweight(832),
+            Bitcoin::InputOutpointsHash => Cost::from_milliweight(126),
+            Bitcoin::InputPrevOutpoint => Cost::from_milliweight(140),
+            Bitcoin::InputScriptsHash => Cost::from_milliweight(129),
+            Bitcoin::InputScriptHash => Cost::from_milliweight(143),
+            Bitcoin::InputScriptSigsHash => Cost::from_milliweight(127),
+            Bitcoin::InputScriptSigHash => Cost::from_milliweight(137),
+            Bitcoin::InputSequence => Cost::from_milliweight(78),
+            Bitcoin::InputSequencesHash => Cost::from_milliweight(125),
+            Bitcoin::InputUtxosHash => Cost::from_milliweight(122),
+            Bitcoin::InputUtxoHash => Cost::from_milliweight(824),
+            Bitcoin::InputValue => Cost::from_milliweight(81),
+            Bitcoin::InputValuesHash => Cost::from_milliweight(126),
+            Bitcoin::InternalKey => Cost::from_milliweight(124),
+            Bitcoin::IsOne16 => Cost::from_milliweight(64),
+            Bitcoin::IsOne32 => Cost::from_milliweight(64),
+            Bitcoin::IsOne64 => Cost::from_milliweight(66),
+            Bitcoin::IsOne8 => Cost::from_milliweight(47),
+            Bitcoin::IsZero16 => Cost::from_milliweight(52),
+            Bitcoin::IsZero32 => Cost::from_milliweight(58),
+            Bitcoin::IsZero64 => Cost::from_milliweight(68),
+            Bitcoin::IsZero8 => Cost::from_milliweight(59),
+            Bitcoin::Leftmost16_1 => Cost::from_milliweight(68),
+            Bitcoin::Leftmost16_2 => Cost::from_milliweight(58),
+            Bitcoin::Leftmost16_4 => Cost::from_milliweight(51),
+            Bitcoin::Leftmost16_8 => Cost::from_milliweight(62),
+            Bitcoin::Leftmost32_1 => Cost::from_milliweight(53),
+            Bitcoin::Leftmost32_16 => Cost::from_milliweight(63),
+            Bitcoin::Leftmost32_2 => Cost::from_milliweight(62),
+            Bitcoin::Leftmost32_4 => Cost::from_milliweight(61),
+            Bitcoin::Leftmost32_8 => Cost::from_milliweight(60),
+            Bitcoin::Leftmost64_1 => Cost::from_milliweight(65),
+            Bitcoin::Leftmost64_16 => Cost::from_milliweight(62),
+            Bitcoin::Leftmost64_2 => Cost::from_milliweight(61),
+            Bitcoin::Leftmost64_32 => Cost::from_milliweight(77),
+            Bitcoin::Leftmost64_4 => Cost::from_milliweight(80),
+            Bitcoin::Leftmost64_8 => Cost::from_milliweight(54),
+            Bitcoin::Leftmost8_1 => Cost::from_milliweight(54),
+            Bitcoin::Leftmost8_2 => Cost::from_milliweight(71),
+            Bitcoin::Leftmost8_4 => Cost::from_milliweight(65),
+            Bitcoin::LeftExtend16_32 => Cost::from_milliweight(72),
+            Bitcoin::LeftExtend16_64 => Cost::from_milliweight(69),
+            Bitcoin::LeftExtend1_16 => Cost::from_milliweight(50),
+            Bitcoin::LeftExtend1_32 => Cost::from_milliweight(48),
+            Bitcoin::LeftExtend1_64 => Cost::from_milliweight(49),
+            Bitcoin::LeftExtend1_8 => Cost::from_milliweight(46),
+            Bitcoin::LeftExtend32_64 => Cost::from_milliweight(69),
+            Bitcoin::LeftExtend8_16 => Cost::from_milliweight(58),
+            Bitcoin::LeftExtend8_32 => Cost::from_milliweight(86),
+            Bitcoin::LeftExtend8_64 => Cost::from_milliweight(98),
+            Bitcoin::LeftPadHigh16_32 => Cost::from_milliweight(71),
+            Bitcoin::LeftPadHigh16_64 => Cost::from_milliweight(82),
+            Bitcoin::LeftPadHigh1_16 => Cost::from_milliweight(106),
+            Bitcoin::LeftPadHigh1_32 => Cost::from_milliweight(220),
+            Bitcoin::LeftPadHigh1_64 => Cost::from_milliweight(302),
+            Bitcoin::LeftPadHigh1_8 => Cost::from_milliweight(73),
+            Bitcoin::LeftPadHigh32_64 => Cost::from_milliweight(69),
+            Bitcoin::LeftPadHigh8_16 => Cost::from_milliweight(65),
+            Bitcoin::LeftPadHigh8_32 => Cost::from_milliweight(105),
+            Bitcoin::LeftPadHigh8_64 => Cost::from_milliweight(113),
+            Bitcoin::LeftPadLow16_32 => Cost::from_milliweight(65),
+            Bitcoin::LeftPadLow16_64 => Cost::from_milliweight(68),
+            Bitcoin::LeftPadLow1_16 => Cost::from_milliweight(59),
+            Bitcoin::LeftPadLow1_32 => Cost::from_milliweight(47),
+            Bitcoin::LeftPadLow1_64 => Cost::from_milliweight(46),
+            Bitcoin::LeftPadLow1_8 => Cost::from_milliweight(48),
+            Bitcoin::LeftPadLow32_64 => Cost::from_milliweight(62),
+            Bitcoin::LeftPadLow8_16 => Cost::from_milliweight(56),
+            Bitcoin::LeftPadLow8_32 => Cost::from_milliweight(75),
+            Bitcoin::LeftPadLow8_64 => Cost::from_milliweight(116),
+            Bitcoin::LeftRotate16 => Cost::from_milliweight(88),
+            Bitcoin::LeftRotate32 => Cost::from_milliweight(62),
+            Bitcoin::LeftRotate64 => Cost::from_milliweight(68),
+            Bitcoin::LeftRotate8 => Cost::from_milliweight(66),
+            Bitcoin::LeftShift16 => Cost::from_milliweight(109),
+            Bitcoin::LeftShift32 => Cost::from_milliweight(79),
+            Bitcoin::LeftShift64 => Cost::from_milliweight(70),
+            Bitcoin::LeftShift8 => Cost::from_milliweight(72),
+            Bitcoin::LeftShiftWith16 => Cost::from_milliweight(72),
+            Bitcoin::LeftShiftWith32 => Cost::from_milliweight(87),
+            Bitcoin::LeftShiftWith64 => Cost::from_milliweight(97),
+            Bitcoin::LeftShiftWith8 => Cost::from_milliweight(104),
+            Bitcoin::Le16 => Cost::from_milliweight(83),
+            Bitcoin::Le32 => Cost::from_milliweight(99),
+            Bitcoin::Le64 => Cost::from_milliweight(79),
+            Bitcoin::Le8 => Cost::from_milliweight(93),
+            Bitcoin::LinearCombination1 => Cost::from_milliweight(85743),
+            Bitcoin::LinearVerify1 => Cost::from_milliweight(43579),
+            Bitcoin::LockTime => Cost::from_milliweight(66),
+            Bitcoin::Low1 => Cost::from_milliweight(40),
+            Bitcoin::Low16 => Cost::from_milliweight(60),
+            Bitcoin::Low32 => Cost::from_milliweight(52),
+            Bitcoin::Low64 => Cost::from_milliweight(50),
+            Bitcoin::Low8 => Cost::from_milliweight(45),
+            Bitcoin::Lt16 => Cost::from_milliweight(83),
+            Bitcoin::Lt32 => Cost::from_milliweight(89),
+            Bitcoin::Lt64 => Cost::from_milliweight(71),
+            Bitcoin::Lt8 => Cost::from_milliweight(86),
+            Bitcoin::Maj1 => Cost::from_milliweight(54),
+            Bitcoin::Maj16 => Cost::from_milliweight(85),
+            Bitcoin::Maj32 => Cost::from_milliweight(73),
+            Bitcoin::Maj64 => Cost::from_milliweight(79),
+            Bitcoin::Maj8 => Cost::from_milliweight(64),
+            Bitcoin::Max16 => Cost::from_milliweight(80),
+            Bitcoin::Max32 => Cost::from_milliweight(70),
+            Bitcoin::Max64 => Cost::from_milliweight(75),
+            Bitcoin::Max8 => Cost::from_milliweight(79),
+            Bitcoin::Median16 => Cost::from_milliweight(80),
+            Bitcoin::Median32 => Cost::from_milliweight(77),
+            Bitcoin::Median64 => Cost::from_milliweight(89),
+            Bitcoin::Median8 => Cost::from_milliweight(77),
+            Bitcoin::Min16 => Cost::from_milliweight(83),
+            Bitcoin::Min32 => Cost::from_milliweight(96),
+            Bitcoin::Min64 => Cost::from_milliweight(82),
+            Bitcoin::Min8 => Cost::from_milliweight(78),
+            Bitcoin::Modulo16 => Cost::from_milliweight(85),
+            Bitcoin::Modulo32 => Cost::from_milliweight(81),
+            Bitcoin::Modulo64 => Cost::from_milliweight(71),
+            Bitcoin::Modulo8 => Cost::from_milliweight(85),
+            Bitcoin::Multiply16 => Cost::from_milliweight(79),
+            Bitcoin::Multiply32 => Cost::from_milliweight(78),
+            Bitcoin::Multiply64 => Cost::from_milliweight(72),
+            Bitcoin::Multiply8 => Cost::from_milliweight(79),
+            Bitcoin::Negate16 => Cost::from_milliweight(69),
+            Bitcoin::Negate32 => Cost::from_milliweight(56),
+            Bitcoin::Negate64 => Cost::from_milliweight(56),
+            Bitcoin::Negate8 => Cost::from_milliweight(69),
+            Bitcoin::NumInputs => Cost::from_milliweight(74),
+            Bitcoin::NumOutputs => Cost::from_milliweight(68),
+            Bitcoin::One16 => Cost::from_milliweight(45),
+            Bitcoin::One32 => Cost::from_milliweight(45),
+            Bitcoin::One64 => Cost::from_milliweight(45),
+            Bitcoin::One8 => Cost::from_milliweight(46),
+            Bitcoin::Or1 => Cost::from_milliweight(56),
+            Bitcoin::Or16 => Cost::from_milliweight(78),
+            Bitcoin::Or32 => Cost::from_milliweight(80),
+            Bitcoin::Or64 => Cost::from_milliweight(71),
+            Bitcoin::Or8 => Cost::from_milliweight(81),
+            Bitcoin::OutpointHash => Cost::from_milliweight(1788),
+            Bitcoin::OutputsHash => Cost::from_milliweight(117),
+            Bitcoin::OutputHash => Cost::from_milliweight(822),
+            Bitcoin::OutputScriptsHash => Cost::from_milliweight(123),
+            Bitcoin::OutputScriptHash => Cost::from_milliweight(135),
+            Bitcoin::OutputValue => Cost::from_milliweight(82),
+            Bitcoin::OutputValuesHash => Cost::from_milliweight(119),
+            Bitcoin::ParseLock => Cost::from_milliweight(82),
+            Bitcoin::ParseSequence => Cost::from_milliweight(93),
+            Bitcoin::PointVerify1 => Cost::from_milliweight(41394),
+            Bitcoin::Rightmost16_1 => Cost::from_milliweight(70),
+            Bitcoin::Rightmost16_2 => Cost::from_milliweight(65),
+            Bitcoin::Rightmost16_4 => Cost::from_milliweight(72),
+            Bitcoin::Rightmost16_8 => Cost::from_milliweight(69),
+            Bitcoin::Rightmost32_1 => Cost::from_milliweight(70),
+            Bitcoin::Rightmost32_16 => Cost::from_milliweight(56),
+            Bitcoin::Rightmost32_2 => Cost::from_milliweight(74),
+            Bitcoin::Rightmost32_4 => Cost::from_milliweight(57),
+            Bitcoin::Rightmost32_8 => Cost::from_milliweight(55),
+            Bitcoin::Rightmost64_1 => Cost::from_milliweight(61),
+            Bitcoin::Rightmost64_16 => Cost::from_milliweight(63),
+            Bitcoin::Rightmost64_2 => Cost::from_milliweight(65),
+            Bitcoin::Rightmost64_32 => Cost::from_milliweight(64),
+            Bitcoin::Rightmost64_4 => Cost::from_milliweight(57),
+            Bitcoin::Rightmost64_8 => Cost::from_milliweight(49),
+            Bitcoin::Rightmost8_1 => Cost::from_milliweight(65),
+            Bitcoin::Rightmost8_2 => Cost::from_milliweight(63),
+            Bitcoin::Rightmost8_4 => Cost::from_milliweight(56),
+            Bitcoin::RightExtend16_32 => Cost::from_milliweight(73),
+            Bitcoin::RightExtend16_64 => Cost::from_milliweight(70),
+            Bitcoin::RightExtend32_64 => Cost::from_milliweight(62),
+            Bitcoin::RightExtend8_16 => Cost::from_milliweight(63),
+            Bitcoin::RightExtend8_32 => Cost::from_milliweight(69),
+            Bitcoin::RightExtend8_64 => Cost::from_milliweight(141),
+            Bitcoin::RightPadHigh16_32 => Cost::from_milliweight(66),
+            Bitcoin::RightPadHigh16_64 => Cost::from_milliweight(81),
+            Bitcoin::RightPadHigh1_16 => Cost::from_milliweight(114),
+            Bitcoin::RightPadHigh1_32 => Cost::from_milliweight(220),
+            Bitcoin::RightPadHigh1_64 => Cost::from_milliweight(313),
+            Bitcoin::RightPadHigh1_8 => Cost::from_milliweight(73),
+            Bitcoin::RightPadHigh32_64 => Cost::from_milliweight(62),
+            Bitcoin::RightPadHigh8_16 => Cost::from_milliweight(75),
+            Bitcoin::RightPadHigh8_32 => Cost::from_milliweight(81),
+            Bitcoin::RightPadHigh8_64 => Cost::from_milliweight(118),
+            Bitcoin::RightPadLow16_32 => Cost::from_milliweight(62),
+            Bitcoin::RightPadLow16_64 => Cost::from_milliweight(98),
+            Bitcoin::RightPadLow1_16 => Cost::from_milliweight(60),
+            Bitcoin::RightPadLow1_32 => Cost::from_milliweight(47),
+            Bitcoin::RightPadLow1_64 => Cost::from_milliweight(57),
+            Bitcoin::RightPadLow1_8 => Cost::from_milliweight(48),
+            Bitcoin::RightPadLow32_64 => Cost::from_milliweight(74),
+            Bitcoin::RightPadLow8_16 => Cost::from_milliweight(62),
+            Bitcoin::RightPadLow8_32 => Cost::from_milliweight(69),
+            Bitcoin::RightPadLow8_64 => Cost::from_milliweight(98),
+            Bitcoin::RightRotate16 => Cost::from_milliweight(67),
+            Bitcoin::RightRotate32 => Cost::from_milliweight(77),
+            Bitcoin::RightRotate64 => Cost::from_milliweight(64),
+            Bitcoin::RightRotate8 => Cost::from_milliweight(72),
+            Bitcoin::RightShift16 => Cost::from_milliweight(60),
+            Bitcoin::RightShift32 => Cost::from_milliweight(69),
+            Bitcoin::RightShift64 => Cost::from_milliweight(68),
+            Bitcoin::RightShift8 => Cost::from_milliweight(63),
+            Bitcoin::RightShiftWith16 => Cost::from_milliweight(83),
+            Bitcoin::RightShiftWith32 => Cost::from_milliweight(78),
+            Bitcoin::RightShiftWith64 => Cost::from_milliweight(72),
+            Bitcoin::RightShiftWith8 => Cost::from_milliweight(71),
+            Bitcoin::ScalarAdd => Cost::from_milliweight(778),
+            Bitcoin::ScalarInvert => Cost::from_milliweight(3178),
+            Bitcoin::ScalarIsZero => Cost::from_milliweight(271),
+            Bitcoin::ScalarMultiply => Cost::from_milliweight(793),
+            Bitcoin::ScalarMultiplyLambda => Cost::from_milliweight(567),
+            Bitcoin::ScalarNegate => Cost::from_milliweight(516),
+            Bitcoin::ScalarNormalize => Cost::from_milliweight(500),
+            Bitcoin::ScalarSquare => Cost::from_milliweight(571),
+            Bitcoin::Scale => Cost::from_milliweight(73548),
+            Bitcoin::ScriptCMR => Cost::from_milliweight(122),
+            Bitcoin::Sha256Block => Cost::from_milliweight(765),
+            Bitcoin::Sha256Ctx8Add1 => Cost::from_milliweight(664),
+            Bitcoin::Sha256Ctx8Add128 => Cost::from_milliweight(1778),
+            Bitcoin::Sha256Ctx8Add16 => Cost::from_milliweight(781),
+            Bitcoin::Sha256Ctx8Add2 => Cost::from_milliweight(674),
+            Bitcoin::Sha256Ctx8Add256 => Cost::from_milliweight(2894),
+            Bitcoin::Sha256Ctx8Add32 => Cost::from_milliweight(928),
+            Bitcoin::Sha256Ctx8Add4 => Cost::from_milliweight(656),
+            Bitcoin::Sha256Ctx8Add512 => Cost::from_milliweight(5161),
+            Bitcoin::Sha256Ctx8Add64 => Cost::from_milliweight(1220),
+            Bitcoin::Sha256Ctx8Add8 => Cost::from_milliweight(694),
+            Bitcoin::Sha256Ctx8AddBuffer511 => Cost::from_milliweight(5137),
+            Bitcoin::Sha256Ctx8Finalize => Cost::from_milliweight(833),
+            Bitcoin::Sha256Ctx8Init => Cost::from_milliweight(123),
+            Bitcoin::Sha256Iv => Cost::from_milliweight(92),
+            Bitcoin::SigAllHash => Cost::from_milliweight(120),
+            Bitcoin::Some1 => Cost::from_milliweight(60),
+            Bitcoin::Some16 => Cost::from_milliweight(52),
+            Bitcoin::Some32 => Cost::from_milliweight(49),
+            Bitcoin::Some64 => Cost::from_milliweight(62),
+            Bitcoin::Some8 => Cost::from_milliweight(57),
+            Bitcoin::Subtract16 => Cost::from_milliweight(93),
+            Bitcoin::Subtract32 => Cost::from_milliweight(87),
+            Bitcoin::Subtract64 => Cost::from_milliweight(125),
+            Bitcoin::Subtract8 => Cost::from_milliweight(96),
+            Bitcoin::Swu => Cost::from_milliweight(32780),
+            Bitcoin::TapdataInit => Cost::from_milliweight(1233),
+            Bitcoin::TapleafHash => Cost::from_milliweight(116),
+            Bitcoin::TapleafVersion => Cost::from_milliweight(66),
+            Bitcoin::Tappath => Cost::from_milliweight(76),
+            Bitcoin::TappathHash => Cost::from_milliweight(123),
+            Bitcoin::TapEnvHash => Cost::from_milliweight(120),
+            Bitcoin::TotalInputValue => Cost::from_milliweight(69),
+            Bitcoin::TotalOutputValue => Cost::from_milliweight(71),
+            Bitcoin::TransactionId => Cost::from_milliweight(122),
+            Bitcoin::TxHash => Cost::from_milliweight(119),
+            Bitcoin::TxIsFinal => Cost::from_milliweight(62),
+            Bitcoin::TxLockDistance => Cost::from_milliweight(72),
+            Bitcoin::TxLockDuration => Cost::from_milliweight(66),
+            Bitcoin::TxLockHeight => Cost::from_milliweight(72),
+            Bitcoin::TxLockTime => Cost::from_milliweight(72),
+            Bitcoin::Verify => Cost::from_milliweight(44),
+            Bitcoin::Version => Cost::from_milliweight(78),
+            Bitcoin::Xor1 => Cost::from_milliweight(60),
+            Bitcoin::Xor16 => Cost::from_milliweight(73),
+            Bitcoin::Xor32 => Cost::from_milliweight(77),
+            Bitcoin::Xor64 => Cost::from_milliweight(68),
+            Bitcoin::Xor8 => Cost::from_milliweight(80),
+            Bitcoin::XorXor1 => Cost::from_milliweight(50),
+            Bitcoin::XorXor16 => Cost::from_milliweight(82),
+            Bitcoin::XorXor32 => Cost::from_milliweight(82),
+            Bitcoin::XorXor64 => Cost::from_milliweight(80),
+            Bitcoin::XorXor8 => Cost::from_milliweight(86),
+        }
     }
 
     fn parse(s: &str) -> Result<Self, crate::Error> where Self: Sized {
@@ -7725,3 +8154,454 @@ impl str::FromStr for Bitcoin {
 pub(crate) fn c_jet_ptr(jet: &Bitcoin) -> fn(&mut CFrameItem, CFrameItem, &()) -> bool {
         unimplemented!("Bitcoin jets have not yet been implemented.")
 }
+
+
+#[cfg(test)]
+mod bitcoin_cmr_tests {
+    use super::*;
+    use crate::merkle::cmr::Cmr;
+
+    #[test]
+    fn cmr_matches_spec() {
+        assert_eq!(Bitcoin::Add16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Add32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Add64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Add8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::All16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::All32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::All64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::All8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::And1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::And16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::And32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::And64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::And8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::AnnexHash.cmr(), Cmr::from_byte_array([0x51, 0xfa, 0x19, 0x13, 0xa6, 0x29, 0x73, 0x48, 0x4a, 0x70, 0x0a, 0xf3, 0xff, 0x93, 0x26, 0x94, 0xd3, 0x89, 0x0a, 0xe0, 0xad, 0x87, 0xa4, 0x55, 0xda, 0xf4, 0x90, 0x6f, 0x22, 0x4a, 0x48, 0xd5]));
+        assert_eq!(Bitcoin::Bip0340Verify.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::BuildTapbranch.cmr(), Cmr::from_byte_array([0xef, 0x8e, 0x92, 0x91, 0x9b, 0x26, 0x08, 0xea, 0x6b, 0x5b, 0xcd, 0xd3, 0x9c, 0x51, 0x78, 0xe5, 0x46, 0x24, 0x95, 0x53, 0x91, 0x4b, 0x0f, 0x8d, 0x33, 0x73, 0x5d, 0x28, 0x86, 0xe1, 0xa5, 0xe8]));
+        assert_eq!(Bitcoin::BuildTapleafSimplicity.cmr(), Cmr::from_byte_array([0x22, 0x41, 0x19, 0x09, 0x98, 0x41, 0x47, 0xde, 0x8f, 0x5a, 0x04, 0x28, 0x35, 0x8b, 0x47, 0x16, 0xdb, 0x08, 0x76, 0x64, 0xa7, 0x28, 0x56, 0x08, 0x52, 0xb0, 0xe6, 0x16, 0xeb, 0xc6, 0x2d, 0x30]));
+        assert_eq!(Bitcoin::BuildTaptweak.cmr(), Cmr::from_byte_array([0xf1, 0x92, 0xdb, 0x17, 0x06, 0x60, 0x8d, 0xef, 0x16, 0x5d, 0xbd, 0xda, 0x72, 0xa3, 0x8c, 0x88, 0x82, 0xcb, 0x36, 0xc6, 0xda, 0x47, 0x07, 0x0d, 0x8a, 0x5f, 0x58, 0x96, 0xfb, 0xda, 0x84, 0x34]));
+        assert_eq!(Bitcoin::CheckLockDistance.cmr(), Cmr::from_byte_array([0x38, 0xfd, 0xf7, 0xdd, 0x28, 0x53, 0x86, 0x70, 0xfb, 0x34, 0xc1, 0xbf, 0xe7, 0x2f, 0x17, 0xe2, 0xca, 0x57, 0x84, 0xf8, 0x7f, 0xed, 0x88, 0xea, 0xb5, 0x84, 0x79, 0x2b, 0x39, 0x74, 0xbd, 0x18]));
+        assert_eq!(Bitcoin::CheckLockDuration.cmr(), Cmr::from_byte_array([0x77, 0x50, 0x38, 0x32, 0x6e, 0xae, 0x25, 0xc7, 0x20, 0x9b, 0x24, 0x43, 0x06, 0xea, 0xa9, 0xf9, 0x20, 0x4c, 0x7e, 0xce, 0x2d, 0xd6, 0x3b, 0x45, 0x2e, 0x10, 0x01, 0x7f, 0xa4, 0xea, 0x53, 0xcf]));
+        assert_eq!(Bitcoin::CheckLockHeight.cmr(), Cmr::from_byte_array([0xb9, 0x0f, 0x15, 0x1f, 0x45, 0xb4, 0xeb, 0x37, 0x21, 0x06, 0x21, 0xf9, 0x70, 0x0a, 0x36, 0xc8, 0xc5, 0x04, 0xbe, 0xe0, 0x67, 0x77, 0x11, 0x63, 0xa8, 0xb8, 0x3a, 0x77, 0x18, 0xe6, 0x68, 0x6a]));
+        assert_eq!(Bitcoin::CheckLockTime.cmr(), Cmr::from_byte_array([0xa4, 0x51, 0xeb, 0xb2, 0x25, 0xd6, 0xb1, 0x33, 0xa5, 0xe6, 0x35, 0x39, 0x78, 0x00, 0xd4, 0x87, 0xb3, 0x96, 0x8b, 0x0d, 0xe5, 0x5c, 0x96, 0xeb, 0x82, 0xf2, 0x90, 0xec, 0xff, 0x9c, 0x25, 0x90]));
+        assert_eq!(Bitcoin::CheckSigVerify.cmr(), Cmr::from_byte_array([0xb5, 0x80, 0x15, 0x54, 0x6d, 0x28, 0x52, 0x66, 0x5d, 0xd2, 0x1b, 0xf1, 0x12, 0x66, 0x26, 0x70, 0x20, 0xfa, 0x5e, 0x27, 0x50, 0x01, 0xdd, 0x46, 0x18, 0xfa, 0x41, 0x56, 0x25, 0x95, 0x2e, 0x68]));
+        assert_eq!(Bitcoin::Ch1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Ch16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Ch32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Ch64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Ch8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Complement1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Complement16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Complement32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Complement64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Complement8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::CurrentAnnexHash.cmr(), Cmr::from_byte_array([0xce, 0xd9, 0x02, 0x2e, 0xdc, 0x69, 0x24, 0x1f, 0xe7, 0x07, 0x49, 0xa7, 0xf5, 0xd4, 0x89, 0xc3, 0x13, 0x5e, 0xe8, 0xc9, 0x6f, 0xe6, 0x4c, 0x44, 0x64, 0x40, 0x1f, 0x98, 0x51, 0xd7, 0xa1, 0x7d]));
+        assert_eq!(Bitcoin::CurrentIndex.cmr(), Cmr::from_byte_array([0x0e, 0x8c, 0x96, 0x4c, 0x2f, 0x2b, 0x34, 0x90, 0x36, 0x2f, 0x3b, 0xbc, 0x74, 0x83, 0xde, 0xa3, 0x7f, 0xda, 0x81, 0x0b, 0x69, 0x31, 0x4f, 0xf6, 0x64, 0xfe, 0xa0, 0xe3, 0x27, 0x08, 0xec, 0x8f]));
+        assert_eq!(Bitcoin::CurrentPrevOutpoint.cmr(), Cmr::from_byte_array([0x64, 0x43, 0x39, 0x1b, 0x34, 0x40, 0x86, 0x84, 0x6d, 0x5a, 0x17, 0xa6, 0x2e, 0x3e, 0x06, 0x28, 0x2a, 0xd6, 0x96, 0x2c, 0x4d, 0xfc, 0xed, 0x2f, 0x6a, 0x83, 0xd0, 0xdf, 0xbf, 0x6a, 0x5c, 0x54]));
+        assert_eq!(Bitcoin::CurrentScriptHash.cmr(), Cmr::from_byte_array([0x23, 0x49, 0x8d, 0xd6, 0x64, 0x5e, 0xd1, 0x38, 0xb3, 0x44, 0x93, 0x7c, 0xf6, 0x54, 0xaa, 0xff, 0xa6, 0x27, 0xf8, 0x5a, 0x47, 0xca, 0xa6, 0x89, 0x54, 0xf1, 0x3f, 0x4c, 0x6a, 0x4d, 0xc7, 0x72]));
+        assert_eq!(Bitcoin::CurrentScriptSigHash.cmr(), Cmr::from_byte_array([0x34, 0xa3, 0xc5, 0x5d, 0x14, 0x73, 0x74, 0xd8, 0xf3, 0xa1, 0x76, 0x1b, 0xba, 0xb2, 0x86, 0x96, 0x84, 0x55, 0x40, 0x4c, 0x2c, 0xa0, 0x3f, 0x69, 0x39, 0x3f, 0x63, 0x39, 0xd0, 0xf5, 0x8b, 0x59]));
+        assert_eq!(Bitcoin::CurrentSequence.cmr(), Cmr::from_byte_array([0xc4, 0x9f, 0x76, 0xac, 0x79, 0xf8, 0xf1, 0x5c, 0x40, 0x9b, 0xa8, 0x15, 0xc1, 0x6e, 0xdc, 0xb8, 0xd1, 0x1e, 0x9a, 0x07, 0x56, 0x5c, 0x8e, 0x09, 0xb6, 0x3e, 0x7f, 0xdf, 0x31, 0x03, 0x00, 0x9f]));
+        assert_eq!(Bitcoin::CurrentValue.cmr(), Cmr::from_byte_array([0x91, 0xb9, 0x6e, 0x82, 0x9e, 0x3b, 0x49, 0x72, 0xb0, 0xcb, 0x09, 0x1a, 0x0a, 0x90, 0x4b, 0xa4, 0x11, 0x33, 0x8a, 0xbf, 0xc0, 0x8d, 0xa7, 0x86, 0xd5, 0xa8, 0x4f, 0x04, 0x9b, 0x5b, 0xa3, 0xb8]));
+        assert_eq!(Bitcoin::Decompress.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Decrement16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Decrement32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Decrement64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Decrement8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Divides16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Divides32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Divides64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Divides8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Divide16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Divide32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Divide64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Divide8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::DivMod128_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::DivMod16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::DivMod32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::DivMod64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::DivMod8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Eq1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Eq16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Eq256.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Eq32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Eq64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Eq8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Fee.cmr(), Cmr::from_byte_array([0xfb, 0x9c, 0xa9, 0x39, 0x81, 0x67, 0x3d, 0x1d, 0x23, 0xae, 0xd2, 0x4d, 0x61, 0x2c, 0x1f, 0x5d, 0xc7, 0xcd, 0x49, 0xf8, 0x6d, 0x34, 0x8e, 0x67, 0xa1, 0x5b, 0xc4, 0xa7, 0x13, 0x0a, 0xe1, 0x85]));
+        assert_eq!(Bitcoin::FeAdd.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FeInvert.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FeIsOdd.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FeIsZero.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FeMultiply.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FeMultiplyBeta.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FeNegate.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FeNormalize.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FeSquare.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FeSquareRoot.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullAdd16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullAdd32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullAdd64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullAdd8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullDecrement16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullDecrement32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullDecrement64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullDecrement8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullIncrement16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullIncrement32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullIncrement64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullIncrement8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift16_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift16_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift16_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift16_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift32_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift32_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift32_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift32_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift32_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift64_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift64_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift64_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift64_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift64_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift64_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift8_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift8_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullLeftShift8_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullMultiply16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullMultiply32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullMultiply64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullMultiply8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift16_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift16_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift16_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift16_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift32_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift32_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift32_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift32_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift32_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift64_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift64_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift64_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift64_32.cmr(), Cmr::from_byte_array([0x35, 0x6f, 0x7d, 0xd4, 0x6b, 0xa3, 0x3f, 0x84, 0xb0, 0x66, 0x72, 0xfd, 0xe9, 0xa2, 0x97, 0x2e, 0x80, 0xf3, 0xea, 0x96, 0x5a, 0xe8, 0xbc, 0x0b, 0xff, 0x67, 0xaa, 0x2f, 0x69, 0xf1, 0x0b, 0x56]));
+        assert_eq!(Bitcoin::FullRightShift64_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift64_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift8_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift8_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullRightShift8_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullSubtract16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullSubtract32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullSubtract64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::FullSubtract8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejAdd.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejDouble.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejEquiv.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejGeAdd.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejGeAddEx.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejGeEquiv.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejInfinity.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejIsInfinity.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejIsOnCurve.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejNegate.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejNormalize.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejRescale.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejXEquiv.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GejYIsOdd.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Generate.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GeIsOnCurve.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::GeNegate.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::HashToCurve.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::High1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::High16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::High32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::High64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::High8.cmr(), Cmr::from_byte_array([0xcb, 0xd7, 0x8d, 0x50, 0xaf, 0x77, 0x99, 0x85, 0x5a, 0xdc, 0x49, 0x03, 0xdb, 0xbe, 0xfc, 0x13, 0x45, 0xd5, 0x14, 0x84, 0xf0, 0x3d, 0x3c, 0x75, 0x5c, 0xaa, 0xa5, 0xca, 0xa9, 0x7d, 0x4a, 0x14]));
+        assert_eq!(Bitcoin::Increment16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Increment32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Increment64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Increment8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::InputsHash.cmr(), Cmr::from_byte_array([0xab, 0xbf, 0xe1, 0xc7, 0xd1, 0x15, 0xc4, 0x19, 0x1f, 0x50, 0x48, 0x39, 0xf9, 0x8c, 0x3f, 0x20, 0x42, 0x2b, 0x84, 0xe7, 0xfa, 0x14, 0xda, 0x14, 0x02, 0x89, 0x6c, 0x4d, 0x98, 0xbf, 0xa8, 0xd8]));
+        assert_eq!(Bitcoin::InputAnnexesHash.cmr(), Cmr::from_byte_array([0x89, 0xb6, 0x02, 0x70, 0x44, 0x14, 0x1f, 0x20, 0x65, 0xb6, 0xf2, 0x36, 0xcf, 0xcc, 0x13, 0xb9, 0x68, 0x48, 0x5e, 0x00, 0x74, 0x6b, 0x78, 0x59, 0x28, 0x69, 0x03, 0xc6, 0x8c, 0x7f, 0x88, 0x0d]));
+        assert_eq!(Bitcoin::InputAnnexHash.cmr(), Cmr::from_byte_array([0x94, 0x5b, 0x14, 0x7e, 0x5f, 0x0e, 0xdb, 0x83, 0x2d, 0x62, 0x34, 0x8c, 0xae, 0xea, 0xc2, 0x24, 0x56, 0xee, 0xe9, 0x44, 0x65, 0x37, 0x6d, 0xbf, 0x59, 0x6b, 0x9d, 0x62, 0x98, 0x5b, 0x01, 0xb6]));
+        assert_eq!(Bitcoin::InputHash.cmr(), Cmr::from_byte_array([0x3a, 0xd2, 0x22, 0x31, 0xd6, 0xb9, 0xdf, 0xf6, 0xa0, 0xb4, 0xdb, 0xcf, 0xf0, 0x44, 0xe1, 0x1c, 0x08, 0x2e, 0x04, 0x68, 0x4e, 0x73, 0xce, 0x95, 0xc2, 0x05, 0xe0, 0xc4, 0x49, 0x6e, 0x5e, 0xca]));
+        assert_eq!(Bitcoin::InputOutpointsHash.cmr(), Cmr::from_byte_array([0x17, 0x59, 0xc6, 0xf4, 0x70, 0xb9, 0xab, 0xa6, 0x2a, 0x31, 0x79, 0x1e, 0xa0, 0x10, 0x56, 0xe3, 0x60, 0x8b, 0xdf, 0x22, 0xf5, 0xdd, 0x43, 0xbf, 0x7d, 0xb0, 0x0e, 0xa5, 0x82, 0x3f, 0x7c, 0xce]));
+        assert_eq!(Bitcoin::InputPrevOutpoint.cmr(), Cmr::from_byte_array([0x5d, 0x17, 0x12, 0x42, 0x09, 0xee, 0x05, 0x21, 0x24, 0xe5, 0x52, 0x38, 0xe0, 0xb6, 0xa6, 0xfe, 0x85, 0xa4, 0x86, 0x88, 0xc1, 0xe1, 0x5e, 0x61, 0x81, 0xde, 0x94, 0xf7, 0x8d, 0xb0, 0x40, 0x18]));
+        assert_eq!(Bitcoin::InputScriptsHash.cmr(), Cmr::from_byte_array([0xf1, 0x77, 0x67, 0x1d, 0x60, 0x96, 0x0e, 0x46, 0x3a, 0x9a, 0x8f, 0x7e, 0x1f, 0x52, 0x13, 0xaa, 0xba, 0x91, 0x22, 0xd2, 0xdb, 0x75, 0xfe, 0x91, 0xf8, 0xf1, 0xcf, 0x91, 0xbe, 0x00, 0x19, 0x07]));
+        assert_eq!(Bitcoin::InputScriptHash.cmr(), Cmr::from_byte_array([0x05, 0x62, 0x41, 0x2f, 0x02, 0x1d, 0xa4, 0x81, 0x9b, 0x01, 0x9c, 0x8c, 0xd8, 0x87, 0xd5, 0x30, 0x49, 0x2b, 0x9f, 0x94, 0x2c, 0x4e, 0xbf, 0x21, 0xae, 0x39, 0xed, 0x32, 0x33, 0x0d, 0x7c, 0xfe]));
+        assert_eq!(Bitcoin::InputScriptSigsHash.cmr(), Cmr::from_byte_array([0xe7, 0x29, 0xc5, 0xf5, 0x8a, 0x93, 0x89, 0x08, 0x1a, 0x5c, 0xa8, 0x45, 0xf7, 0x6c, 0xb9, 0x80, 0xf0, 0x85, 0x99, 0xce, 0xb3, 0xc7, 0xd7, 0xea, 0xe1, 0x14, 0x5b, 0x53, 0xa6, 0x0a, 0xe3, 0xd5]));
+        assert_eq!(Bitcoin::InputScriptSigHash.cmr(), Cmr::from_byte_array([0x1c, 0x7e, 0xfb, 0x37, 0xcb, 0xc4, 0xb9, 0x96, 0xd9, 0xb8, 0xc6, 0x17, 0x08, 0xe6, 0x65, 0x73, 0xce, 0x87, 0xc1, 0xf0, 0xaa, 0x05, 0x22, 0xd0, 0x65, 0xba, 0x90, 0x25, 0x05, 0x6e, 0x3f, 0x80]));
+        assert_eq!(Bitcoin::InputSequence.cmr(), Cmr::from_byte_array([0x5d, 0xd1, 0x7f, 0xe1, 0x55, 0x0f, 0x48, 0xf7, 0xba, 0xed, 0x4d, 0x06, 0x80, 0x08, 0xd4, 0xa1, 0xff, 0x98, 0xcb, 0xeb, 0xe2, 0x54, 0x1c, 0x5d, 0xc7, 0x7a, 0xc5, 0x3a, 0xd8, 0x3f, 0xa7, 0x79]));
+        assert_eq!(Bitcoin::InputSequencesHash.cmr(), Cmr::from_byte_array([0x55, 0x97, 0x3d, 0x64, 0x43, 0x45, 0x74, 0x72, 0x81, 0x37, 0x73, 0x64, 0xba, 0xd2, 0xa8, 0x0b, 0x75, 0x8f, 0x45, 0x66, 0x60, 0xc1, 0x8d, 0xe5, 0xc0, 0x1a, 0x38, 0x82, 0x07, 0x1d, 0x50, 0xe8]));
+        assert_eq!(Bitcoin::InputUtxosHash.cmr(), Cmr::from_byte_array([0xd6, 0xf9, 0x0c, 0xd1, 0x04, 0xe1, 0xa5, 0xc6, 0x1a, 0x4b, 0x50, 0x00, 0xad, 0x9a, 0xba, 0x8d, 0x43, 0x00, 0x4b, 0xf9, 0x43, 0xdf, 0x32, 0x5f, 0xa6, 0x36, 0xd1, 0xa2, 0x2b, 0xec, 0xa0, 0xcb]));
+        assert_eq!(Bitcoin::InputUtxoHash.cmr(), Cmr::from_byte_array([0x93, 0x1e, 0x4e, 0x95, 0xe0, 0xa6, 0x47, 0x60, 0x27, 0x6e, 0x91, 0xb5, 0xdc, 0x74, 0x67, 0x80, 0xd0, 0x69, 0x7d, 0x0a, 0xf5, 0xaa, 0xf5, 0xbb, 0xc8, 0x1d, 0xbe, 0xb3, 0x98, 0x59, 0x6a, 0xbb]));
+        assert_eq!(Bitcoin::InputValue.cmr(), Cmr::from_byte_array([0x7d, 0x3c, 0x3f, 0x95, 0x5b, 0x2c, 0xf0, 0xd0, 0xd1, 0x28, 0x0a, 0x1b, 0xb1, 0x20, 0x46, 0x92, 0x92, 0xd1, 0x32, 0x9c, 0x83, 0xa9, 0xc2, 0xff, 0x7e, 0x7e, 0x1e, 0xb3, 0xf6, 0x97, 0x83, 0xa3]));
+        assert_eq!(Bitcoin::InputValuesHash.cmr(), Cmr::from_byte_array([0x29, 0x83, 0x9e, 0xad, 0x0e, 0xb0, 0x3f, 0xe4, 0x65, 0x42, 0xe3, 0x6d, 0x71, 0xe9, 0xe6, 0xaf, 0xdf, 0x96, 0x93, 0x01, 0x53, 0x3d, 0x74, 0xee, 0x09, 0x9b, 0x12, 0x66, 0xa2, 0x50, 0x55, 0x2c]));
+        assert_eq!(Bitcoin::InternalKey.cmr(), Cmr::from_byte_array([0x37, 0x48, 0x36, 0x99, 0x28, 0x10, 0x02, 0x2f, 0x88, 0xe0, 0x14, 0x5b, 0xca, 0xd7, 0x7f, 0x4a, 0x84, 0x91, 0xfa, 0x80, 0x83, 0xcb, 0x51, 0xc3, 0x01, 0xfc, 0xf7, 0xa1, 0x34, 0x78, 0xc2, 0xcc]));
+        assert_eq!(Bitcoin::IsOne16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::IsOne32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::IsOne64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::IsOne8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::IsZero16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::IsZero32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::IsZero64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::IsZero8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost16_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost16_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost16_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost16_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost32_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost32_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost32_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost32_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost32_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost64_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost64_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost64_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost64_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost64_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost64_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost8_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost8_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Leftmost8_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend16_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend16_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend1_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend1_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend1_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend1_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend32_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend8_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend8_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftExtend8_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh16_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh16_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh1_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh1_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh1_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh1_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh32_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh8_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh8_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadHigh8_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow16_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow16_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow1_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow1_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow1_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow1_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow32_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow8_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow8_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftPadLow8_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftRotate16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftRotate32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftRotate64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftRotate8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftShift16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftShift32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftShift64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftShift8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftShiftWith16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftShiftWith32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftShiftWith64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LeftShiftWith8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Le16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Le32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Le64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Le8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LinearCombination1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LinearVerify1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::LockTime.cmr(), Cmr::from_byte_array([0x9a, 0xe0, 0xac, 0xc3, 0x7b, 0xc2, 0x04, 0x47, 0x79, 0xb0, 0x7c, 0x3d, 0x46, 0x02, 0xa5, 0xfd, 0xe8, 0xbc, 0x33, 0xf8, 0x79, 0xf6, 0x6b, 0x73, 0x9b, 0x10, 0xf0, 0x1a, 0xeb, 0x11, 0x54, 0xec]));
+        assert_eq!(Bitcoin::Low1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Low16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Low32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Low64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Low8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Lt16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Lt32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Lt64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Lt8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Maj1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Maj16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Maj32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Maj64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Maj8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Max16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Max32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Max64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Max8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Median16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Median32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Median64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Median8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Min16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Min32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Min64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Min8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Modulo16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Modulo32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Modulo64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Modulo8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Multiply16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Multiply32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Multiply64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Multiply8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Negate16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Negate32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Negate64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Negate8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::NumInputs.cmr(), Cmr::from_byte_array([0x5c, 0x5a, 0xc4, 0xff, 0x6d, 0xa5, 0x6c, 0xb3, 0x72, 0xb2, 0x32, 0x66, 0x6e, 0x83, 0x34, 0xb9, 0xe2, 0xcf, 0xb0, 0xdc, 0xb4, 0x18, 0xf1, 0x61, 0xbf, 0xf1, 0x49, 0xe8, 0x4e, 0xc9, 0x2c, 0x3e]));
+        assert_eq!(Bitcoin::NumOutputs.cmr(), Cmr::from_byte_array([0x98, 0xa1, 0xcc, 0xa7, 0x05, 0xdf, 0xcf, 0xaf, 0xd3, 0xa6, 0x9e, 0x9a, 0xdc, 0x05, 0xba, 0x47, 0xe1, 0xfe, 0xfa, 0x6a, 0x29, 0xf3, 0x42, 0x86, 0x20, 0x48, 0xe4, 0x96, 0x86, 0x48, 0xc3, 0xd7]));
+        assert_eq!(Bitcoin::One16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::One32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::One64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::One8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Or1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Or16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Or32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Or64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Or8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::OutpointHash.cmr(), Cmr::from_byte_array([0x3a, 0x1a, 0xe9, 0x0e, 0x16, 0x7f, 0xb4, 0x0d, 0x6e, 0x13, 0xb4, 0x51, 0xad, 0x67, 0x41, 0x0d, 0x8d, 0xd9, 0x91, 0xc8, 0x7d, 0x6a, 0x4a, 0x59, 0xcc, 0x76, 0xc6, 0x3f, 0x3b, 0x9e, 0x5e, 0x56]));
+        assert_eq!(Bitcoin::OutputsHash.cmr(), Cmr::from_byte_array([0xf2, 0xeb, 0x6d, 0x0f, 0x01, 0x8e, 0x6f, 0x15, 0xe3, 0x5b, 0xaa, 0x82, 0xe5, 0x7e, 0x14, 0xfe, 0x34, 0x37, 0x96, 0xf2, 0x19, 0x68, 0x26, 0xbe, 0xd7, 0xc7, 0x87, 0x55, 0x98, 0xd6, 0x64, 0x1d]));
+        assert_eq!(Bitcoin::OutputHash.cmr(), Cmr::from_byte_array([0x91, 0x21, 0x1f, 0xc6, 0x01, 0x1a, 0x64, 0x93, 0x00, 0xc6, 0xbe, 0xe9, 0x4f, 0xdd, 0x48, 0xa9, 0x7f, 0xa2, 0xa9, 0xb6, 0xf2, 0x84, 0xbe, 0x01, 0x5d, 0x46, 0x2d, 0x17, 0xde, 0x66, 0x4a, 0xc3]));
+        assert_eq!(Bitcoin::OutputScriptsHash.cmr(), Cmr::from_byte_array([0xff, 0x20, 0xbc, 0x43, 0x65, 0xe7, 0x17, 0x07, 0x57, 0x1c, 0x6e, 0x17, 0x38, 0xe1, 0xed, 0x32, 0x6f, 0x7c, 0x35, 0x1d, 0xe1, 0x30, 0x22, 0xae, 0xa3, 0xd6, 0x40, 0x6b, 0x8a, 0xee, 0x8e, 0x3b]));
+        assert_eq!(Bitcoin::OutputScriptHash.cmr(), Cmr::from_byte_array([0xbd, 0xfd, 0xb2, 0x31, 0xf4, 0xf1, 0xa6, 0x2c, 0x9d, 0x7b, 0x03, 0x93, 0x1e, 0x7f, 0x19, 0xa4, 0x54, 0x6a, 0xf2, 0x34, 0x75, 0x4c, 0xbf, 0x70, 0x05, 0x9f, 0xdd, 0x42, 0xbb, 0xbc, 0x41, 0x26]));
+        assert_eq!(Bitcoin::OutputValue.cmr(), Cmr::from_byte_array([0x93, 0x36, 0x43, 0xb6, 0xc5, 0xa6, 0x22, 0x0a, 0xbb, 0xca, 0x6f, 0x35, 0x09, 0xfe, 0xff, 0x6d, 0x13, 0xef, 0xa6, 0xc9, 0xfa, 0xe9, 0x59, 0x24, 0x57, 0x53, 0x64, 0xf2, 0xb1, 0x64, 0xd2, 0xbc]));
+        assert_eq!(Bitcoin::OutputValuesHash.cmr(), Cmr::from_byte_array([0x22, 0x89, 0x93, 0x79, 0x00, 0x57, 0x06, 0x6f, 0x20, 0x16, 0x97, 0x1d, 0xf5, 0x5e, 0x6f, 0x67, 0xd2, 0x52, 0xef, 0xb6, 0xda, 0xab, 0xd0, 0xfc, 0x56, 0x6a, 0x8d, 0x21, 0x56, 0xef, 0xbb, 0xfc]));
+        assert_eq!(Bitcoin::ParseLock.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::ParseSequence.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::PointVerify1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost16_1.cmr(), Cmr::from_byte_array([0x3f, 0x3c, 0x43, 0x46, 0x87, 0x17, 0x42, 0x26, 0x5e, 0x87, 0xf0, 0x01, 0xb4, 0x6d, 0xe7, 0xd1, 0x98, 0x75, 0x1b, 0x34, 0xfa, 0xa1, 0x80, 0x18, 0xde, 0x60, 0xc8, 0x46, 0x8d, 0x9b, 0x98, 0xa4]));
+        assert_eq!(Bitcoin::Rightmost16_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost16_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost16_8.cmr(), Cmr::from_byte_array([0xee, 0x76, 0x9c, 0x1c, 0xc8, 0xa3, 0xfd, 0xd1, 0x83, 0x8f, 0xc9, 0xf0, 0x49, 0x0c, 0xe7, 0x03, 0x93, 0xfd, 0x91, 0xba, 0x3c, 0xbd, 0x4a, 0xbd, 0x08, 0x64, 0x9f, 0xb9, 0xc4, 0x43, 0x11, 0xbd]));
+        assert_eq!(Bitcoin::Rightmost32_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost32_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost32_2.cmr(), Cmr::from_byte_array([0x00, 0xb8, 0x81, 0x5a, 0xd7, 0x42, 0x3d, 0xd5, 0x8c, 0xb9, 0x8b, 0xe8, 0x2c, 0xad, 0x26, 0x67, 0x5c, 0x3b, 0xf5, 0x4a, 0x0b, 0xed, 0xba, 0xde, 0x34, 0x64, 0xb4, 0xfe, 0x5a, 0x4e, 0x8c, 0xe6]));
+        assert_eq!(Bitcoin::Rightmost32_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost32_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost64_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost64_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost64_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost64_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost64_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost64_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost8_1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost8_2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Rightmost8_4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightExtend16_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightExtend16_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightExtend32_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightExtend8_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightExtend8_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightExtend8_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh16_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh16_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh1_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh1_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh1_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh1_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh32_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh8_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh8_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadHigh8_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow16_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow16_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow1_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow1_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow1_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow1_8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow32_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow8_16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow8_32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightPadLow8_64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightRotate16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightRotate32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightRotate64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightRotate8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightShift16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightShift32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightShift64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightShift8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightShiftWith16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightShiftWith32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightShiftWith64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::RightShiftWith8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::ScalarAdd.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::ScalarInvert.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::ScalarIsZero.cmr(), Cmr::from_byte_array([0xf7, 0x5e, 0xda, 0x06, 0xce, 0x6a, 0xf0, 0x9f, 0xae, 0x37, 0xdb, 0x4e, 0x62, 0x25, 0xe6, 0xa8, 0xac, 0x86, 0xa2, 0x36, 0x37, 0x62, 0x7d, 0x62, 0x64, 0x09, 0x19, 0x0f, 0xf3, 0xb3, 0x9d, 0x90]));
+        assert_eq!(Bitcoin::ScalarMultiply.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::ScalarMultiplyLambda.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::ScalarNegate.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::ScalarNormalize.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::ScalarSquare.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Scale.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::ScriptCMR.cmr(), Cmr::from_byte_array([0xa8, 0xa4, 0xa6, 0x22, 0x10, 0xb5, 0xe4, 0x95, 0x0e, 0x25, 0x34, 0x24, 0x7c, 0x74, 0x11, 0xd1, 0xc8, 0xff, 0x22, 0x86, 0x5b, 0x54, 0x56, 0xbb, 0xb2, 0x16, 0x38, 0xe9, 0x14, 0xf5, 0xe5, 0x28]));
+        assert_eq!(Bitcoin::Sha256Block.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add128.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add2.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add256.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add4.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add512.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Add8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8AddBuffer511.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Finalize.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Ctx8Init.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Sha256Iv.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::SigAllHash.cmr(), Cmr::from_byte_array([0x09, 0x78, 0xb9, 0xe5, 0x0b, 0x9e, 0x8e, 0x09, 0x8b, 0x27, 0xf2, 0xb8, 0xb5, 0x9d, 0xe5, 0x4f, 0x62, 0xba, 0x7c, 0x13, 0x33, 0xdf, 0x3b, 0xed, 0x22, 0x1e, 0x26, 0x62, 0x68, 0x05, 0xbc, 0x55]));
+        assert_eq!(Bitcoin::Some1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Some16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Some32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Some64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Some8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Subtract16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Subtract32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Subtract64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Subtract8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Swu.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::TapdataInit.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::TapleafHash.cmr(), Cmr::from_byte_array([0x0c, 0x07, 0x16, 0xfe, 0x5d, 0x97, 0x8e, 0xa8, 0xe0, 0xc7, 0x5a, 0xdc, 0x82, 0x10, 0xd6, 0x60, 0x06, 0x2e, 0x3d, 0xa0, 0x6f, 0x1a, 0x66, 0x61, 0x31, 0x79, 0x27, 0xd3, 0xb8, 0x4b, 0x50, 0x73]));
+        assert_eq!(Bitcoin::TapleafVersion.cmr(), Cmr::from_byte_array([0xe2, 0xec, 0xb1, 0xcb, 0x0e, 0xd4, 0xed, 0x93, 0x48, 0x35, 0x45, 0xfd, 0x8a, 0x62, 0xf8, 0xaa, 0x10, 0x17, 0x53, 0x49, 0xff, 0xcc, 0x5a, 0xd3, 0xde, 0x7f, 0x34, 0x84, 0xea, 0x1f, 0x10, 0x3f]));
+        assert_eq!(Bitcoin::Tappath.cmr(), Cmr::from_byte_array([0x99, 0xe8, 0x21, 0x1e, 0x8c, 0x1b, 0xe6, 0xd9, 0xca, 0x98, 0xd3, 0xd4, 0x3d, 0x91, 0x42, 0x56, 0x7e, 0x06, 0xa8, 0x40, 0x22, 0x39, 0x33, 0x03, 0xfa, 0xb0, 0xb5, 0x7d, 0x39, 0x40, 0x74, 0xe8]));
+        assert_eq!(Bitcoin::TappathHash.cmr(), Cmr::from_byte_array([0x02, 0x11, 0x54, 0x6d, 0x07, 0x78, 0xe7, 0x87, 0x14, 0x1e, 0xce, 0x65, 0xdf, 0x6c, 0xd1, 0xdb, 0x31, 0x38, 0x8f, 0xc1, 0x42, 0x19, 0x68, 0xc8, 0xcf, 0xd8, 0xd7, 0x59, 0x26, 0xdb, 0x47, 0xb3]));
+        assert_eq!(Bitcoin::TapEnvHash.cmr(), Cmr::from_byte_array([0x19, 0xd9, 0x94, 0x4c, 0x4d, 0x45, 0x7c, 0x70, 0xba, 0xbc, 0x45, 0xcc, 0xcb, 0xd5, 0x73, 0xb3, 0x9a, 0x51, 0xd0, 0xc9, 0x91, 0x15, 0xb4, 0x12, 0x78, 0x3b, 0x49, 0x00, 0x82, 0xfd, 0x0e, 0x58]));
+        assert_eq!(Bitcoin::TotalInputValue.cmr(), Cmr::from_byte_array([0x81, 0x28, 0x7a, 0x15, 0x89, 0xdd, 0xc2, 0x17, 0x99, 0x26, 0xb7, 0x06, 0x5e, 0x9b, 0x26, 0x77, 0xb7, 0xfb, 0x09, 0x9b, 0x95, 0xf9, 0x47, 0xa7, 0xdd, 0x59, 0x0c, 0xdd, 0x4c, 0xcf, 0x4a, 0x56]));
+        assert_eq!(Bitcoin::TotalOutputValue.cmr(), Cmr::from_byte_array([0xba, 0x03, 0x2f, 0x3e, 0x62, 0xf8, 0xfc, 0xb0, 0x4b, 0x04, 0x29, 0xa2, 0x53, 0xb5, 0xec, 0x57, 0xe4, 0xc8, 0x7a, 0xe2, 0xe9, 0x51, 0xe1, 0x45, 0xd7, 0x65, 0x0e, 0x7f, 0x0c, 0x63, 0xe5, 0x55]));
+        assert_eq!(Bitcoin::TransactionId.cmr(), Cmr::from_byte_array([0x5c, 0x49, 0xea, 0x98, 0x6b, 0x32, 0x8b, 0xe2, 0xa4, 0xe0, 0xb3, 0x15, 0xb6, 0xb3, 0xfe, 0xf2, 0x3c, 0x1f, 0x68, 0x56, 0xbb, 0xc3, 0xb0, 0x56, 0xc9, 0x9c, 0xf5, 0x9f, 0xbd, 0x54, 0x6e, 0x65]));
+        assert_eq!(Bitcoin::TxHash.cmr(), Cmr::from_byte_array([0x54, 0xe5, 0x3c, 0x99, 0x93, 0xab, 0xd5, 0x5d, 0x1f, 0x85, 0x23, 0xd2, 0xbb, 0x21, 0x7b, 0x32, 0xe6, 0xfe, 0x86, 0x1f, 0x84, 0xc9, 0x86, 0xb7, 0xee, 0x8b, 0xdc, 0x68, 0x81, 0x06, 0x87, 0x4a]));
+        assert_eq!(Bitcoin::TxIsFinal.cmr(), Cmr::from_byte_array([0x7b, 0x0e, 0x4f, 0x4c, 0xa8, 0xe5, 0xaf, 0x61, 0xa1, 0xd3, 0x45, 0x4e, 0x11, 0xef, 0x9a, 0xb6, 0x88, 0x70, 0x61, 0x21, 0x1c, 0x00, 0x90, 0xeb, 0xa9, 0x55, 0x3d, 0xa2, 0xe4, 0x5d, 0x84, 0x73]));
+        assert_eq!(Bitcoin::TxLockDistance.cmr(), Cmr::from_byte_array([0xb6, 0xfb, 0xaa, 0xc2, 0x10, 0xa3, 0x06, 0xbe, 0x8b, 0x58, 0xd0, 0xd7, 0xb1, 0x56, 0x3f, 0x62, 0x23, 0x36, 0xd2, 0xae, 0xb5, 0x6c, 0x39, 0x3d, 0x27, 0x64, 0x45, 0xa9, 0xa2, 0x2c, 0xc4, 0xa7]));
+        assert_eq!(Bitcoin::TxLockDuration.cmr(), Cmr::from_byte_array([0x53, 0x57, 0x28, 0x18, 0xe7, 0xe5, 0xb9, 0x8f, 0x96, 0x8c, 0x9d, 0xa7, 0xdf, 0x50, 0x90, 0xd9, 0x82, 0x6f, 0x9b, 0xcf, 0x84, 0xb6, 0x36, 0x39, 0x5e, 0xea, 0x32, 0x1b, 0x69, 0x09, 0xec, 0xe9]));
+        assert_eq!(Bitcoin::TxLockHeight.cmr(), Cmr::from_byte_array([0x44, 0x9f, 0x61, 0xdf, 0x1a, 0x7b, 0xad, 0x8d, 0x9e, 0x0a, 0x96, 0x67, 0x14, 0x22, 0x7e, 0x57, 0x10, 0x07, 0xf9, 0x3c, 0x51, 0x7b, 0x80, 0x5d, 0x61, 0x65, 0x10, 0xe8, 0xff, 0x62, 0x17, 0x2b]));
+        assert_eq!(Bitcoin::TxLockTime.cmr(), Cmr::from_byte_array([0x31, 0xdf, 0x36, 0x3f, 0x17, 0xb2, 0xcf, 0xc9, 0x7a, 0x1f, 0x93, 0x72, 0xc1, 0x4a, 0x32, 0x58, 0x64, 0xd7, 0xcb, 0x13, 0xaa, 0x8d, 0x52, 0x15, 0xfb, 0x25, 0x3d, 0x33, 0x10, 0x91, 0x77, 0x62]));
+        assert_eq!(Bitcoin::Verify.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Version.cmr(), Cmr::from_byte_array([0x83, 0x73, 0x58, 0x64, 0x00, 0xb6, 0x79, 0x0b, 0x46, 0xab, 0x04, 0x10, 0x52, 0x3c, 0xf0, 0x1e, 0xb7, 0x4d, 0x10, 0xfa, 0xf4, 0x8a, 0x3a, 0xcc, 0x86, 0xc4, 0xc5, 0x1d, 0x06, 0xa5, 0x2c, 0x49]));
+        assert_eq!(Bitcoin::Xor1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Xor16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Xor32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Xor64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::Xor8.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::XorXor1.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::XorXor16.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::XorXor32.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::XorXor64.cmr(), Cmr::from_byte_array([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]));
+        assert_eq!(Bitcoin::XorXor8.cmr(), Cmr::from_byte_array([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]));
+    }
+
+    #[test]
+    fn cost_matches_spec() {
+        assert_eq!(Bitcoin::Add16.cost(), Cost::from_milliweight(80));
+        assert_eq!(Bitcoin::AnnexHash.cost(), Cost::from_milliweight(1491));
+        assert_eq!(Bitcoin::Bip0340Verify.cost(), Cost::from_milliweight(49421));
+        assert_eq!(Bitcoin::CheckSigVerify.cost(), Cost::from_milliweight(50000));
+        assert_eq!(Bitcoin::Sha256Block.cost(), Cost::from_milliweight(765));
+        assert_eq!(Bitcoin::Verify.cost(), Cost::from_milliweight(44));
+        assert_eq!(Bitcoin::FullLeftShift64_32.cost(), Cost::from_milliweight(73));
+        assert_eq!(Bitcoin::ScalarMultiply.cost(), Cost::from_milliweight(793));
+    }
+}

From 85d37fce51cfa3c0f15f636c90d7a821e42d08ac Mon Sep 17 00:00:00 2001
From: Byron Hambly <bhambly@blockstream.com>
Date: Mon, 7 Sep 2026 14:40:14 +0200
Subject: [PATCH 13/16] analysis: split Cost padding API into size and
 chain-specific bytes

Add Cost::get_padding_size, which returns the chain-agnostic byte length
of the witness stack item required to bring a program cost within budget.
The required length depends only on the item's serialized size, not its
content, and is the same for Bitcoin and Elements.

Add Cost::get_padding_bytes, which returns the chain-specific bytes that
fill that length:
- Bitcoin (cfg bitcoin, not elements): a plain all-zero item. A leading
  0x50 byte would be misread as an annex, so Bitcoin must not use one.
- Elements (cfg elements): an annex item: [0x50] followed by zeros.

Deprecate Cost::get_padding (Elements annex form), which now delegates
to get_padding_bytes. Make get_budget and is_budget_valid chain-agnostic
by computing the witness-stack serialized length with explicit CompactSize
math instead of the elements consensus encoder.
---
 src/analysis.rs | 208 ++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 168 insertions(+), 40 deletions(-)

diff --git a/src/analysis.rs b/src/analysis.rs
index fe5fed84..c286bcc2 100644
--- a/src/analysis.rs
+++ b/src/analysis.rs
@@ -4,12 +4,8 @@ use crate::jet::Jet;
 use std::{cmp, fmt};
 
 use crate::value::Word;
-#[cfg(feature = "elements")]
-use elements::encode::Encodable;
 #[cfg(feature = "serde")]
 use serde::Serialize;
-#[cfg(feature = "elements")]
-use std::{convert::TryFrom, io};
 
 /// Copy of [`bitcoin::Weight`] that uses [`u32`] instead of [`u64`].
 ///
@@ -115,78 +111,159 @@ impl Cost {
         self <= Self::CONSENSUS_MAX
     }
 
-    /// Return the budget of the given script witness of a transaction output.
+    /// Return the budget of the given script witness of a transaction input.
     ///
-    /// The script witness is passed as `&Vec<Vec<u8>>` in order to use
-    /// the consensus encoding implemented for this type.
-    #[cfg(feature = "elements")]
-    fn get_budget(script_witness: &Vec<Vec<u8>>) -> U32Weight {
-        let mut sink = io::sink();
-        let witness_stack_serialized_len = script_witness
-            .consensus_encode(&mut sink)
-            .expect("writing to sink never fails");
-        let budget = u32::try_from(witness_stack_serialized_len)
-            .expect("Serialized witness stack must be shorter than 2^32 elements")
-            .saturating_add(50);
+    /// The budget is the serialized size of the witness stack (in weight
+    /// units) plus the 50 free weight units of validation weight.
+    ///
+    /// The witness stack is passed as `&[Vec<u8>]`, where each inner `Vec<u8>`
+    /// is one stack item. Both Bitcoin and Elements serialize the witness stack
+    /// identically: a CompactSize item count, followed by each item as a
+    /// CompactSize length prefix and its bytes. The math is therefore
+    /// chain-agnostic, and this method is available under the `bitcoin` feature
+    /// (which `elements` implies) so it can be shared by both.
+    #[cfg(feature = "bitcoin")]
+    fn get_budget(script_witness: &[Vec<u8>]) -> U32Weight {
+        // Serialized witness stack size, in bytes.
+        let mut serialized_len = compact_size_len(script_witness.len());
+        for item in script_witness {
+            serialized_len += compact_size_len(item.len()) + item.len();
+        }
+        let budget = serialized_len.saturating_add(50);
+        let budget =
+            u32::try_from(budget).expect("Serialized witness stack must be shorter than 2^32");
         U32Weight(budget)
     }
 
     /// Return whether the cost is within the budget of
     /// the given script witness of a transaction input.
     ///
-    /// The script witness is passed as `&Vec<Vec<u8>>` in order to use
-    /// the consensus encoding implemented for this type.
-    #[cfg(feature = "elements")]
-    pub fn is_budget_valid(self, script_witness: &Vec<Vec<u8>>) -> bool {
+    /// The script witness is passed as `&[Vec<u8>]`, where each inner `Vec<u8>`
+    /// is one witness stack item.
+    #[cfg(feature = "bitcoin")]
+    pub fn is_budget_valid(self, script_witness: &[Vec<u8>]) -> bool {
         let budget = Self::get_budget(script_witness);
         self.0 <= budget.0.saturating_mul(1000)
     }
 
-    /// Return the annex bytes that are required as padding
+    /// Return the length, in bytes, of the padding witness stack item required
     /// so the transaction input has enough budget to cover the cost.
     ///
-    /// The first annex byte is 0x50, as defined in BIP 341.
-    /// The following padding bytes are 0x00.
-    #[cfg(feature = "elements")]
-    pub fn get_padding(self, script_witness: &Vec<Vec<u8>>) -> Option<Vec<u8>> {
+    /// The returned length is chain-agnostic: adding a stack item of length `L`
+    /// increases the serialized witness-stack budget by `CompactSize(L) + L`,
+    /// which depends only on the item's length, not its content. Bitcoin and
+    /// Elements therefore require the same padding *length*; only the bytes
+    /// that fill it differ (see [`Self::get_padding_bytes`]).
+    ///
+    /// The script witness is passed as `&[Vec<u8>]`, where each inner `Vec<u8>`
+    /// is one witness stack item (the padding item is *not* yet included).
+    ///
+    /// Returns `None` if no padding is required, i.e. the cost already fits
+    /// within the budget of the given witness stack.
+    #[cfg(feature = "bitcoin")]
+    pub fn get_padding_size(self, script_witness: &[Vec<u8>]) -> Option<usize> {
         let weight = U32Weight::from(self);
         let budget = Self::get_budget(script_witness);
         if weight <= budget {
             return None;
         }
 
-        // Adding the annex to the witness stack increases the serialized size by:
+        // Adding the padding item to the witness stack increases the serialized
+        // size by:
         //
-        // 1. CompactSize(annex_len): the length prefix of the annex item
-        // 2. annex_len: the annex bytes themselves (0x50 tag + zero padding)
+        // 1. CompactSize(item_len): the length prefix of the padding item
+        // 2. item_len: the padding item bytes themselves
         //
         // CompactSize uses 1 byte for values <= 252, 3 bytes for <= 65535,
         // and 5 bytes for larger values. The overhead subtracted must account
-        // for the actual CompactSize encoding length of the resulting annex.
+        // for the actual CompactSize encoding length of the resulting item.
         let deficit = (weight - budget).0 as usize; // cast safety: 32-bit machine or higher
 
-        // overhead = compact_size_len + 1 (for 0x50 tag)
+        // overhead = compact_size_len + 1 (for the 0x50 annex tag, when an
+        // Elements annex is used; for a plain Bitcoin zero item there is no
+        // tag, but the deficit accounting is identical because what matters is
+        // only the total serialized item length).
         let padding_len = match deficit {
-            // annex_len <= 252, compact_size uses 1 byte, overhead = 2
+            // item_len <= 252, compact_size uses 1 byte, overhead = 2
             0..=253 => deficit.saturating_sub(2),
-            // Boundary region: annex must be >= 253 bytes (3-byte compact_size),
+            // Boundary region: item must be >= 253 bytes (3-byte compact_size),
             // but deficit - 4 < 252. Use minimum padding for 3-byte encoding.
             254..=255 => 252,
-            // annex_len in 253..=65535, compact_size uses 3 bytes, overhead = 4
+            // item_len in 253..=65535, compact_size uses 3 bytes, overhead = 4
             256..=65538 => deficit - 4,
             // Boundary region for 5-byte compact_size encoding.
             65539..=65540 => 65535,
-            // annex_len >= 65536, compact_size uses 5 bytes, overhead = 6
+            // item_len >= 65536, compact_size uses 5 bytes, overhead = 6
             _ => deficit - 6,
             // Note: the 9-byte compact_size boundary (deficit > 4_294_967_300)
             // is unreachable because Cost uses u32 milliweight, limiting the
             // maximum deficit to ~4_294_968 weight units.
         };
-        let annex_bytes: Vec<u8> = std::iter::once(0x50)
-            .chain(std::iter::repeat(0x00).take(padding_len))
-            .collect();
 
-        Some(annex_bytes)
+        Some(padding_len + 1)
+    }
+
+    /// Return the bytes of the padding witness stack item required so the
+    /// transaction input has enough budget to cover the cost.
+    ///
+    /// This is the Bitcoin-specific form: the padding is a single all-zero
+    /// witness stack item. (Bitcoin has no annex, so the padding must be a
+    /// regular stack item; a leading `0x50` byte would be misread as an annex.)
+    #[cfg(all(feature = "bitcoin", not(feature = "elements")))]
+    pub fn get_padding_bytes(self, script_witness: &[Vec<u8>]) -> Option<Vec<u8>> {
+        self.get_padding_size(script_witness)
+            .map(|len| vec![0x00; len])
+    }
+
+    /// Return the bytes of the padding witness stack item required so the
+    /// transaction input has enough budget to cover the cost.
+    ///
+    /// This is the Elements-specific form: on Elements, padding is an annex,
+    /// which is a single witness stack item whose first byte is the `0x50`
+    /// annex tag (BIP 341) followed by zero bytes.
+    ///
+    /// To build an annex of total length `L` (as returned by
+    /// [`Self::get_padding_size`]) this returns `[0x50]` followed by `L - 1`
+    /// zero bytes. Callers targeting non-Liquid Elements (where annexes are
+    /// unavailable) should instead use the length and build their own all-zero
+    /// item, as Bitcoin does.
+    #[cfg(feature = "elements")]
+    pub fn get_padding_bytes(self, script_witness: &[Vec<u8>]) -> Option<Vec<u8>> {
+        self.get_padding_size(script_witness).map(|len| {
+            let mut annex = Vec::with_capacity(len);
+            annex.push(0x50);
+            annex.extend(std::iter::repeat(0x00).take(len.saturating_sub(1)));
+            annex
+        })
+    }
+
+    /// Return the annex bytes that are required as padding so the transaction
+    /// input has enough budget to cover the cost.
+    ///
+    /// The first annex byte is `0x50`, as defined in BIP 341.
+    /// The following padding bytes are `0x00`.
+    #[cfg(feature = "elements")]
+    #[deprecated(
+        since = "0.7.1",
+        note = "use `get_padding_size` (chain-agnostic item length) or `get_padding_bytes` (chain-specific bytes) instead"
+    )]
+    pub fn get_padding(self, script_witness: &[Vec<u8>]) -> Option<Vec<u8>> {
+        self.get_padding_bytes(script_witness)
+    }
+}
+
+/// The length, in bytes, of the CompactSize (VarInt) encoding of `value`.
+///
+/// CompactSize uses 1 byte for values <= 252, 3 bytes for <= 65535, 5 bytes
+/// for <= 2^32-1, and 9 bytes otherwise. `Cost` uses `u32` milliweight, so
+/// serialized lengths can never exceed the 5-byte encoding range.
+#[cfg(feature = "bitcoin")]
+fn compact_size_len(value: usize) -> usize {
+    match value {
+        0..=252 => 1,
+        253..=65_535 => 3,
+        65_536..=4_294_967_295 => 5,
+        _ => 9,
     }
 }
 
@@ -439,6 +516,7 @@ mod tests {
 
     #[test]
     #[cfg(feature = "elements")]
+    #[allow(deprecated)]
     fn test_get_padding() {
         // The budget of the empty witness stack is 51 WU:
         //
@@ -486,16 +564,31 @@ mod tests {
         ];
 
         for (cost, mut witness, maybe_padding) in test_vectors {
+            let size = cost.get_padding_size(&witness);
             match maybe_padding {
                 None => {
                     assert!(cost.is_budget_valid(&witness));
+                    assert_eq!(size, None);
+                    assert!(cost.get_padding_bytes(&witness).is_none());
+                    // deprecated alias still works and agrees
                     assert!(cost.get_padding(&witness).is_none());
                 }
                 Some(expected_annex_len) => {
                     assert!(!cost.is_budget_valid(&witness));
 
-                    let annex_bytes = cost.get_padding(&witness).expect("not enough budget");
-                    assert_eq!(expected_annex_len, annex_bytes.len());
+                    // The chain-agnostic size is the total item length, which for
+                    // the Elements annex equals 0x50 tag + zero padding bytes.
+                    let size = size.expect("not enough budget");
+                    assert_eq!(expected_annex_len, size);
+
+                    let annex_bytes = cost.get_padding_bytes(&witness).expect("not enough budget");
+                    assert_eq!(size, annex_bytes.len());
+                    assert_eq!(annex_bytes[0], 0x50);
+                    assert!(annex_bytes[1..].iter().all(|&b| b == 0x00));
+
+                    // The deprecated alias agrees with get_padding_bytes.
+                    assert_eq!(cost.get_padding(&witness).unwrap(), annex_bytes);
+
                     witness.extend(std::iter::once(annex_bytes));
                     assert!(cost.is_budget_valid(&witness));
 
@@ -505,4 +598,39 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    #[cfg(all(feature = "bitcoin", not(feature = "elements")))]
+    fn test_get_padding_bitcoin() {
+        // Empty witness stack budget is 51 WU: 50 free weight + 1 length byte.
+        let empty = 51_000;
+
+        let test_vectors = vec![
+            (Cost::from_milliweight(empty + 2_001), vec![], 2usize),
+            (
+                Cost::from_milliweight(8_045_103),
+                vec![vec![], vec![0; 497], vec![0; 32], vec![0; 33]],
+                7_424usize,
+            ),
+        ];
+
+        for (cost, mut witness, expected_len) in test_vectors {
+            assert!(!cost.is_budget_valid(&witness));
+
+            let size = cost.get_padding_size(&witness).expect("not enough budget");
+            assert_eq!(expected_len, size);
+
+            // Bitcoin padding is a plain all-zero witness stack item: no annex
+            // tag, and no 0x50-leading byte (which would be misread as an annex).
+            let padding = cost.get_padding_bytes(&witness).expect("not enough budget");
+            assert_eq!(size, padding.len());
+            assert!(padding.iter().all(|&b| b == 0x00));
+
+            witness.push(padding);
+            assert!(cost.is_budget_valid(&witness));
+
+            witness.pop();
+            assert!(!cost.is_budget_valid(&witness), "Padding must be minimal");
+        }
+    }
 }

From 3cf464ac2aa44c6c5d45d46d2db810c5cb96ea55 Mon Sep 17 00:00:00 2001
From: Byron Hambly <bhambly@blockstream.com>
Date: Mon, 7 Sep 2026 14:40:14 +0200
Subject: [PATCH 14/16] bitcoin jets: implement c_jet_ptr for pure/core jets

Implement Bitcoin::c_jet_ptr for the jets that share C wrappers in
jets_wrapper (sha256 family, all_8, eq_256, verify). These wrappers
ignore the environment argument and pass null, so they work for the ()
CJetEnvironment used by the Bitcoin backend.

Before this change, c_jet_ptr was unimplemented!() for all Bitcoin jets.
RedeemNode::prune() could not execute Bitcoin programs, so it could not
rewrite dead case branches into assertl/assertr. Bitcoin spends therefore
could not produce the pruned program required by the interpreter's
CHECK_EXEC/CHECK_CASE anti-DOS rules.

Jets that require a real transaction environment are left with an
explicit unimplemented!() message until the bitcoin env wiring is done.
---
 src/jet/init/bitcoin.rs | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/jet/init/bitcoin.rs b/src/jet/init/bitcoin.rs
index 99ff5270..d27e1af6 100644
--- a/src/jet/init/bitcoin.rs
+++ b/src/jet/init/bitcoin.rs
@@ -8152,7 +8152,30 @@ impl str::FromStr for Bitcoin {
 }
 
 pub(crate) fn c_jet_ptr(jet: &Bitcoin) -> fn(&mut CFrameItem, CFrameItem, &()) -> bool {
-        unimplemented!("Bitcoin jets have not yet been implemented.")
+    match jet {
+        Bitcoin::All8 => simplicity_sys::c_jets::jets_wrapper::all_8,
+        Bitcoin::Eq256 => simplicity_sys::c_jets::jets_wrapper::eq_256,
+        Bitcoin::Sha256Ctx8Add1 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_1,
+        Bitcoin::Sha256Ctx8Add2 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_2,
+        Bitcoin::Sha256Ctx8Add4 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_4,
+        Bitcoin::Sha256Ctx8Add8 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_8,
+        Bitcoin::Sha256Ctx8Add16 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_16,
+        Bitcoin::Sha256Ctx8Add32 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_32,
+        Bitcoin::Sha256Ctx8Add64 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_64,
+        Bitcoin::Sha256Ctx8Add128 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_128,
+        Bitcoin::Sha256Ctx8Add256 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_256,
+        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::Sha256Block => simplicity_sys::c_jets::jets_wrapper::sha_256_block,
+        Bitcoin::Verify => simplicity_sys::c_jets::jets_wrapper::verify,
+        // Fallback for Jets that have not yet been wired up to their C
+        // implementations. This covers the tx-context / crypto jets whose C
+        // functions need a real transaction environment (not the `&()` this
+        // build passes); those cannot be executed by the Rust Bit Machine yet.
+        _ => unimplemented!("Bitcoin jet {:?} has no wired C implementation in this build", jet),
+    }
 }
 
 

From 064a63ac2f5abffb5a360933019342c88691d94f Mon Sep 17 00:00:00 2001
From: Byron Hambly <bhambly@blockstream.com>
Date: Mon, 7 Sep 2026 14:40:14 +0200
Subject: [PATCH 15/16] bitcoin jets: wire real tx environment and env-context
 jets

Change the Bitcoin JetEnvironment so CJetEnvironment is the real bitcoin
CTxEnv (not ()), returned by c_jet_env(). This allows the Rust BitMachine
to execute tx-context jets against the C interpreter's live transaction
environment, which RedeemNode::prune() requires to rewrite dead case
branches into asserts.

Add FFI declarations and safe wrappers in simplicity-sys c_env/bitcoin.rs
for: sig_all_hash, check_lock_height, check_lock_distance,
check_lock_duration, current_index, num_inputs, tx_hash, tap_env_hash.
These match the rustsimplicity_0_8_bitcoin_* symbols in bitcoinJets.c.

Implement c_jet_ptr for these jets and bip_0340_verify (which is env-free
and maps to jets_wrapper). Remaining jets are still unimplemented and fail
loudly.

Add tests: c_jet_env_is_the_tx_env, env_jets_execute_with_real_environment,
check_lock_height_executes_against_env, bip_0340_verify_ptr_resolves.
---
 simplicity-sys/src/c_jets/c_env/bitcoin.rs |  61 ++++++++++
 src/jet/bitcoin/mod.rs                     |   7 +-
 src/jet/bitcoin/tests.rs                   | 135 +++++++++++++++++++++
 src/jet/init/bitcoin.rs                    |  25 +++-
 4 files changed, 222 insertions(+), 6 deletions(-)
 create mode 100644 src/jet/bitcoin/tests.rs

diff --git a/simplicity-sys/src/c_jets/c_env/bitcoin.rs b/simplicity-sys/src/c_jets/c_env/bitcoin.rs
index b1517268..3467d5df 100644
--- a/simplicity-sys/src/c_jets/c_env/bitcoin.rs
+++ b/simplicity-sys/src/c_jets/c_env/bitcoin.rs
@@ -2,6 +2,7 @@
 
 use hashes::sha256;
 
+use crate::c_jets::frame_ffi::CFrameItem;
 use crate::ffi::sha256::CSha256Midstate;
 use crate::ffi::{c_size_t, c_uchar, c_uint, c_uint_fast32_t};
 
@@ -108,6 +109,39 @@ extern "C" {
     pub fn simplicity_mallocTapEnv(rawEnv: *const CRawTapEnv) -> *mut CTapEnv;
     #[link_name = "rustsimplicity_0_8_bitcoin_mallocTransaction"]
     pub fn simplicity_mallocTransaction(rawTx: *const CRawTransaction) -> *mut CTransaction;
+
+    // Bitcoin jets whose C implementations read the transaction environment.
+    // Each has signature `bool f(frameItem* dst, frameItem src, const txEnv* env)`
+    // (note `src` is passed *by value*, matching the C definitions in bitcoinJets.c).
+    #[link_name = "rustsimplicity_0_8_bitcoin_sig_all_hash"]
+    pub fn bitcoin_sig_all_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_check_lock_height"]
+    pub fn bitcoin_check_lock_height(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_check_lock_distance"]
+    pub fn bitcoin_check_lock_distance(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_check_lock_duration"]
+    pub fn bitcoin_check_lock_duration(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_current_index"]
+    pub fn bitcoin_current_index(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv)
+        -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_num_inputs"]
+    pub fn bitcoin_num_inputs(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tx_hash"]
+    pub fn bitcoin_tx_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tap_env_hash"]
+    pub fn bitcoin_tap_env_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
 }
 
 impl CTxEnv {
@@ -136,6 +170,33 @@ impl CRawBuffer {
     }
 }
 
+// Safe wrappers around the bitcoin environment jets above. These expose a
+// Rust-safe signature (`&mut CFrameItem`, `&CTxEnv`) that can be used directly
+// as a `JetEnvironment::c_jet_ptr` function pointer, mirroring how the
+// elements backend exposes its jets via the `jets_wrapper` module. We cannot
+// hand out the raw `extern "C"` functions as fn pointers because `c_jet_ptr`
+// returns a safe (non-extern) function pointer.
+macro_rules! bitcoin_env_jet_wrapper {
+    ($name:ident, $ffi:ident) => {
+        pub fn $name(dst: &mut CFrameItem, src: CFrameItem, env: &CTxEnv) -> bool {
+            // SAFETY: we pass valid references through as pointers to a C
+            // function that treats them as borrowed (`frameItem* dst`,
+            // `const txEnv* env`) and `src` is forwarded by value exactly as
+            // the C `frameItem src` parameter expects.
+            unsafe { $ffi(dst, src, env) }
+        }
+    };
+}
+
+bitcoin_env_jet_wrapper!(sig_all_hash, bitcoin_sig_all_hash);
+bitcoin_env_jet_wrapper!(check_lock_height, bitcoin_check_lock_height);
+bitcoin_env_jet_wrapper!(check_lock_distance, bitcoin_check_lock_distance);
+bitcoin_env_jet_wrapper!(check_lock_duration, bitcoin_check_lock_duration);
+bitcoin_env_jet_wrapper!(current_index, bitcoin_current_index);
+bitcoin_env_jet_wrapper!(num_inputs, bitcoin_num_inputs);
+bitcoin_env_jet_wrapper!(tx_hash, bitcoin_tx_hash);
+bitcoin_env_jet_wrapper!(tap_env_hash, bitcoin_tap_env_hash);
+
 // Will uncomment in a later commit; need to update libsimplicity first.
 #[cfg(test)]
 mod tests {
diff --git a/src/jet/bitcoin/mod.rs b/src/jet/bitcoin/mod.rs
index 61b56565..01334fd9 100644
--- a/src/jet/bitcoin/mod.rs
+++ b/src/jet/bitcoin/mod.rs
@@ -2,19 +2,22 @@
 
 mod c_env;
 mod environment;
+#[cfg(test)]
+mod tests;
 
 pub use environment::BitcoinEnv;
 
 use super::init::bitcoin::Bitcoin;
 use super::JetEnvironment;
+use simplicity_sys::c_jets::c_env::bitcoin::CTxEnv;
 use simplicity_sys::c_jets::frame_ffi::CFrameItem;
 
 impl<T: core::borrow::Borrow<bitcoin::Transaction>> JetEnvironment for BitcoinEnv<T> {
     type Jet = Bitcoin;
-    type CJetEnvironment = ();
+    type CJetEnvironment = CTxEnv;
 
     fn c_jet_env(&self) -> &Self::CJetEnvironment {
-        &()
+        self.c_tx_env()
     }
 
     fn c_jet_ptr(
diff --git a/src/jet/bitcoin/tests.rs b/src/jet/bitcoin/tests.rs
new file mode 100644
index 00000000..e8dc11b3
--- /dev/null
+++ b/src/jet/bitcoin/tests.rs
@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: CC0-1.0
+
+//! Tests that the Bitcoin backend actually executes (and prunes) tx-context /
+//! crypto jets through the C implementations, using a *real* transaction
+//! environment (`c_jet_env` returns the live `CTxEnv`, not the unit type).
+
+use std::sync::Arc;
+
+use bitcoin::taproot::ControlBlock;
+
+use crate::jet::Bitcoin;
+use crate::jet::BitcoinEnv;
+use crate::node::{ConstructNode, CoreConstructible as _};
+use crate::types::Context;
+use crate::{BitMachine, Cmr, Value};
+
+type Node<'brand> = Arc<ConstructNode<'brand>>;
+
+/// A dummy but *structurally valid* spending context: one input (index 0), one
+/// output, matching prevout utxo and a valid 33-byte control block. Building a
+/// `BitcoinEnv` computes the sighash-all and tap-env-hash eagerly in C, so this
+/// must not trip any C assertion.
+fn dummy_env() -> BitcoinEnv<bitcoin::Transaction> {
+    let tx = bitcoin::Transaction {
+        version: bitcoin::transaction::Version(2),
+        lock_time: bitcoin::absolute::LockTime::ZERO,
+        input: vec![bitcoin::TxIn {
+            previous_output: bitcoin::OutPoint::null(),
+            script_sig: bitcoin::ScriptBuf::new(),
+            sequence: bitcoin::Sequence::MAX,
+            witness: bitcoin::Witness::new(),
+        }],
+        output: vec![bitcoin::TxOut {
+            value: bitcoin::Amount::from_sat(0),
+            script_pubkey: bitcoin::ScriptBuf::new(),
+        }],
+    };
+    let utxo = bitcoin::TxOut {
+        value: bitcoin::Amount::from_sat(0),
+        script_pubkey: bitcoin::ScriptBuf::new(),
+    };
+    let cmr = Cmr::from_byte_array([0u8; 32]);
+    let ctrl = ControlBlock::decode(&[
+        0xc0, 0x50, 0x92, 0x9b, 0x74, 0xc1, 0xa0, 0x49, 0x54, 0xb7, 0x8b, 0x4b, 0x60, 0x35, 0xe9,
+        0x7a, 0x5e, 0x07, 0x8a, 0x5a, 0x0f, 0x28, 0xec, 0x96, 0xd5, 0x47, 0xbf, 0xee, 0x9a, 0xce,
+        0x80, 0x3a, 0xc0,
+    ])
+    .expect("control block");
+    BitcoinEnv::new(tx, &[utxo], 0, cmr, ctrl)
+}
+
+/// Run a single-jet program (unit source) and return its output value.
+fn run_jet(jet: &Bitcoin) -> Value {
+    Context::with_context(|ctx| {
+        let prog = Node::jet(&ctx, jet);
+        let env = dummy_env();
+        BitMachine::test_exec(prog, &env).expect("bit machine execution")
+    })
+}
+
+/// `c_jet_env` must hand back the live transaction environment, not `()`.
+#[test]
+fn c_jet_env_is_the_tx_env() {
+    let env = dummy_env();
+    // Type is enforced at compile time: the trait method returns &CTxEnv.
+    // We also confirm it points at the same struct the env exposes.
+    let env_jet: &simplicity_sys::c_jets::c_env::bitcoin::CTxEnv =
+        <BitcoinEnv<bitcoin::Transaction> as crate::jet::JetEnvironment>::c_jet_env(&env);
+    assert_eq!(
+        std::ptr::eq(env_jet, env.c_tx_env()),
+        true,
+        "c_jet_env should return the env's own CTxEnv"
+    );
+}
+
+/// Every wired bitcoin env jet must yield a real C function pointer (i.e.
+/// `c_jet_ptr` must not panic via `unimplemented!`) AND must execute
+/// successfully against a live environment.
+#[test]
+fn env_jets_execute_with_real_environment() {
+    // current_index (ONE -> 2^32): index of the input under scrutiny (0).
+    assert_eq!(run_jet(&Bitcoin::CurrentIndex), Value::u32(0));
+    // num_inputs (ONE -> 2^32): number of inputs (1).
+    assert_eq!(run_jet(&Bitcoin::NumInputs), Value::u32(1));
+
+    // tx_hash / tap_env_hash / sig_all_hash are ONE -> 2^256; just make sure
+    // they execute (their C impls dereference the live txEnv, so a wrong/null
+    // env would crash rather than return Ok).
+    for jet in [Bitcoin::TxHash, Bitcoin::TapEnvHash, Bitcoin::SigAllHash] {
+        let out = run_jet(&jet);
+        assert_eq!(out.ty().to_string(), "2^256", "{jet:?} output type");
+    }
+}
+
+/// bip_0340_verify is env-free on the bitcoin backend (C lives in the shared
+/// jets-secp256k1.c); make sure its pointer resolves and it does not panic.
+#[test]
+fn bip_0340_verify_ptr_resolves() {
+    let ptr = crate::jet::init::bitcoin::c_jet_ptr(&Bitcoin::Bip0340Verify);
+    let ptr2 = crate::jet::init::bitcoin::c_jet_ptr(&Bitcoin::SigAllHash);
+    let ptr3 = crate::jet::init::bitcoin::c_jet_ptr(&Bitcoin::CheckLockHeight);
+    // Unwired jets still panic here; these must not.
+    let _ = (ptr, ptr2, ptr3);
+}
+
+/// `check_lock_height` reads a 32-bit source and returns unit iff that height
+/// is <= the transaction's lock height. Feed an in-range and an out-of-range
+/// value and confirm the C jet consults the live environment.
+#[test]
+fn check_lock_height_executes_against_env() {
+    use crate::node::SimpleFinalizer;
+
+    let res_for = |x: u32| {
+        Context::with_context(|ctx| {
+            let prog = Node::jet(&ctx, &Bitcoin::CheckLockHeight); // 2^32 -> 1
+            let prog = prog
+                .finalize_types_non_program()
+                .expect("finalizing types")
+                .finalize(&mut SimpleFinalizer::new(None.into_iter()))
+                .expect("finalizing");
+            let env = dummy_env(); // lock_time = 0 => lock height 0
+            let mut mac = BitMachine::for_program(&prog).expect("program bounds");
+            mac.input(&Value::u32(x)).expect("input");
+            mac.exec(&prog, &env)
+        })
+    };
+
+    // 0 <= 0 -> Ok (unit), C returns true.
+    assert_eq!(res_for(0).expect("should satisfy lock"), Value::unit());
+    // 5 <= 0 is false -> C returns false -> JetFailed.
+    assert!(
+        res_for(5).is_err(),
+        "height beyond lock should fail the jet"
+    );
+}
diff --git a/src/jet/init/bitcoin.rs b/src/jet/init/bitcoin.rs
index d27e1af6..34a019c8 100644
--- a/src/jet/init/bitcoin.rs
+++ b/src/jet/init/bitcoin.rs
@@ -7,6 +7,7 @@ use crate::decode_bits;
 use crate::{decode, BitIter, BitWriter};
 use crate::analysis::Cost;
 use simplicity_sys::CFrameItem;
+use simplicity_sys::c_jets::c_env::bitcoin as c_bitcoin;
 use std::io::Write;
 use std::{fmt, str};
 
@@ -8151,7 +8152,7 @@ impl str::FromStr for Bitcoin {
     }
 }
 
-pub(crate) fn c_jet_ptr(jet: &Bitcoin) -> fn(&mut CFrameItem, CFrameItem, &()) -> bool {
+pub(crate) fn c_jet_ptr(jet: &Bitcoin) -> fn(&mut CFrameItem, CFrameItem, &c_bitcoin::CTxEnv) -> bool {
     match jet {
         Bitcoin::All8 => simplicity_sys::c_jets::jets_wrapper::all_8,
         Bitcoin::Eq256 => simplicity_sys::c_jets::jets_wrapper::eq_256,
@@ -8170,10 +8171,26 @@ pub(crate) fn c_jet_ptr(jet: &Bitcoin) -> fn(&mut CFrameItem, CFrameItem, &()) -
         Bitcoin::Sha256Iv => simplicity_sys::c_jets::jets_wrapper::sha_256_iv,
         Bitcoin::Sha256Block => simplicity_sys::c_jets::jets_wrapper::sha_256_block,
         Bitcoin::Verify => simplicity_sys::c_jets::jets_wrapper::verify,
+        // bip_0340_verify ignores its environment (the C implementation lives
+        // in the env-free jets-secp256k1.c), so it can use the shared wrapper
+        // that passes a null environment, exactly like the elements backend.
+        Bitcoin::Bip0340Verify => simplicity_sys::c_jets::jets_wrapper::bip_0340_verify,
+        // Bitcoin jets whose C implementations read the transaction
+        // environment (`const txEnv* env`). The wrappers in the bitcoin c_env
+        // module forward the Rust `CTxEnv` reference to the C functions.
+        Bitcoin::SigAllHash => c_bitcoin::sig_all_hash,
+        Bitcoin::CheckLockHeight => c_bitcoin::check_lock_height,
+        Bitcoin::CheckLockDistance => c_bitcoin::check_lock_distance,
+        Bitcoin::CheckLockDuration => c_bitcoin::check_lock_duration,
+        Bitcoin::CurrentIndex => c_bitcoin::current_index,
+        Bitcoin::NumInputs => c_bitcoin::num_inputs,
+        Bitcoin::TxHash => c_bitcoin::tx_hash,
+        Bitcoin::TapEnvHash => c_bitcoin::tap_env_hash,
         // Fallback for Jets that have not yet been wired up to their C
-        // implementations. This covers the tx-context / crypto jets whose C
-        // functions need a real transaction environment (not the `&()` this
-        // build passes); those cannot be executed by the Rust Bit Machine yet.
+        // implementations. This covers the remaining tx-context / crypto jets
+        // whose C functions need a real transaction environment; they cannot be
+        // executed by the Rust Bit Machine until their FFI is declared and
+        // wrapped in simplicity-sys/src/c_jets/c_env/bitcoin.rs.
         _ => unimplemented!("Bitcoin jet {:?} has no wired C implementation in this build", jet),
     }
 }

From 49e08916b8e3d3896a6cb7fd2c82667185bc190e Mon Sep 17 00:00:00 2001
From: Byron Hambly <bhambly@blockstream.com>
Date: Mon, 7 Sep 2026 14:40:15 +0200
Subject: [PATCH 16/16] bitcoin jets: wire c_jet_ptr for all remaining jets

Declare FFI bindings and implement c_jet_ptr for all Bitcoin jets that
were previously left as unimplemented!(). Each jet maps to its
rustsimplicity_0_8_bitcoin_* C symbol in bitcoinJets.c.

After this commit, the Rust BitMachine can execute any Bitcoin Simplicity
program through c_jet_ptr, and RedeemNode::prune() can produce the
anti-DOS-clean pruned programs required by the script interpreter.
---
 simplicity-sys/src/c_jets/c_env/bitcoin.rs | 286 ++++++++++++++
 src/jet/init/bitcoin.rs                    | 410 ++++++++++++++++++++-
 2 files changed, 690 insertions(+), 6 deletions(-)

diff --git a/simplicity-sys/src/c_jets/c_env/bitcoin.rs b/simplicity-sys/src/c_jets/c_env/bitcoin.rs
index 3467d5df..52a216d9 100644
--- a/simplicity-sys/src/c_jets/c_env/bitcoin.rs
+++ b/simplicity-sys/src/c_jets/c_env/bitcoin.rs
@@ -142,6 +142,240 @@ extern "C" {
     pub fn bitcoin_tx_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
     #[link_name = "rustsimplicity_0_8_bitcoin_tap_env_hash"]
     pub fn bitcoin_tap_env_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_annex_hash"]
+    pub fn bitcoin_annex_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_build_tapbranch"]
+    pub fn bitcoin_build_tapbranch(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_build_tapleaf_simplicity"]
+    pub fn bitcoin_build_tapleaf_simplicity(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_build_taptweak"]
+    pub fn bitcoin_build_taptweak(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_check_lock_time"]
+    pub fn bitcoin_check_lock_time(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_current_annex_hash"]
+    pub fn bitcoin_current_annex_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_current_prev_outpoint"]
+    pub fn bitcoin_current_prev_outpoint(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_current_script_hash"]
+    pub fn bitcoin_current_script_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_current_script_sig_hash"]
+    pub fn bitcoin_current_script_sig_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_current_sequence"]
+    pub fn bitcoin_current_sequence(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_current_value"]
+    pub fn bitcoin_current_value(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv)
+        -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_fee"]
+    pub fn bitcoin_fee(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_annex_hash"]
+    pub fn bitcoin_input_annex_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_annexes_hash"]
+    pub fn bitcoin_input_annexes_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_hash"]
+    pub fn bitcoin_input_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_outpoints_hash"]
+    pub fn bitcoin_input_outpoints_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_prev_outpoint"]
+    pub fn bitcoin_input_prev_outpoint(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_script_hash"]
+    pub fn bitcoin_input_script_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_script_sig_hash"]
+    pub fn bitcoin_input_script_sig_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_script_sigs_hash"]
+    pub fn bitcoin_input_script_sigs_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_scripts_hash"]
+    pub fn bitcoin_input_scripts_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_sequence"]
+    pub fn bitcoin_input_sequence(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_sequences_hash"]
+    pub fn bitcoin_input_sequences_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_utxo_hash"]
+    pub fn bitcoin_input_utxo_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_utxos_hash"]
+    pub fn bitcoin_input_utxos_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_value"]
+    pub fn bitcoin_input_value(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_input_values_hash"]
+    pub fn bitcoin_input_values_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_inputs_hash"]
+    pub fn bitcoin_inputs_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_internal_key"]
+    pub fn bitcoin_internal_key(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_lock_time"]
+    pub fn bitcoin_lock_time(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_num_outputs"]
+    pub fn bitcoin_num_outputs(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_outpoint_hash"]
+    pub fn bitcoin_outpoint_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv)
+        -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_output_hash"]
+    pub fn bitcoin_output_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_output_script_hash"]
+    pub fn bitcoin_output_script_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_output_scripts_hash"]
+    pub fn bitcoin_output_scripts_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_output_value"]
+    pub fn bitcoin_output_value(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_output_values_hash"]
+    pub fn bitcoin_output_values_hash(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_outputs_hash"]
+    pub fn bitcoin_outputs_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_script_cmr"]
+    pub fn bitcoin_script_cmr(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tapleaf_hash"]
+    pub fn bitcoin_tapleaf_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tapleaf_version"]
+    pub fn bitcoin_tapleaf_version(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tappath"]
+    pub fn bitcoin_tappath(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tappath_hash"]
+    pub fn bitcoin_tappath_hash(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_total_input_value"]
+    pub fn bitcoin_total_input_value(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_total_output_value"]
+    pub fn bitcoin_total_output_value(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_transaction_id"]
+    pub fn bitcoin_transaction_id(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tx_is_final"]
+    pub fn bitcoin_tx_is_final(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tx_lock_distance"]
+    pub fn bitcoin_tx_lock_distance(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tx_lock_duration"]
+    pub fn bitcoin_tx_lock_duration(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tx_lock_height"]
+    pub fn bitcoin_tx_lock_height(
+        dst: *mut CFrameItem,
+        src: CFrameItem,
+        env: *const CTxEnv,
+    ) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_tx_lock_time"]
+    pub fn bitcoin_tx_lock_time(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
+    #[link_name = "rustsimplicity_0_8_bitcoin_version"]
+    pub fn bitcoin_version(dst: *mut CFrameItem, src: CFrameItem, env: *const CTxEnv) -> bool;
 }
 
 impl CTxEnv {
@@ -196,6 +430,58 @@ bitcoin_env_jet_wrapper!(current_index, bitcoin_current_index);
 bitcoin_env_jet_wrapper!(num_inputs, bitcoin_num_inputs);
 bitcoin_env_jet_wrapper!(tx_hash, bitcoin_tx_hash);
 bitcoin_env_jet_wrapper!(tap_env_hash, bitcoin_tap_env_hash);
+bitcoin_env_jet_wrapper!(annex_hash, bitcoin_annex_hash);
+bitcoin_env_jet_wrapper!(build_tapbranch, bitcoin_build_tapbranch);
+bitcoin_env_jet_wrapper!(build_tapleaf_simplicity, bitcoin_build_tapleaf_simplicity);
+bitcoin_env_jet_wrapper!(build_taptweak, bitcoin_build_taptweak);
+bitcoin_env_jet_wrapper!(check_lock_time, bitcoin_check_lock_time);
+bitcoin_env_jet_wrapper!(current_annex_hash, bitcoin_current_annex_hash);
+bitcoin_env_jet_wrapper!(current_prev_outpoint, bitcoin_current_prev_outpoint);
+bitcoin_env_jet_wrapper!(current_script_hash, bitcoin_current_script_hash);
+bitcoin_env_jet_wrapper!(current_script_sig_hash, bitcoin_current_script_sig_hash);
+bitcoin_env_jet_wrapper!(current_sequence, bitcoin_current_sequence);
+bitcoin_env_jet_wrapper!(current_value, bitcoin_current_value);
+bitcoin_env_jet_wrapper!(fee, bitcoin_fee);
+bitcoin_env_jet_wrapper!(input_annex_hash, bitcoin_input_annex_hash);
+bitcoin_env_jet_wrapper!(input_annexes_hash, bitcoin_input_annexes_hash);
+bitcoin_env_jet_wrapper!(input_hash, bitcoin_input_hash);
+bitcoin_env_jet_wrapper!(input_outpoints_hash, bitcoin_input_outpoints_hash);
+bitcoin_env_jet_wrapper!(input_prev_outpoint, bitcoin_input_prev_outpoint);
+bitcoin_env_jet_wrapper!(input_script_hash, bitcoin_input_script_hash);
+bitcoin_env_jet_wrapper!(input_script_sig_hash, bitcoin_input_script_sig_hash);
+bitcoin_env_jet_wrapper!(input_script_sigs_hash, bitcoin_input_script_sigs_hash);
+bitcoin_env_jet_wrapper!(input_scripts_hash, bitcoin_input_scripts_hash);
+bitcoin_env_jet_wrapper!(input_sequence, bitcoin_input_sequence);
+bitcoin_env_jet_wrapper!(input_sequences_hash, bitcoin_input_sequences_hash);
+bitcoin_env_jet_wrapper!(input_utxo_hash, bitcoin_input_utxo_hash);
+bitcoin_env_jet_wrapper!(input_utxos_hash, bitcoin_input_utxos_hash);
+bitcoin_env_jet_wrapper!(input_value, bitcoin_input_value);
+bitcoin_env_jet_wrapper!(input_values_hash, bitcoin_input_values_hash);
+bitcoin_env_jet_wrapper!(inputs_hash, bitcoin_inputs_hash);
+bitcoin_env_jet_wrapper!(internal_key, bitcoin_internal_key);
+bitcoin_env_jet_wrapper!(lock_time, bitcoin_lock_time);
+bitcoin_env_jet_wrapper!(num_outputs, bitcoin_num_outputs);
+bitcoin_env_jet_wrapper!(outpoint_hash, bitcoin_outpoint_hash);
+bitcoin_env_jet_wrapper!(output_hash, bitcoin_output_hash);
+bitcoin_env_jet_wrapper!(output_script_hash, bitcoin_output_script_hash);
+bitcoin_env_jet_wrapper!(output_scripts_hash, bitcoin_output_scripts_hash);
+bitcoin_env_jet_wrapper!(output_value, bitcoin_output_value);
+bitcoin_env_jet_wrapper!(output_values_hash, bitcoin_output_values_hash);
+bitcoin_env_jet_wrapper!(outputs_hash, bitcoin_outputs_hash);
+bitcoin_env_jet_wrapper!(script_cmr, bitcoin_script_cmr);
+bitcoin_env_jet_wrapper!(tapleaf_hash, bitcoin_tapleaf_hash);
+bitcoin_env_jet_wrapper!(tapleaf_version, bitcoin_tapleaf_version);
+bitcoin_env_jet_wrapper!(tappath, bitcoin_tappath);
+bitcoin_env_jet_wrapper!(tappath_hash, bitcoin_tappath_hash);
+bitcoin_env_jet_wrapper!(total_input_value, bitcoin_total_input_value);
+bitcoin_env_jet_wrapper!(total_output_value, bitcoin_total_output_value);
+bitcoin_env_jet_wrapper!(transaction_id, bitcoin_transaction_id);
+bitcoin_env_jet_wrapper!(tx_is_final, bitcoin_tx_is_final);
+bitcoin_env_jet_wrapper!(tx_lock_distance, bitcoin_tx_lock_distance);
+bitcoin_env_jet_wrapper!(tx_lock_duration, bitcoin_tx_lock_duration);
+bitcoin_env_jet_wrapper!(tx_lock_height, bitcoin_tx_lock_height);
+bitcoin_env_jet_wrapper!(tx_lock_time, bitcoin_tx_lock_time);
+bitcoin_env_jet_wrapper!(version, bitcoin_version);
 
 // Will uncomment in a later commit; need to update libsimplicity first.
 #[cfg(test)]
diff --git a/src/jet/init/bitcoin.rs b/src/jet/init/bitcoin.rs
index 34a019c8..01fc140d 100644
--- a/src/jet/init/bitcoin.rs
+++ b/src/jet/init/bitcoin.rs
@@ -8186,12 +8186,410 @@ pub(crate) fn c_jet_ptr(jet: &Bitcoin) -> fn(&mut CFrameItem, CFrameItem, &c_bit
         Bitcoin::NumInputs => c_bitcoin::num_inputs,
         Bitcoin::TxHash => c_bitcoin::tx_hash,
         Bitcoin::TapEnvHash => c_bitcoin::tap_env_hash,
-        // Fallback for Jets that have not yet been wired up to their C
-        // implementations. This covers the remaining tx-context / crypto jets
-        // whose C functions need a real transaction environment; they cannot be
-        // executed by the Rust Bit Machine until their FFI is declared and
-        // wrapped in simplicity-sys/src/c_jets/c_env/bitcoin.rs.
-        _ => unimplemented!("Bitcoin jet {:?} has no wired C implementation in this build", jet),
+        // Pure jets (no environment needed)
+        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::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::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::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::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::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::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::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::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::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::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::Sha256Ctx8Add512 => simplicity_sys::c_jets::jets_wrapper::sha_256_ctx_8_add_512,
+        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::TapdataInit => simplicity_sys::c_jets::jets_wrapper::tapdata_init,
+        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,
+        // Remaining env jets
+        Bitcoin::AnnexHash => c_bitcoin::annex_hash,
+        Bitcoin::BuildTapbranch => c_bitcoin::build_tapbranch,
+        Bitcoin::BuildTapleafSimplicity => c_bitcoin::build_tapleaf_simplicity,
+        Bitcoin::BuildTaptweak => c_bitcoin::build_taptweak,
+        Bitcoin::CheckLockTime => c_bitcoin::check_lock_time,
+        Bitcoin::CurrentAnnexHash => c_bitcoin::current_annex_hash,
+        Bitcoin::CurrentPrevOutpoint => c_bitcoin::current_prev_outpoint,
+        Bitcoin::CurrentScriptHash => c_bitcoin::current_script_hash,
+        Bitcoin::CurrentScriptSigHash => c_bitcoin::current_script_sig_hash,
+        Bitcoin::CurrentSequence => c_bitcoin::current_sequence,
+        Bitcoin::CurrentValue => c_bitcoin::current_value,
+        Bitcoin::Fee => c_bitcoin::fee,
+        Bitcoin::InputAnnexHash => c_bitcoin::input_annex_hash,
+        Bitcoin::InputAnnexesHash => c_bitcoin::input_annexes_hash,
+        Bitcoin::InputHash => c_bitcoin::input_hash,
+        Bitcoin::InputOutpointsHash => c_bitcoin::input_outpoints_hash,
+        Bitcoin::InputPrevOutpoint => c_bitcoin::input_prev_outpoint,
+        Bitcoin::InputScriptHash => c_bitcoin::input_script_hash,
+        Bitcoin::InputScriptSigHash => c_bitcoin::input_script_sig_hash,
+        Bitcoin::InputScriptSigsHash => c_bitcoin::input_script_sigs_hash,
+        Bitcoin::InputScriptsHash => c_bitcoin::input_scripts_hash,
+        Bitcoin::InputSequence => c_bitcoin::input_sequence,
+        Bitcoin::InputSequencesHash => c_bitcoin::input_sequences_hash,
+        Bitcoin::InputUtxoHash => c_bitcoin::input_utxo_hash,
+        Bitcoin::InputUtxosHash => c_bitcoin::input_utxos_hash,
+        Bitcoin::InputValue => c_bitcoin::input_value,
+        Bitcoin::InputValuesHash => c_bitcoin::input_values_hash,
+        Bitcoin::InputsHash => c_bitcoin::inputs_hash,
+        Bitcoin::InternalKey => c_bitcoin::internal_key,
+        Bitcoin::LockTime => c_bitcoin::lock_time,
+        Bitcoin::NumOutputs => c_bitcoin::num_outputs,
+        Bitcoin::OutpointHash => c_bitcoin::outpoint_hash,
+        Bitcoin::OutputHash => c_bitcoin::output_hash,
+        Bitcoin::OutputScriptHash => c_bitcoin::output_script_hash,
+        Bitcoin::OutputScriptsHash => c_bitcoin::output_scripts_hash,
+        Bitcoin::OutputValue => c_bitcoin::output_value,
+        Bitcoin::OutputValuesHash => c_bitcoin::output_values_hash,
+        Bitcoin::OutputsHash => c_bitcoin::outputs_hash,
+        Bitcoin::ScriptCMR => c_bitcoin::script_cmr,
+        Bitcoin::TapleafHash => c_bitcoin::tapleaf_hash,
+        Bitcoin::TapleafVersion => c_bitcoin::tapleaf_version,
+        Bitcoin::Tappath => c_bitcoin::tappath,
+        Bitcoin::TappathHash => c_bitcoin::tappath_hash,
+        Bitcoin::TotalInputValue => c_bitcoin::total_input_value,
+        Bitcoin::TotalOutputValue => c_bitcoin::total_output_value,
+        Bitcoin::TransactionId => c_bitcoin::transaction_id,
+        Bitcoin::TxIsFinal => c_bitcoin::tx_is_final,
+        Bitcoin::TxLockDistance => c_bitcoin::tx_lock_distance,
+        Bitcoin::TxLockDuration => c_bitcoin::tx_lock_duration,
+        Bitcoin::TxLockHeight => c_bitcoin::tx_lock_height,
+        Bitcoin::TxLockTime => c_bitcoin::tx_lock_time,
+        Bitcoin::Version => c_bitcoin::version,
     }
 }