Copy disabled (too large)
Download .txt
Showing preview only (15,386K chars total). Download the full file to get everything.
Repository: ElementsProject/simplicity
Branch: master
Commit: c6ab4dd8f178
Files: 307
Total size: 47.3 MB
Directory structure:
gitextract__1j3kvgc/
├── .github/
│ └── workflows/
│ └── ci.yml
├── .gitignore
├── C/
│ ├── Makefile
│ ├── bitcoin/
│ │ ├── bitcoinJets.c
│ │ ├── bitcoinJets.h
│ │ ├── decodeBitcoinJets.inc
│ │ ├── env.c
│ │ ├── ops.c
│ │ ├── ops.h
│ │ ├── primitive.c
│ │ ├── primitive.h
│ │ ├── primitiveEnumJet.inc
│ │ ├── primitiveEnumTy.inc
│ │ ├── primitiveInitTy.inc
│ │ ├── primitiveJetNode.inc
│ │ ├── txEnv.c
│ │ └── txEnv.h
│ ├── bitstream.c
│ ├── bitstream.h
│ ├── bitstring.h
│ ├── bounded.h
│ ├── ctx8Pruned.c
│ ├── ctx8Pruned.h
│ ├── ctx8Unpruned.c
│ ├── ctx8Unpruned.h
│ ├── dag.c
│ ├── dag.h
│ ├── decodeCoreJets.inc
│ ├── deserialize.c
│ ├── deserialize.h
│ ├── elements/
│ │ ├── checkSigHashAllTx1.c
│ │ ├── checkSigHashAllTx1.h
│ │ ├── cmr.c
│ │ ├── decodeElementsJets.inc
│ │ ├── elementsJets.c
│ │ ├── elementsJets.h
│ │ ├── env.c
│ │ ├── exec.c
│ │ ├── ops.c
│ │ ├── ops.h
│ │ ├── primitive.c
│ │ ├── primitive.h
│ │ ├── primitiveEnumJet.inc
│ │ ├── primitiveEnumTy.inc
│ │ ├── primitiveInitTy.inc
│ │ ├── primitiveJetNode.inc
│ │ ├── txEnv.c
│ │ └── txEnv.h
│ ├── elements-sources.mk
│ ├── eval.c
│ ├── eval.h
│ ├── frame.c
│ ├── frame.h
│ ├── hashBlock.c
│ ├── hashBlock.h
│ ├── include/
│ │ └── simplicity/
│ │ ├── bitcoin/
│ │ │ └── env.h
│ │ ├── elements/
│ │ │ ├── cmr.h
│ │ │ ├── env.h
│ │ │ └── exec.h
│ │ └── errorCodes.h
│ ├── jets-secp256k1.c
│ ├── jets.c
│ ├── jets.h
│ ├── limitations.h
│ ├── precomputed.h
│ ├── regression4.c
│ ├── regression4.h
│ ├── rsort.c
│ ├── rsort.h
│ ├── schnorr0.c
│ ├── schnorr0.h
│ ├── schnorr6.c
│ ├── schnorr6.h
│ ├── secp256k1/
│ │ ├── README.md
│ │ ├── assumptions.h
│ │ ├── eckey.h
│ │ ├── eckey_impl.h
│ │ ├── ecmult.h
│ │ ├── ecmult_impl.h
│ │ ├── extrakeys.h
│ │ ├── extrakeys_impl.h
│ │ ├── field.h
│ │ ├── field_5x52.h
│ │ ├── field_5x52_asm_impl.h
│ │ ├── field_5x52_impl.h
│ │ ├── field_5x52_int128_impl.h
│ │ ├── field_impl.h
│ │ ├── generator.h
│ │ ├── generator_impl.h
│ │ ├── group.h
│ │ ├── group_impl.h
│ │ ├── int128.h
│ │ ├── int128_impl.h
│ │ ├── int128_native.h
│ │ ├── int128_native_impl.h
│ │ ├── int128_struct.h
│ │ ├── int128_struct_impl.h
│ │ ├── modinv64.h
│ │ ├── modinv64_impl.h
│ │ ├── precomputed_ecmult.h
│ │ ├── scalar.h
│ │ ├── scalar_4x64.h
│ │ ├── scalar_4x64_impl.h
│ │ ├── scalar_impl.h
│ │ ├── schnorrsig.h
│ │ ├── schnorrsig_impl.h
│ │ ├── secp256k1.h
│ │ ├── secp256k1_impl.h
│ │ └── util.h
│ ├── sha256.c
│ ├── sha256.h
│ ├── sha256_x86.inc
│ ├── simplicity_alloc.h
│ ├── simplicity_assert.h
│ ├── taptweak.h
│ ├── test.c
│ ├── type.c
│ ├── type.h
│ ├── typeInference.c
│ ├── typeInference.h
│ ├── typeSkipTest.c
│ ├── typeSkipTest.h
│ └── uword.h
├── Coq/
│ ├── C/
│ │ ├── divstep.v
│ │ ├── extraMath.v
│ │ ├── jets_secp256k1.v
│ │ ├── modinv.v
│ │ ├── progressC.v
│ │ └── secp256k1/
│ │ ├── spec_int128.v
│ │ ├── spec_modinv64.v
│ │ ├── verif_int128_impl.v
│ │ └── verif_modinv64_impl.v
│ ├── Simplicity/
│ │ ├── Alg.v
│ │ ├── Bit.v
│ │ ├── BitMachine.v
│ │ ├── Core.v
│ │ ├── Delegation.v
│ │ ├── Digest.v
│ │ ├── MerkleRoot.v
│ │ ├── Primitive/
│ │ │ └── Bitcoin.v
│ │ ├── Primitive.v
│ │ ├── SHA256.v
│ │ ├── StaticAnalysis.v
│ │ ├── Translate.v
│ │ ├── Ty.v
│ │ ├── Util/
│ │ │ ├── Arith.v
│ │ │ ├── List.v
│ │ │ ├── Monad/
│ │ │ │ └── Reader.v
│ │ │ ├── Monad.v
│ │ │ ├── Option.v
│ │ │ ├── PackedClass.v
│ │ │ └── Thrist.v
│ │ └── Word.v
│ └── _CoqProject
├── Haskell/
│ ├── Bitcoin/
│ │ └── Simplicity/
│ │ └── Bitcoin/
│ │ ├── DataTypes.hs
│ │ └── Primitive.hs
│ ├── Core/
│ │ └── Simplicity/
│ │ ├── BitMachine/
│ │ │ ├── Authentic.hs
│ │ │ ├── StaticAnalysis/
│ │ │ │ ├── Cost.hs
│ │ │ │ └── TCO.hs
│ │ │ ├── StaticAnalysis.hs
│ │ │ ├── Translate/
│ │ │ │ └── TCO.hs
│ │ │ ├── Translate.hs
│ │ │ └── Ty.hs
│ │ ├── BitMachine.hs
│ │ ├── Bitcoin.hs
│ │ ├── CoreJets.hs
│ │ ├── Delegator/
│ │ │ └── Impl.hs
│ │ ├── Delegator.hs
│ │ ├── Digest/
│ │ │ └── Pure/
│ │ │ └── SHA.hs
│ │ ├── Digest.hs
│ │ ├── FFI/
│ │ │ ├── Frame.hs
│ │ │ └── Jets.hs
│ │ ├── Functor.hs
│ │ ├── LibSecp256k1/
│ │ │ ├── Schnorr.hs
│ │ │ └── Spec.hs
│ │ ├── MerkleRoot/
│ │ │ └── Impl.hs
│ │ ├── MerkleRoot.hs
│ │ ├── Programs/
│ │ │ ├── Arith.hs
│ │ │ ├── Bit.hs
│ │ │ ├── Bitcoin/
│ │ │ │ └── Lib.hs
│ │ │ ├── Bitcoin.hs
│ │ │ ├── CheckSig/
│ │ │ │ └── Lib.hs
│ │ │ ├── CheckSig.hs
│ │ │ ├── Elements/
│ │ │ │ └── Lib.hs
│ │ │ ├── Elements.hs
│ │ │ ├── Generic.hs
│ │ │ ├── LibSecp256k1/
│ │ │ │ └── Lib.hs
│ │ │ ├── LibSecp256k1.hs
│ │ │ ├── Loop.hs
│ │ │ ├── Sha256/
│ │ │ │ └── Lib.hs
│ │ │ ├── Sha256.hs
│ │ │ ├── TimeLock.hs
│ │ │ └── Word.hs
│ │ ├── Serialization.hs
│ │ ├── Tags.hs
│ │ ├── Tensor.hs
│ │ ├── Term/
│ │ │ └── Core.hs
│ │ ├── Tree.hs
│ │ ├── Ty/
│ │ │ ├── Bit.hs
│ │ │ ├── LibSecp256k1.hs
│ │ │ ├── Sha256.hs
│ │ │ └── Word.hs
│ │ ├── Ty.hs
│ │ ├── Weight.hs
│ │ └── Word.hs
│ ├── Elements/
│ │ └── Simplicity/
│ │ └── Elements/
│ │ ├── DataTypes.hs
│ │ └── Primitive.hs
│ ├── Indef/
│ │ └── Simplicity/
│ │ ├── Dag.hs
│ │ ├── Inference.hs
│ │ ├── JetType.hs
│ │ ├── Primitive.hsig
│ │ ├── Semantics.hs
│ │ ├── Serialization/
│ │ │ ├── BitString.hs
│ │ │ └── ByteString.hs
│ │ ├── StaticAnalysis/
│ │ │ └── Cost.hs
│ │ └── Term.hs
│ ├── Simplicity/
│ │ ├── Bitcoin/
│ │ │ ├── Benchmarks.hs
│ │ │ ├── FFI/
│ │ │ │ ├── Env.hs
│ │ │ │ └── Jets.hs
│ │ │ ├── Jets.hs
│ │ │ └── Programs/
│ │ │ ├── SigHash/
│ │ │ │ └── Lib.hs
│ │ │ ├── SigHash.hs
│ │ │ ├── TimeLock.hs
│ │ │ ├── Transaction/
│ │ │ │ └── Lib.hs
│ │ │ └── Transaction.hs
│ │ └── Elements/
│ │ ├── Benchmarks.hs
│ │ ├── FFI/
│ │ │ ├── Env.hs
│ │ │ └── Jets.hs
│ │ ├── Jets.hs
│ │ └── Programs/
│ │ ├── Issuance/
│ │ │ └── Lib.hs
│ │ ├── Issuance.hs
│ │ ├── SigHash/
│ │ │ └── Lib.hs
│ │ ├── SigHash.hs
│ │ ├── TimeLock.hs
│ │ ├── Transaction/
│ │ │ └── Lib.hs
│ │ └── Transaction.hs
│ ├── Tests/
│ │ ├── Simplicity/
│ │ │ ├── Arbitrary.hs
│ │ │ ├── Bip0340.hs
│ │ │ ├── BitMachine/
│ │ │ │ ├── StaticAnalysis/
│ │ │ │ │ └── Tests.hs
│ │ │ │ └── Tests.hs
│ │ │ ├── Bitcoin/
│ │ │ │ ├── Arbitrary.hs
│ │ │ │ ├── FFI/
│ │ │ │ │ ├── Primitive.hs
│ │ │ │ │ └── Tests.hs
│ │ │ │ ├── Serialization/
│ │ │ │ │ └── Tests.hs
│ │ │ │ ├── TestEval.hs
│ │ │ │ └── Tests.hs
│ │ │ ├── Elements/
│ │ │ │ ├── Arbitrary.hs
│ │ │ │ ├── FFI/
│ │ │ │ │ ├── Primitive.hs
│ │ │ │ │ └── Tests.hs
│ │ │ │ ├── Regression.hs
│ │ │ │ ├── Serialization/
│ │ │ │ │ └── Tests.hs
│ │ │ │ ├── TestEval.hs
│ │ │ │ └── Tests.hs
│ │ │ ├── FFI/
│ │ │ │ ├── Bitstream.hs
│ │ │ │ ├── Dag.hs
│ │ │ │ └── Tests.hs
│ │ │ ├── Programs/
│ │ │ │ ├── Example.hs
│ │ │ │ └── Tests.hs
│ │ │ ├── Serialization/
│ │ │ │ └── Tests.hs
│ │ │ ├── TestCoreEval.hs
│ │ │ └── Ty/
│ │ │ ├── Arbitrary.hs
│ │ │ └── Tests.hs
│ │ └── Tests.hs
│ └── cbits/
│ ├── bitcoin/
│ │ ├── env.c
│ │ └── jets.c
│ ├── bitstream.c
│ ├── coreJets.c
│ ├── dag.c
│ ├── elements/
│ │ ├── env.c
│ │ └── jets.c
│ ├── frame.c
│ └── wrappers.h
├── Haskell-Examples/
│ └── TestnetTransaction.hs
├── Haskell-Generate/
│ ├── GenDecodeJet.hs
│ ├── GenPrecomputed.hs
│ ├── GenPrimitive.hs
│ ├── GenRustJets.hs
│ ├── GenTests.hs
│ └── NameWrangler.hs
├── LICENSE
├── README.md
├── Setup.hs
├── Simplicity-Primitive.html
├── Simplicity-TR.tm
├── Simplicity.C.nix
├── Simplicity.Coq.nix
├── Simplicity.Haskell.nix
├── Simplicity.bib
├── Simplicity.cabal
├── alectryon/
│ ├── alectryon.css
│ ├── alectryon.js
│ ├── divstep.v.html
│ ├── pygments.css
│ ├── spec_int128.v.html
│ ├── spec_modinv64.v.html
│ ├── verif_int128_impl.v.html
│ └── verif_modinv64_impl.v.html
├── compcert-opensource.nix
├── compcert-opensource.patch
├── default.nix
├── inheritance.Coq.dot
├── manual-index.html
├── safegcd-bounds.nix
├── shell.nix
├── spelling.ignore.txt
├── unification.patch
└── vst.nix
================================================
FILE CONTENTS
================================================
================================================
FILE: .github/workflows/ci.yml
================================================
name: CI
on: [push, pull_request]
jobs:
codespell:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: codespell-project/actions-codespell@v2
with:
ignore_words_file: spelling.ignore.txt
skip: alectryon
build:
strategy:
fail-fast: false
matrix:
project: ["c", "haskell"] # coq takes a very long time and times out at 6 hours...
os: ["ubuntu-latest", macos-latest]
channel: ["nixos-25.05", "nixpkgs-unstable"]
runs-on: ${{ matrix.os }}
permissions:
id-token: write
contents: read
steps:
- uses: actions/checkout@v4
- uses: DeterminateSystems/nix-installer-action@v17
- name: Update channel ${{matrix.channel}}
run: |
nix-channel --add https://nixos.org/channels/${{matrix.channel}} nixpkgs
nix-channel --update
- run: nix-build -A ${{matrix.project}}
================================================
FILE: .gitignore
================================================
# Tech report
Simplicity-TR.pdf
*.eps
# Haskell
/Haskell/*.pdf
dist-newstyle
cabal.project.local
# Nix
result
result-doc
# Coq
/Coq/*Makefile*
/Coq/.Makefile.d
/Coq/.nia.cache
.lia.cache
*.vok
*.vos
*.glob
*.aux
*.vo
*.crashcoqide
alectryon-doc
# C
/C/test
*.o
*.out
*.a
# Coverage
*.gcda
*.gcno
*.gcov
*.info
# Gen
/*.rs
/*.c
/*.h
/*.inc
================================================
FILE: C/Makefile
================================================
CORE_OBJS := bitstream.o dag.o deserialize.o eval.o frame.o jets.o jets-secp256k1.o rsort.o sha256.o type.o typeInference.o
BITCOIN_OBJS := bitcoin/env.o bitcoin/ops.o bitcoin/bitcoinJets.o bitcoin/primitive.o bitcoin/txEnv.o
ELEMENTS_OBJS := elements/env.o elements/exec.o elements/ops.o elements/elementsJets.o elements/primitive.o elements/cmr.o elements/txEnv.o
TEST_OBJS := test.o ctx8Pruned.o ctx8Unpruned.o hashBlock.o regression4.o schnorr0.o schnorr6.o typeSkipTest.o elements/checkSigHashAllTx1.o
# From https://fastcompression.blogspot.com/2019/01/compiler-warnings.html
CWARN := -Werror -Wall -Wextra -Wcast-qual -Wcast-align -Wstrict-aliasing -Wpointer-arith -Winit-self -Wshadow -Wswitch-enum -Wstrict-prototypes -Wmissing-prototypes -Wredundant-decls -Wfloat-equal -Wundef -Wconversion
ifneq ($(doCheck), 1)
CPPFLAGS := $(CPPFLAGS) -DPRODUCTION
endif
CFLAGS := $(CFLAGS) -I include
# libsecp256k1 is full of conversion warnings, so we compile jets-secp256k1.c separately.
jets-secp256k1.o: jets-secp256k1.c
$(CC) -c $(CFLAGS) $(CWARN) -Wno-conversion $(CPPFLAGS) -o $@ $<
elements/elementsJets.o: elements/elementsJets.c
$(CC) -c $(CFLAGS) $(CWARN) -Wno-switch-enum -Wswitch $(CPPFLAGS) -o $@ $<
sha256.o: sha256.c
$(CC) -c $(CFLAGS) $(X86_SHANI_CXXFLAGS) $(CWARN) -Wno-cast-align -Wno-sign-conversion $(CPPFLAGS) -o $@ $<
%.o: %.c
$(CC) -c $(CFLAGS) $(CWARN) $(CPPFLAGS) -o $@ $<
libBitcoinSimplicity.a: $(CORE_OBJS) $(BITCOIN_OBJS)
ar rcs $@ $^
libElementsSimplicity.a: $(CORE_OBJS) $(ELEMENTS_OBJS)
ar rcs $@ $^
test: $(TEST_OBJS) libElementsSimplicity.a
$(CC) $^ -o $@ $(LDFLAGS)
install: libBitcoinSimplicity.a libElementsSimplicity.a
mkdir -p $(out)/lib
cp $^ $(out)/lib/
cp -R include $(out)/include
check: test
./test
clean:
-rm -f test libElementsSimplicity.a $(TEST_OBJS) $(OBJS)
.PHONY: install check clean
================================================
FILE: C/bitcoin/bitcoinJets.c
================================================
#include "bitcoinJets.h"
#include "ops.h"
#include "txEnv.h"
#include "../taptweak.h"
#include "../simplicity_assert.h"
/* Read a 256-bit hash value from the 'src' frame, advancing the cursor 256 cells.
*
* Precondition: '*src' is a valid read frame for 256 more cells;
* NULL != h;
*/
static void readHash(sha256_midstate* h, frameItem *src) {
read32s(h->s, 8, src);
}
/* Write a 256-bit hash value to the 'dst' frame, advancing the cursor 256 cells.
*
* Precondition: '*dst' is a valid write frame for 256 more cells;
* NULL != h;
*/
static void writeHash(frameItem* dst, const sha256_midstate* h) {
write32s(dst, h->s, 8);
}
/* Write an outpoint value to the 'dst' frame, advancing the cursor 288 cells.
*
* Precondition: '*dst' is a valid write frame for 288 more cells;
* NULL != op;
*/
static void prevOutpoint(frameItem* dst, const outpoint* op) {
writeHash(dst, &op->txid);
simplicity_write32(dst, op->ix);
}
static uint_fast32_t lockHeight(const bitcoinTransaction* tx) {
return !tx->isFinal && tx->lockTime < 500000000U ? tx->lockTime : 0;
}
static uint_fast32_t lockTime(const bitcoinTransaction* tx) {
return !tx->isFinal && 500000000U <= tx->lockTime ? tx->lockTime : 0;
}
static uint_fast16_t lockDistance(const bitcoinTransaction* tx, uint_fast32_t ix) {
simplicity_assert(ix < tx->numInputs);
if (2 <= tx->version &&
tx->input[ix].sequence < 0x80000000 &&
!(tx->input[ix].sequence & ((uint_fast32_t)1 << 22))) {
return tx->input[ix].sequence & 0xffff;
} else {
return 0;
}
}
static uint_fast16_t lockDuration(const bitcoinTransaction* tx, uint_fast32_t ix) {
simplicity_assert(ix < tx->numInputs);
if (2 <= tx->version &&
tx->input[ix].sequence < 0x80000000 &&
!!(tx->input[ix].sequence & ((uint_fast32_t)1 << 22))) {
return tx->input[ix].sequence & 0xffff;
} else {
return 0;
}
}
/* version : ONE |- TWO^32 */
bool simplicity_bitcoin_version(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write32(dst, env->tx->version);
return true;
}
/* lock_time : ONE |- TWO^32 */
bool simplicity_bitcoin_lock_time(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write32(dst, env->tx->lockTime);
return true;
}
/* input_prev_outpoint : TWO^32 |- S (TWO^256 * TWO^32) */
bool simplicity_bitcoin_input_prev_outpoint(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numInputs)) {
prevOutpoint(dst, &env->tx->input[i].prevOutpoint);
} else {
skipBits(dst, 288);
}
return true;
}
/* input_value : TWO^32 |- S TWO^64 */
bool simplicity_bitcoin_input_value(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numInputs)) {
simplicity_write64(dst, env->tx->input[i].txo.value);
} else {
skipBits(dst, 64);
}
return true;
}
/* input_script_hash : TWO^32 |- S TWO^256 */
bool simplicity_bitcoin_input_script_hash(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numInputs)) {
writeHash(dst, &env->tx->input[i].txo.scriptPubKey);
} else {
skipBits(dst, 256);
}
return true;
}
/* input_sequence : TWO^32 |- S TWO^32 */
bool simplicity_bitcoin_input_sequence(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numInputs)) {
simplicity_write32(dst, env->tx->input[i].sequence);
} else {
skipBits(dst, 32);
}
return true;
}
/* input_annex_hash : TWO^32 |- S (S (TWO^256)) */
bool simplicity_bitcoin_input_annex_hash(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numInputs)) {
if (writeBit(dst, env->tx->input[i].hasAnnex)) {
writeHash(dst, &env->tx->input[i].annexHash);
} else {
skipBits(dst, 256);
}
} else {
skipBits(dst, 257);
}
return true;
}
/* input_script_sig_hash : TWO^32 |- (S (TWO^256) */
bool simplicity_bitcoin_input_script_sig_hash(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numInputs)) {
writeHash(dst, &env->tx->input[i].scriptSigHash);
} else {
skipBits(dst, 256);
}
return true;
}
/* output_value : TWO^32 |- S (TWO^64) */
bool simplicity_bitcoin_output_value(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numOutputs)) {
simplicity_write64(dst, env->tx->output[i].value);
} else {
skipBits(dst, 64);
}
return true;
}
/* output_script_hash : TWO^32 |- S TWO^256 */
bool simplicity_bitcoin_output_script_hash(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numOutputs)) {
writeHash(dst, &env->tx->output[i].scriptPubKey);
} else {
skipBits(dst, 256);
}
return true;
}
/* fee : ONE |- TWO^64 */
bool simplicity_bitcoin_fee(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write64(dst, env->tx->totalInputValue - env->tx->totalOutputValue);
return true;
}
/* total_input_value : ONE |- TWO^64 */
bool simplicity_bitcoin_total_input_value(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write64(dst, env->tx->totalInputValue);
return true;
}
/* total_output_value : ONE |- TWO^64 */
bool simplicity_bitcoin_total_output_value(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write64(dst, env->tx->totalOutputValue);
return true;
}
/* script_cmr : ONE |- TWO^256 */
bool simplicity_bitcoin_script_cmr(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
write32s(dst, env->taproot->scriptCMR.s, 8);
return true;
}
/* transaction_id : ONE |- TWO^256 */
bool simplicity_bitcoin_transaction_id(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
write32s(dst, env->tx->txid.s, 8);
return true;
}
/* current_index : ONE |- TWO^32 */
bool simplicity_bitcoin_current_index(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write32(dst, env->ix);
return true;
}
/* current_prev_outpoint : ONE |- TWO^256 * TWO^32 */
bool simplicity_bitcoin_current_prev_outpoint(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
if (env->tx->numInputs <= env->ix) return false;
prevOutpoint(dst, &env->tx->input[env->ix].prevOutpoint);
return true;
}
/* current_value : ONE |- (TWO^64) */
bool simplicity_bitcoin_current_value(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
if (env->tx->numInputs <= env->ix) return false;
simplicity_write64(dst, env->tx->input[env->ix].txo.value);
return true;
}
/* current_script_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_current_script_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
if (env->tx->numInputs <= env->ix) return false;
writeHash(dst, &env->tx->input[env->ix].txo.scriptPubKey);
return true;
}
/* current_sequence : ONE |- TWO^32 */
bool simplicity_bitcoin_current_sequence(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
if (env->tx->numInputs <= env->ix) return false;
simplicity_write32(dst, env->tx->input[env->ix].sequence);
return true;
}
/* current_script_sig_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_current_script_sig_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
if (env->tx->numInputs <= env->ix) return false;
writeHash(dst, &env->tx->input[env->ix].scriptSigHash);
return true;
}
/* current_annex_hash : ONE |- S (TWO^256) */
bool simplicity_bitcoin_current_annex_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
if (env->tx->numInputs <= env->ix) return false;
if (writeBit(dst, env->tx->input[env->ix].hasAnnex)) {
writeHash(dst, &env->tx->input[env->ix].annexHash);
} else {
skipBits(dst, 256);
}
return true;
}
/* tapleaf_version : ONE |- TWO^8 */
bool simplicity_bitcoin_tapleaf_version(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write8(dst, env->taproot->leafVersion);
return true;
}
/* tappath : TWO^8 |- S (TWO^256) */
bool simplicity_bitcoin_tappath(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast8_t i = simplicity_read8(&src);
if (writeBit(dst, i < env->taproot->pathLen)) {
writeHash(dst, &env->taproot->path[i]);
} else {
skipBits(dst, 256);
}
return true;
}
/* internal_key : ONE |- TWO^256 */
bool simplicity_bitcoin_internal_key(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->taproot->internalKey);
return true;
}
/* num_inputs : ONE |- TWO^32 */
bool simplicity_bitcoin_num_inputs(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write32(dst, env->tx->numInputs);
return true;
}
/* num_outputs : ONE |- TWO^32 */
bool simplicity_bitcoin_num_outputs(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write32(dst, env->tx->numOutputs);
return true;
}
/* tx_is_final : ONE |- TWO */
bool simplicity_bitcoin_tx_is_final(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeBit(dst, env->tx->isFinal);
return true;
}
/* tx_lock_height : ONE |- TWO^32 */
bool simplicity_bitcoin_tx_lock_height(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write32(dst, lockHeight(env->tx));
return true;
}
/* tx_lock_time : ONE |- TWO^32 */
bool simplicity_bitcoin_tx_lock_time(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
simplicity_write32(dst, lockTime(env->tx));
return true;
}
/* tx_lock_distance : ONE |- TWO^16 */
bool simplicity_bitcoin_tx_lock_distance(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
if (env->tx->numInputs <= env->ix) return false;
simplicity_write16(dst, lockDistance(env->tx, env->ix));
return true;
}
/* tx_lock_duration : ONE |- TWO^16 */
bool simplicity_bitcoin_tx_lock_duration(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
if (env->tx->numInputs <= env->ix) return false;
simplicity_write16(dst, lockDuration(env->tx, env->ix));
return true;
}
/* check_lock_height : TWO^32 |- ONE */
bool simplicity_bitcoin_check_lock_height(frameItem* dst, frameItem src, const txEnv* env) {
(void) dst; // dst is unused;
uint_fast32_t x = simplicity_read32(&src);
return x <= lockHeight(env->tx);
}
/* check_lock_time : TWO^32 |- ONE */
bool simplicity_bitcoin_check_lock_time(frameItem* dst, frameItem src, const txEnv* env) {
(void) dst; // dst is unused;
uint_fast32_t x = simplicity_read32(&src);
return x <= lockTime(env->tx);
}
/* check_lock_distance : TWO^16 |- ONE */
bool simplicity_bitcoin_check_lock_distance(frameItem* dst, frameItem src, const txEnv* env) {
(void) dst; // dst is unused;
if (env->tx->numInputs <= env->ix) return false;
uint_fast16_t x = simplicity_read16(&src);
return x <= lockDistance(env->tx, env->ix);
}
/* check_lock_duration : TWO^16 |- ONE */
bool simplicity_bitcoin_check_lock_duration(frameItem* dst, frameItem src, const txEnv* env) {
(void) dst; // dst is unused;
if (env->tx->numInputs <= env->ix) return false;
uint_fast16_t x = simplicity_read16(&src);
return x <= lockDuration(env->tx, env->ix);
}
/* build_tapleaf_simplicity : TWO^256 |- TWO^256 */
bool simplicity_bitcoin_build_tapleaf_simplicity(frameItem* dst, frameItem src, const txEnv* env) {
(void) env; // env is unused.
sha256_midstate cmr;
readHash(&cmr, &src);
sha256_midstate result = simplicity_bitcoin_make_tapleaf(0xbe, &cmr);
writeHash(dst, &result);
return true;
}
/* build_tapbranch : TWO^256 * TWO^256 |- TWO^256 */
bool simplicity_bitcoin_build_tapbranch(frameItem* dst, frameItem src, const txEnv* env) {
(void) env; // env is unused.
sha256_midstate a, b;
readHash(&a, &src);
readHash(&b, &src);
sha256_midstate result = simplicity_bitcoin_make_tapbranch(&a, &b);
writeHash(dst, &result);
return true;
}
/* build_taptweak : PUBKEY * TWO^256 |- PUBKEY */
bool simplicity_bitcoin_build_taptweak(frameItem* dst, frameItem src, const txEnv* env) {
(void) env; // env is unused.
static unsigned char taptweak[] = "TapTweak";
return simplicity_generic_taptweak(dst, &src, taptweak, sizeof(taptweak)-1);
}
/* outpoint_hash : CTX8 * TWO^256 * TWO^32 |- CTX8 */
bool simplicity_bitcoin_outpoint_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) env; // env is unused.
sha256_midstate midstate;
unsigned char buf[36];
sha256_context ctx = {.output = midstate.s};
/* Read a SHA-256 context. */
if (!simplicity_read_sha256_context(&ctx, &src)) return false;
/* Read an outpoint (hash and index). */
read8s(buf, 36, &src);
sha256_uchars(&ctx, buf, 36);
return simplicity_write_sha256_context(dst, &ctx);
}
/* annex_hash : CTX8 * S TWO^256 |- CTX8 */
bool simplicity_bitcoin_annex_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) env; // env is unused.
sha256_midstate midstate;
unsigned char buf[32];
sha256_context ctx = {.output = midstate.s};
/* Read a SHA-256 context. */
if (!simplicity_read_sha256_context(&ctx, &src)) return false;
/* Read an optional hash. (257 bits) */
if (readBit(&src)) {
/* Read a hash. (256 bits) */
read8s(buf, 32, &src);
sha256_uchar(&ctx, 0x01);
sha256_uchars(&ctx, buf, 32);
} else {
/* No hash. */
sha256_uchar(&ctx, 0x00);
}
return simplicity_write_sha256_context(dst, &ctx);
}
/* output_amounts_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_output_values_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->outputValuesHash);
return true;
}
/* output_scripts_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_output_scripts_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->outputScriptsHash);
return true;
}
/* outputs_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_outputs_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->outputsHash);
return true;
}
/* output_hash : TWO^32 |- S TWO^256 */
bool simplicity_bitcoin_output_hash(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numOutputs)) {
const sigOutput* output = &env->tx->output[i];
sha256_midstate midstate;
sha256_context ctx = sha256_init(midstate.s);
sha256_u64be(&ctx, output->value);
sha256_hash(&ctx, &output->scriptPubKey);
sha256_finalize(&ctx);
writeHash(dst, &midstate);
} else {
skipBits(dst, 256);
}
return true;
}
/* input_outpoints_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_input_outpoints_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->inputOutpointsHash);
return true;
}
/* input_values_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_input_values_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->inputValuesHash);
return true;
}
/* input_scripts_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_input_scripts_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->inputScriptsHash);
return true;
}
/* input_utxos_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_input_utxos_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->inputUTXOsHash);
return true;
}
/* input_utxo_hash : TWO^32 |- S TWO^256 */
bool simplicity_bitcoin_input_utxo_hash(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numInputs)) {
const sigOutput* txo = &env->tx->input[i].txo;
sha256_midstate midstate;
sha256_context ctx = sha256_init(midstate.s);
sha256_u64be(&ctx, txo->value);
sha256_hash(&ctx, &txo->scriptPubKey);
sha256_finalize(&ctx);
writeHash(dst, &midstate);
} else {
skipBits(dst, 256);
}
return true;
}
/* input_sequences_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_input_sequences_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->inputSequencesHash);
return true;
}
/* input_annexes_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_input_annexes_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->inputAnnexesHash);
return true;
}
/* input_script_sigs_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_input_script_sigs_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->inputScriptSigsHash);
return true;
}
/* inputs_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_inputs_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->inputsHash);
return true;
}
/* input_hash : TWO^32 |- S TWO^256 */
bool simplicity_bitcoin_input_hash(frameItem* dst, frameItem src, const txEnv* env) {
uint_fast32_t i = simplicity_read32(&src);
if (writeBit(dst, i < env->tx->numInputs)) {
const sigInput* input = &env->tx->input[i];
sha256_midstate midstate;
sha256_context ctx = sha256_init(midstate.s);
sha256_hash(&ctx, &input->prevOutpoint.txid);
sha256_u32be(&ctx, input->prevOutpoint.ix);
sha256_u32be(&ctx, input->sequence);
if (input->hasAnnex) {
sha256_uchar(&ctx, 1);
sha256_hash(&ctx, &input->annexHash);
} else {
sha256_uchar(&ctx, 0);
}
sha256_finalize(&ctx);
writeHash(dst, &midstate);
} else {
skipBits(dst, 256);
}
return true;
}
/* tx_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_tx_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->tx->txHash);
return true;
}
/* tapleaf_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_tapleaf_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->taproot->tapLeafHash);
return true;
}
/* tappath_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_tappath_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->taproot->tappathHash);
return true;
}
/* tap_env_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_tap_env_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->taproot->tapEnvHash);
return true;
}
/* sig_all_hash : ONE |- TWO^256 */
bool simplicity_bitcoin_sig_all_hash(frameItem* dst, frameItem src, const txEnv* env) {
(void) src; // src is unused;
writeHash(dst, &env->sigAllHash);
return true;
}
================================================
FILE: C/bitcoin/bitcoinJets.h
================================================
/* This module defines primitives and jets that are specific to the Bitcoin application for Simplicity.
*/
#ifndef SIMPLICITY_BITCOIN_BITCOINJETS_H
#define SIMPLICITY_BITCOIN_BITCOINJETS_H
#include "../jets.h"
/* Jets for the Bitcoin application of Simplicity. */
bool simplicity_bitcoin_version(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_lock_time(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_prev_outpoint(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_value(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_script_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_sequence(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_annex_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_script_sig_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_output_value(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_output_script_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_fee(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_total_input_value(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_total_output_value(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_script_cmr(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_transaction_id(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_current_index(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_current_prev_outpoint(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_current_value(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_current_script_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_current_sequence(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_current_annex_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_current_script_sig_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tapleaf_version(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tappath(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_internal_key(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_num_inputs(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_num_outputs(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tx_is_final(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tx_lock_height(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tx_lock_time(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tx_lock_distance(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tx_lock_duration(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_check_lock_height(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_check_lock_time(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_check_lock_distance(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_check_lock_duration(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_build_tapleaf_simplicity(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_build_tapbranch(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_build_taptweak(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_outpoint_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_annex_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_output_values_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_output_scripts_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_outputs_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_output_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_outpoints_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_values_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_scripts_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_utxos_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_utxo_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_sequences_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_annexes_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_script_sigs_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_inputs_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_input_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tx_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tapleaf_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tappath_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_tap_env_hash(frameItem* dst, frameItem src, const txEnv* env);
bool simplicity_bitcoin_sig_all_hash(frameItem* dst, frameItem src, const txEnv* env);
#endif
================================================
FILE: C/bitcoin/decodeBitcoinJets.inc
================================================
/* This file has been automatically generated. */
{
int32_t code;
code = simplicity_decodeUptoMaxInt(stream);
if (code < 0) return (simplicity_err)code;
switch (code) {
case 1:
code = simplicity_decodeUptoMaxInt(stream);
if (code < 0) return (simplicity_err)code;
switch (code) {
case 1: *result = SIG_ALL_HASH; return SIMPLICITY_NO_ERROR;
case 2: *result = TX_HASH; return SIMPLICITY_NO_ERROR;
case 3: *result = TAP_ENV_HASH; return SIMPLICITY_NO_ERROR;
case 4: *result = OUTPUTS_HASH; return SIMPLICITY_NO_ERROR;
case 5: *result = INPUTS_HASH; return SIMPLICITY_NO_ERROR;
case 6: *result = INPUT_UTXOS_HASH; return SIMPLICITY_NO_ERROR;
case 7: *result = OUTPUT_HASH; return SIMPLICITY_NO_ERROR;
case 8: *result = OUTPUT_VALUES_HASH; return SIMPLICITY_NO_ERROR;
case 9: *result = OUTPUT_SCRIPTS_HASH; return SIMPLICITY_NO_ERROR;
case 10: *result = INPUT_HASH; return SIMPLICITY_NO_ERROR;
case 11: *result = INPUT_OUTPOINTS_HASH; return SIMPLICITY_NO_ERROR;
case 12: *result = INPUT_SEQUENCES_HASH; return SIMPLICITY_NO_ERROR;
case 13: *result = INPUT_ANNEXES_HASH; return SIMPLICITY_NO_ERROR;
case 14: *result = INPUT_SCRIPT_SIGS_HASH; return SIMPLICITY_NO_ERROR;
case 15: *result = INPUT_UTXO_HASH; return SIMPLICITY_NO_ERROR;
case 16: *result = INPUT_VALUES_HASH; return SIMPLICITY_NO_ERROR;
case 17: *result = INPUT_SCRIPTS_HASH; return SIMPLICITY_NO_ERROR;
case 18: *result = TAPLEAF_HASH; return SIMPLICITY_NO_ERROR;
case 19: *result = TAPPATH_HASH; return SIMPLICITY_NO_ERROR;
case 20: *result = OUTPOINT_HASH; return SIMPLICITY_NO_ERROR;
case 21: *result = ANNEX_HASH; return SIMPLICITY_NO_ERROR;
case 22: *result = BUILD_TAPLEAF_SIMPLICITY; return SIMPLICITY_NO_ERROR;
case 23: *result = BUILD_TAPBRANCH; return SIMPLICITY_NO_ERROR;
case 24: *result = BUILD_TAPTWEAK; return SIMPLICITY_NO_ERROR;
}
break;
case 2:
code = simplicity_decodeUptoMaxInt(stream);
if (code < 0) return (simplicity_err)code;
switch (code) {
case 1: *result = CHECK_LOCK_HEIGHT; return SIMPLICITY_NO_ERROR;
case 2: *result = CHECK_LOCK_TIME; return SIMPLICITY_NO_ERROR;
case 3: *result = CHECK_LOCK_DISTANCE; return SIMPLICITY_NO_ERROR;
case 4: *result = CHECK_LOCK_DURATION; return SIMPLICITY_NO_ERROR;
case 5: *result = TX_LOCK_HEIGHT; return SIMPLICITY_NO_ERROR;
case 6: *result = TX_LOCK_TIME; return SIMPLICITY_NO_ERROR;
case 7: *result = TX_LOCK_DISTANCE; return SIMPLICITY_NO_ERROR;
case 8: *result = TX_LOCK_DURATION; return SIMPLICITY_NO_ERROR;
case 9: *result = TX_IS_FINAL; return SIMPLICITY_NO_ERROR;
}
break;
case 3:
code = simplicity_decodeUptoMaxInt(stream);
if (code < 0) return (simplicity_err)code;
switch (code) {
case 1: *result = SCRIPT_CMR; return SIMPLICITY_NO_ERROR;
case 2: *result = INTERNAL_KEY; return SIMPLICITY_NO_ERROR;
case 3: *result = CURRENT_INDEX; return SIMPLICITY_NO_ERROR;
case 4: *result = NUM_INPUTS; return SIMPLICITY_NO_ERROR;
case 5: *result = NUM_OUTPUTS; return SIMPLICITY_NO_ERROR;
case 6: *result = LOCK_TIME; return SIMPLICITY_NO_ERROR;
case 7: *result = FEE; return SIMPLICITY_NO_ERROR;
case 8: *result = OUTPUT_VALUE; return SIMPLICITY_NO_ERROR;
case 9: *result = OUTPUT_SCRIPT_HASH; return SIMPLICITY_NO_ERROR;
case 10: *result = TOTAL_OUTPUT_VALUE; return SIMPLICITY_NO_ERROR;
case 11: *result = CURRENT_PREV_OUTPOINT; return SIMPLICITY_NO_ERROR;
case 12: *result = CURRENT_VALUE; return SIMPLICITY_NO_ERROR;
case 13: *result = CURRENT_SCRIPT_HASH; return SIMPLICITY_NO_ERROR;
case 14: *result = CURRENT_SEQUENCE; return SIMPLICITY_NO_ERROR;
case 15: *result = CURRENT_ANNEX_HASH; return SIMPLICITY_NO_ERROR;
case 16: *result = CURRENT_SCRIPT_SIG_HASH; return SIMPLICITY_NO_ERROR;
case 17: *result = INPUT_PREV_OUTPOINT; return SIMPLICITY_NO_ERROR;
case 18: *result = INPUT_VALUE; return SIMPLICITY_NO_ERROR;
case 19: *result = INPUT_SCRIPT_HASH; return SIMPLICITY_NO_ERROR;
case 20: *result = INPUT_SEQUENCE; return SIMPLICITY_NO_ERROR;
case 21: *result = INPUT_ANNEX_HASH; return SIMPLICITY_NO_ERROR;
case 22: *result = INPUT_SCRIPT_SIG_HASH; return SIMPLICITY_NO_ERROR;
case 23: *result = TOTAL_INPUT_VALUE; return SIMPLICITY_NO_ERROR;
case 24: *result = TAPLEAF_VERSION; return SIMPLICITY_NO_ERROR;
case 25: *result = TAPPATH; return SIMPLICITY_NO_ERROR;
case 26: *result = VERSION; return SIMPLICITY_NO_ERROR;
case 27: *result = TRANSACTION_ID; return SIMPLICITY_NO_ERROR;
}
break;
}
}
================================================
FILE: C/bitcoin/env.c
================================================
#include <simplicity/bitcoin/env.h>
#include <stdalign.h>
#include <stddef.h>
#include <string.h>
#include "txEnv.h"
#include "ops.h"
#include "../sha256.h"
#include "../simplicity_assert.h"
#include "../simplicity_alloc.h"
#define PADDING(alignType, allocated) ((alignof(alignType) - (allocated) % alignof(alignType)) % alignof(alignType))
/* Compute the SHA-256 hash of a scriptPubKey and write it into 'result'.
*
* Precondition: NULL != result;
* NULL != scriptPubKey;
*/
static void hashBuffer(sha256_midstate* result, const rawBitcoinBuffer* buffer) {
sha256_context ctx = sha256_init(result->s);
sha256_uchars(&ctx, buffer->buf, buffer->len);
sha256_finalize(&ctx);
}
/* Initialize a 'sigOutput' from a 'rawOutput', copying or hashing the data as needed.
*
* Precondition: NULL != result;
* NULL != output;
*/
static void copyOutput(sigOutput* result, const rawBitcoinOutput* output) {
hashBuffer(&result->scriptPubKey, &output->scriptPubKey);
result->value = output->value;
}
/* Initialize a 'sigInput' from a 'rawBitcoinInput', copying or hashing the data as needed.
*
* Precondition: NULL != result;
* NULL != input;
*/
static void copyInput(sigInput* result, const rawBitcoinInput* input) {
*result = (sigInput){ .prevOutpoint = { .ix = input->prevIx }
, .sequence = input->sequence
, .hasAnnex = !!input->annex
};
if (input->annex) hashBuffer(&result->annexHash, input->annex);
sha256_toMidstate(result->prevOutpoint.txid.s, input->prevTxid);
copyOutput(&result->txo, &input->txo);
hashBuffer(&result->scriptSigHash, &input->scriptSig);
}
/* Allocate and initialize a 'bitcoinTransaction' from a 'rawBitcoinTransaction', copying or hashing the data as needed.
* Returns NULL if malloc fails (or if malloc cannot be called because we require an allocation larger than SIZE_MAX).
*
* Precondition: NULL != rawTx
*/
extern bitcoinTransaction* simplicity_bitcoin_mallocTransaction(const rawBitcoinTransaction* rawTx) {
if (!rawTx) return NULL;
size_t allocationSize = sizeof(bitcoinTransaction);
const size_t pad1 = PADDING(sigInput, allocationSize);
if (SIZE_MAX - allocationSize < pad1) return NULL;
allocationSize += pad1;
/* Multiply by (size_t)1 to disable type-limits warning. */
if (SIZE_MAX / sizeof(sigInput) < (size_t)1 * rawTx->numInputs) return NULL;
if (SIZE_MAX - allocationSize < rawTx->numInputs * sizeof(sigInput)) return NULL;
allocationSize += rawTx->numInputs * sizeof(sigInput);
const size_t pad2 = PADDING(sigOutput, allocationSize);
if (SIZE_MAX - allocationSize < pad2) return NULL;
allocationSize += pad2;
/* Multiply by (size_t)1 to disable type-limits warning. */
if (SIZE_MAX / sizeof(sigOutput) < (size_t)1 * rawTx->numOutputs) return NULL;
if (SIZE_MAX - allocationSize < rawTx->numOutputs * sizeof(sigOutput)) return NULL;
allocationSize += rawTx->numOutputs * sizeof(sigOutput);
char *allocation = simplicity_malloc(allocationSize);
if (!allocation) return NULL;
/* Casting through void* to avoid warning about pointer alignment.
* Our padding is done carefully to ensure alignment.
*/
bitcoinTransaction* const tx = (bitcoinTransaction*)(void*)allocation;
allocation += sizeof(bitcoinTransaction) + pad1;
sigInput* const input = (sigInput*)(void*)allocation;
allocation += rawTx->numInputs * sizeof(sigInput) + pad2;
sigOutput* const output = (sigOutput*)(void*)allocation;
*tx = (bitcoinTransaction){ .input = input
, .output = output
, .numInputs = rawTx->numInputs
, .numOutputs = rawTx->numOutputs
, .version = rawTx->version
, .lockTime = rawTx->lockTime
, .isFinal = true
};
sha256_toMidstate(tx->txid.s, rawTx->txid);
{
sha256_context ctx_inputOutpointsHash = sha256_init(tx->inputOutpointsHash.s);
sha256_context ctx_inputValuesHash = sha256_init(tx->inputValuesHash.s);
sha256_context ctx_inputScriptsHash = sha256_init(tx->inputScriptsHash.s);
sha256_context ctx_inputUTXOsHash = sha256_init(tx->inputUTXOsHash.s);
sha256_context ctx_inputSequencesHash = sha256_init(tx->inputSequencesHash.s);
sha256_context ctx_inputAnnexesHash = sha256_init(tx->inputAnnexesHash.s);
sha256_context ctx_inputScriptSigsHash = sha256_init(tx->inputScriptSigsHash.s);
sha256_context ctx_inputsHash = sha256_init(tx->inputsHash.s);
for (uint_fast32_t i = 0; i < tx->numInputs; ++i) {
copyInput(&input[i], &rawTx->input[i]);
tx->totalInputValue += input[i].txo.value;
if (input[i].sequence < 0xffffffff) { tx->isFinal = false; }
sha256_hash(&ctx_inputOutpointsHash, &input[i].prevOutpoint.txid);
sha256_u32be(&ctx_inputOutpointsHash, input[i].prevOutpoint.ix);
sha256_u64be(&ctx_inputValuesHash, input[i].txo.value);
sha256_hash(&ctx_inputScriptsHash, &input[i].txo.scriptPubKey);
sha256_u32be(&ctx_inputSequencesHash, input[i].sequence);
if (input[i].hasAnnex) {
sha256_uchar(&ctx_inputAnnexesHash, 1);
sha256_hash(&ctx_inputAnnexesHash, &input[i].annexHash);
} else {
sha256_uchar(&ctx_inputAnnexesHash, 0);
}
sha256_hash(&ctx_inputScriptSigsHash, &input[i].scriptSigHash);
}
sha256_finalize(&ctx_inputOutpointsHash);
sha256_finalize(&ctx_inputValuesHash);
sha256_finalize(&ctx_inputScriptsHash);
sha256_finalize(&ctx_inputSequencesHash);
sha256_finalize(&ctx_inputAnnexesHash);
sha256_finalize(&ctx_inputScriptSigsHash);
sha256_hash(&ctx_inputUTXOsHash, &tx->inputValuesHash);
sha256_hash(&ctx_inputUTXOsHash, &tx->inputScriptsHash);
sha256_finalize(&ctx_inputUTXOsHash);
sha256_hash(&ctx_inputsHash, &tx->inputOutpointsHash);
sha256_hash(&ctx_inputsHash, &tx->inputSequencesHash);
sha256_hash(&ctx_inputsHash, &tx->inputAnnexesHash);
sha256_finalize(&ctx_inputsHash);
}
{
sha256_context ctx_outputValuesHash = sha256_init(tx->outputValuesHash.s);
sha256_context ctx_outputScriptsHash = sha256_init(tx->outputScriptsHash.s);
sha256_context ctx_outputsHash = sha256_init(tx->outputsHash.s);
for (uint_fast32_t i = 0; i < tx->numOutputs; ++i) {
copyOutput(&output[i], &rawTx->output[i]);
tx->totalOutputValue += output[i].value;
sha256_u64be(&ctx_outputValuesHash, output[i].value);
sha256_hash(&ctx_outputScriptsHash, &output[i].scriptPubKey);
}
sha256_finalize(&ctx_outputValuesHash);
sha256_finalize(&ctx_outputScriptsHash);
sha256_hash(&ctx_outputsHash, &tx->outputValuesHash);
sha256_hash(&ctx_outputsHash, &tx->outputScriptsHash);
sha256_finalize(&ctx_outputsHash);
}
{
sha256_context ctx_txHash = sha256_init(tx->txHash.s);
sha256_u32be(&ctx_txHash, tx->version);
sha256_u32be(&ctx_txHash, tx->lockTime);
sha256_hash(&ctx_txHash, &tx->inputsHash);
sha256_hash(&ctx_txHash, &tx->outputsHash);
sha256_hash(&ctx_txHash, &tx->inputUTXOsHash);
sha256_finalize(&ctx_txHash);
}
return tx;
}
/* Free a pointer to 'bitcoinTransaction'.
*/
extern void simplicity_bitcoin_freeTransaction(bitcoinTransaction* tx) {
simplicity_free(tx);
}
/* Allocate and initialize a 'bitcoinTapEnv' from a 'rawBitcoinTapEnv', copying or hashing the data as needed.
* Returns NULL if malloc fails (or if malloc cannot be called because we require an allocation larger than SIZE_MAX).
*
* Precondition: *rawEnv is well-formed (i.e. rawEnv->pathLen <= 128.)
*/
extern bitcoinTapEnv* simplicity_bitcoin_mallocTapEnv(const rawBitcoinTapEnv* rawEnv) {
if (!rawEnv) return NULL;
if (128 < rawEnv->pathLen) return NULL;
size_t allocationSize = sizeof(bitcoinTapEnv);
const size_t numMidstate = rawEnv->pathLen;
const size_t pad1 = PADDING(sha256_midstate, allocationSize);
if (numMidstate) {
if (SIZE_MAX - allocationSize < pad1) return NULL;
allocationSize += pad1;
if (SIZE_MAX / sizeof(sha256_midstate) < numMidstate) return NULL;
if (SIZE_MAX - allocationSize < numMidstate * sizeof(sha256_midstate)) return NULL;
allocationSize += numMidstate * sizeof(sha256_midstate);
}
char *allocation = simplicity_malloc(allocationSize);
if (!allocation) return NULL;
/* Casting through void* to avoid warning about pointer alignment.
* Our padding is done carefully to ensure alignment.
*/
bitcoinTapEnv* const env = (bitcoinTapEnv*)(void*)allocation;
sha256_midstate* path = NULL;
sha256_midstate internalKey;
sha256_toMidstate(internalKey.s, &rawEnv->controlBlock[1]);
if (numMidstate) {
allocation += sizeof(bitcoinTapEnv) + pad1;
if (rawEnv->pathLen) {
path = (sha256_midstate*)(void*)allocation;
}
}
*env = (bitcoinTapEnv){ .leafVersion = rawEnv->controlBlock[0] & 0xfe
, .internalKey = internalKey
, .path = path
, .pathLen = rawEnv->pathLen
};
sha256_toMidstate(env->scriptCMR.s, rawEnv->scriptCMR);
{
sha256_context ctx = sha256_init(env->tappathHash.s);
for (int i = 0; i < env->pathLen; ++i) {
sha256_toMidstate(path[i].s, &rawEnv->controlBlock[33+32*i]);
sha256_hash(&ctx, &path[i]);
}
sha256_finalize(&ctx);
}
env->tapLeafHash = simplicity_bitcoin_make_tapleaf(env->leafVersion, &env->scriptCMR);
{
sha256_context ctx = sha256_init(env->tapEnvHash.s);
sha256_hash(&ctx, &env->tapLeafHash);
sha256_hash(&ctx, &env->tappathHash);
sha256_hash(&ctx, &env->internalKey);
sha256_finalize(&ctx);
}
return env;
}
/* Free a pointer to 'bitcoinTapEnv'.
*/
extern void simplicity_bitcoin_freeTapEnv(bitcoinTapEnv* env) {
simplicity_free(env);
}
================================================
FILE: C/bitcoin/ops.c
================================================
#include "ops.h"
/* Compute Bitcoins's tapleaf hash from a tapleaf version and a 256-bit script value.
* A reimplementation of ComputeTapleafHash from Bitcoin's 'interpreter.cpp'.
* Only 256-bit script values are supported as that is the size used for Simplicity CMRs.
*
* Precondition: NULL != cmr;
*/
sha256_midstate simplicity_bitcoin_make_tapleaf(unsigned char version, const sha256_midstate* cmr) {
sha256_midstate result;
sha256_midstate tapleafTag;
{
static unsigned char tagName[] = "TapLeaf";
sha256_context ctx = sha256_init(tapleafTag.s);
sha256_uchars(&ctx, tagName, sizeof(tagName) - 1);
sha256_finalize(&ctx);
}
sha256_context ctx = sha256_init(result.s);
sha256_hash(&ctx, &tapleafTag);
sha256_hash(&ctx, &tapleafTag);
sha256_uchar(&ctx, version);
sha256_uchar(&ctx, 32);
sha256_hash(&ctx, cmr);
sha256_finalize(&ctx);
return result;
}
/* Compute Bitcoins's tapbrach hash from two branches.
*
* Precondition: NULL != a;
* NULL != b;
*/
sha256_midstate simplicity_bitcoin_make_tapbranch(const sha256_midstate* a, const sha256_midstate* b) {
sha256_midstate result;
sha256_midstate tapbranchTag;
{
static unsigned char tagName[] = "TapBranch";
sha256_context ctx = sha256_init(tapbranchTag.s);
sha256_uchars(&ctx, tagName, sizeof(tagName) - 1);
sha256_finalize(&ctx);
}
sha256_context ctx = sha256_init(result.s);
sha256_hash(&ctx, &tapbranchTag);
sha256_hash(&ctx, &tapbranchTag);
if (sha256_cmp_be(a, b) < 0) {
sha256_hash(&ctx, a);
sha256_hash(&ctx, b);
} else {
sha256_hash(&ctx, b);
sha256_hash(&ctx, a);
}
sha256_finalize(&ctx);
return result;
}
================================================
FILE: C/bitcoin/ops.h
================================================
/* This module defines operations used in the construction the environment ('txEnv') and some jets.
*/
#ifndef SIMPLICITY_BITCOIN_OPS_H
#define SIMPLICITY_BITCOIN_OPS_H
#include "../sha256.h"
/* Compute Bitcoin's tapleaf hash from a tapleaf version and a 256-bit script value.
* A reimplementation of ComputeTapleafHash from Bitcoin's 'interpreter.cpp'.
* Only 256-bit script values are supported as that is the size used for Simplicity CMRs.
*
* Precondition: NULL != cmr;
*/
sha256_midstate simplicity_bitcoin_make_tapleaf(unsigned char version, const sha256_midstate* cmr);
/* Compute an Bitcoin's tapbrach hash from two branches.
*
* Precondition: NULL != a;
* NULL != b;
*/
sha256_midstate simplicity_bitcoin_make_tapbranch(const sha256_midstate* a, const sha256_midstate* b);
#endif
================================================
FILE: C/bitcoin/primitive.c
================================================
/* This module implements the 'primitive.h' interface for the Bitcoin application of Simplicity.
*/
#include "primitive.h"
#include "bitcoinJets.h"
#include "../limitations.h"
#include "../simplicity_alloc.h"
#include "../simplicity_assert.h"
/* An enumeration of all the types we need to construct to specify the input and output types of all jets created by 'decodeJet'. */
enum TypeNamesForJets {
#include "primitiveEnumTy.inc"
NumberOfTypeNames
};
/* Allocate a fresh set of unification variables bound to at least all the types necessary
* for all the jets that can be created by 'decodeJet', and also the type 'TWO^256',
* and also allocate space for 'extra_var_len' many unification variables.
* Return the number of non-trivial bindings created.
*
* However, if malloc fails, then return 0.
*
* Precondition: NULL != bound_var;
* NULL != word256_ix;
* NULL != extra_var_start;
* extra_var_len <= 6*DAG_LEN_MAX;
*
* Postcondition: Either '*bound_var == NULL' and the function returns 0
* or 'unification_var (*bound_var)[*extra_var_start + extra_var_len]' is an array of unification variables
* such that for any 'jet : A |- B' there is some 'i < *extra_var_start' and 'j < *extra_var_start' such that
* '(*bound_var)[i]' is bound to 'A' and '(*bound_var)[j]' is bound to 'B'
* and, '*word256_ix < *extra_var_start' and '(*bound_var)[*word256_ix]' is bound the type 'TWO^256'
*/
size_t simplicity_bitcoin_mallocBoundVars(unification_var** bound_var, size_t* word256_ix, size_t* extra_var_start, size_t extra_var_len) {
static_assert(1 <= NumberOfTypeNames, "Missing TypeNamesForJets.");
static_assert(NumberOfTypeNames <= NUMBER_OF_TYPENAMES_MAX, "Too many TypeNamesForJets.");
static_assert(DAG_LEN_MAX <= (SIZE_MAX - NumberOfTypeNames) / 6, "NumberOfTypeNames + 6*DAG_LEN_MAX doesn't fit in size_t");
static_assert(NumberOfTypeNames + 6*DAG_LEN_MAX <= SIZE_MAX/sizeof(unification_var) , "bound_var array too large");
static_assert(NumberOfTypeNames + 6*DAG_LEN_MAX - 1 <= UINT32_MAX, "bound_var array index doesn't fit in uint32_t");
simplicity_assert(extra_var_len <= 6*DAG_LEN_MAX);
*bound_var = simplicity_malloc((NumberOfTypeNames + extra_var_len) * sizeof(unification_var));
if (!(*bound_var)) return 0;
#include "primitiveInitTy.inc"
*word256_ix = ty_w256;
*extra_var_start = NumberOfTypeNames;
/* 'ty_u' is a trivial binding, so we made 'NumberOfTypeNames - 1' non-trivial bindings. */
return NumberOfTypeNames - 1;
};
/* An enumeration of the names of Bitcoin specific jets and primitives. */
typedef enum jetName
{
#include "primitiveEnumJet.inc"
NUMBER_OF_JET_NAMES
} jetName;
/* Decode an Bitcoin specific jet name from 'stream' into 'result'.
* All jets begin with a bit prefix of '1' which needs to have already been consumed from the 'stream'.
* Returns 'SIMPLICITY_ERR_DATA_OUT_OF_RANGE' if the stream's prefix doesn't match any valid code for a jet.
* Returns 'SIMPLICITY_ERR_BITSTRING_EOF' if not enough bits are available in the 'stream'.
* In the above error cases, 'result' may be modified.
* Returns 'SIMPLICITY_NO_ERROR' if successful.
*
* Precondition: NULL != result
* NULL != stream
*/
static simplicity_err decodePrimitive(jetName* result, bitstream* stream) {
int32_t bit = read1Bit(stream);
if (bit < 0) return (simplicity_err)bit;
if (!bit) {
/* Core jets */
#include "../decodeCoreJets.inc"
return SIMPLICITY_ERR_DATA_OUT_OF_RANGE;
} else {
/* Bitcoin jets */
#include "decodeBitcoinJets.inc"
return SIMPLICITY_ERR_DATA_OUT_OF_RANGE;
}
}
/* Return a copy of the Simplicity node corresponding to the given Bitcoin specific jet 'name'. */
static dag_node jetNode(jetName name) {
static const dag_node jet_node[] = {
#include "primitiveJetNode.inc"
};
return jet_node[name];
}
/* Decode a Bitcoin specific jet from 'stream' into 'node'.
* All jets begin with a bit prefix of '1' which needs to have already been consumed from the 'stream'.
* Returns 'SIMPLICITY_ERR_DATA_OUT_OF_RANGE' if the stream's prefix doesn't match any valid code for a jet.
* Returns 'SIMPLICITY_ERR_BITSTRING_EOF' if not enough bits are available in the 'stream'.
* In the above error cases, 'dag' may be modified.
* Returns 'SIMPLICITY_NO_ERR' if successful.
*
* Precondition: NULL != node
* NULL != stream
*/
simplicity_err simplicity_bitcoin_decodeJet(dag_node* node, bitstream* stream) {
jetName name;
simplicity_err error = decodePrimitive(&name, stream);
if (!IS_OK(error)) return error;
*node = jetNode(name);
return SIMPLICITY_NO_ERROR;
}
================================================
FILE: C/bitcoin/primitive.h
================================================
/* Implements the primitive.h interface for the Bitcoin Simplicity application.
*/
#ifndef SIMPLICITY_BITCOIN_PRIMITIVE_H
#define SIMPLICITY_BITCOIN_PRIMITIVE_H
#include "../bitstream.h"
#include "../typeInference.h"
/* Allocate a fresh set of unification variables bound to at least all the types necessary
* for all the jets that can be created by 'decodeJet', and also the type 'TWO^256',
* and also allocate space for 'extra_var_len' many unification variables.
* Return the number of non-trivial bindings created.
*
* However, if malloc fails, then return 0.
*
* Precondition: NULL != bound_var;
* NULL != word256_ix;
* NULL != extra_var_start;
* extra_var_len <= 6*DAG_LEN_MAX;
*
* Postcondition: Either '*bound_var == NULL' and the function returns 0
* or 'unification_var (*bound_var)[*extra_var_start + extra_var_len]' is an array of unification variables
* such that for any 'jet : A |- B' there is some 'i < *extra_var_start' and 'j < *extra_var_start' such that
* '(*bound_var)[i]' is bound to 'A' and '(*bound_var)[j]' is bound to 'B'
* and, '*word256_ix < *extra_var_start' and '(*bound_var)[*word256_ix]' is bound the type 'TWO^256'
*/
size_t simplicity_bitcoin_mallocBoundVars(unification_var** bound_var, size_t* word256_ix, size_t* extra_var_start, size_t extra_var_len);
/* Decode a Bitcoin specific jet from 'stream' into 'node'.
* All jets begin with a bit prefix of '1' which needs to have already been consumed from the 'stream'.
* Returns 'SIMPLICITY_ERR_DATA_OUT_OF_RANGE' if the stream's prefix doesn't match any valid code for a jet.
* Returns 'SIMPLICITY_ERR_BITSTRING_EOF' if not enough bits are available in the 'stream'.
* In the above error cases, 'dag' may be modified.
* Returns 'SIMPLICITY_NO_ERROR' if successful.
*
* Precondition: NULL != node
* NULL != stream
*/
simplicity_err simplicity_bitcoin_decodeJet(dag_node* node, bitstream* stream);
#endif
================================================
FILE: C/bitcoin/primitiveEnumJet.inc
================================================
/* This file has been automatically generated. */
ADD_16,
ADD_32,
ADD_64,
ADD_8,
ALL_16,
ALL_32,
ALL_64,
ALL_8,
AND_1,
AND_16,
AND_32,
AND_64,
AND_8,
ANNEX_HASH,
BIP_0340_VERIFY,
BUILD_TAPBRANCH,
BUILD_TAPLEAF_SIMPLICITY,
BUILD_TAPTWEAK,
CH_1,
CH_16,
CH_32,
CH_64,
CH_8,
CHECK_LOCK_DISTANCE,
CHECK_LOCK_DURATION,
CHECK_LOCK_HEIGHT,
CHECK_LOCK_TIME,
CHECK_SIG_VERIFY,
COMPLEMENT_1,
COMPLEMENT_16,
COMPLEMENT_32,
COMPLEMENT_64,
COMPLEMENT_8,
CURRENT_ANNEX_HASH,
CURRENT_INDEX,
CURRENT_PREV_OUTPOINT,
CURRENT_SCRIPT_HASH,
CURRENT_SCRIPT_SIG_HASH,
CURRENT_SEQUENCE,
CURRENT_VALUE,
DECOMPRESS,
DECREMENT_16,
DECREMENT_32,
DECREMENT_64,
DECREMENT_8,
DIV_MOD_128_64,
DIV_MOD_16,
DIV_MOD_32,
DIV_MOD_64,
DIV_MOD_8,
DIVIDE_16,
DIVIDE_32,
DIVIDE_64,
DIVIDE_8,
DIVIDES_16,
DIVIDES_32,
DIVIDES_64,
DIVIDES_8,
EQ_1,
EQ_16,
EQ_256,
EQ_32,
EQ_64,
EQ_8,
FE_ADD,
FE_INVERT,
FE_IS_ODD,
FE_IS_ZERO,
FE_MULTIPLY,
FE_MULTIPLY_BETA,
FE_NEGATE,
FE_NORMALIZE,
FE_SQUARE,
FE_SQUARE_ROOT,
FEE,
FULL_ADD_16,
FULL_ADD_32,
FULL_ADD_64,
FULL_ADD_8,
FULL_DECREMENT_16,
FULL_DECREMENT_32,
FULL_DECREMENT_64,
FULL_DECREMENT_8,
FULL_INCREMENT_16,
FULL_INCREMENT_32,
FULL_INCREMENT_64,
FULL_INCREMENT_8,
FULL_LEFT_SHIFT_16_1,
FULL_LEFT_SHIFT_16_2,
FULL_LEFT_SHIFT_16_4,
FULL_LEFT_SHIFT_16_8,
FULL_LEFT_SHIFT_32_1,
FULL_LEFT_SHIFT_32_16,
FULL_LEFT_SHIFT_32_2,
FULL_LEFT_SHIFT_32_4,
FULL_LEFT_SHIFT_32_8,
FULL_LEFT_SHIFT_64_1,
FULL_LEFT_SHIFT_64_16,
FULL_LEFT_SHIFT_64_2,
FULL_LEFT_SHIFT_64_32,
FULL_LEFT_SHIFT_64_4,
FULL_LEFT_SHIFT_64_8,
FULL_LEFT_SHIFT_8_1,
FULL_LEFT_SHIFT_8_2,
FULL_LEFT_SHIFT_8_4,
FULL_MULTIPLY_16,
FULL_MULTIPLY_32,
FULL_MULTIPLY_64,
FULL_MULTIPLY_8,
FULL_RIGHT_SHIFT_16_1,
FULL_RIGHT_SHIFT_16_2,
FULL_RIGHT_SHIFT_16_4,
FULL_RIGHT_SHIFT_16_8,
FULL_RIGHT_SHIFT_32_1,
FULL_RIGHT_SHIFT_32_16,
FULL_RIGHT_SHIFT_32_2,
FULL_RIGHT_SHIFT_32_4,
FULL_RIGHT_SHIFT_32_8,
FULL_RIGHT_SHIFT_64_1,
FULL_RIGHT_SHIFT_64_16,
FULL_RIGHT_SHIFT_64_2,
FULL_RIGHT_SHIFT_64_32,
FULL_RIGHT_SHIFT_64_4,
FULL_RIGHT_SHIFT_64_8,
FULL_RIGHT_SHIFT_8_1,
FULL_RIGHT_SHIFT_8_2,
FULL_RIGHT_SHIFT_8_4,
FULL_SUBTRACT_16,
FULL_SUBTRACT_32,
FULL_SUBTRACT_64,
FULL_SUBTRACT_8,
GE_IS_ON_CURVE,
GE_NEGATE,
GEJ_ADD,
GEJ_DOUBLE,
GEJ_EQUIV,
GEJ_GE_ADD,
GEJ_GE_ADD_EX,
GEJ_GE_EQUIV,
GEJ_INFINITY,
GEJ_IS_INFINITY,
GEJ_IS_ON_CURVE,
GEJ_NEGATE,
GEJ_NORMALIZE,
GEJ_RESCALE,
GEJ_X_EQUIV,
GEJ_Y_IS_ODD,
GENERATE,
HASH_TO_CURVE,
HIGH_1,
HIGH_16,
HIGH_32,
HIGH_64,
HIGH_8,
INCREMENT_16,
INCREMENT_32,
INCREMENT_64,
INCREMENT_8,
INPUT_ANNEX_HASH,
INPUT_ANNEXES_HASH,
INPUT_HASH,
INPUT_OUTPOINTS_HASH,
INPUT_PREV_OUTPOINT,
INPUT_SCRIPT_HASH,
INPUT_SCRIPT_SIG_HASH,
INPUT_SCRIPT_SIGS_HASH,
INPUT_SCRIPTS_HASH,
INPUT_SEQUENCE,
INPUT_SEQUENCES_HASH,
INPUT_UTXO_HASH,
INPUT_UTXOS_HASH,
INPUT_VALUE,
INPUT_VALUES_HASH,
INPUTS_HASH,
INTERNAL_KEY,
IS_ONE_16,
IS_ONE_32,
IS_ONE_64,
IS_ONE_8,
IS_ZERO_16,
IS_ZERO_32,
IS_ZERO_64,
IS_ZERO_8,
LE_16,
LE_32,
LE_64,
LE_8,
LEFT_EXTEND_16_32,
LEFT_EXTEND_16_64,
LEFT_EXTEND_1_16,
LEFT_EXTEND_1_32,
LEFT_EXTEND_1_64,
LEFT_EXTEND_1_8,
LEFT_EXTEND_32_64,
LEFT_EXTEND_8_16,
LEFT_EXTEND_8_32,
LEFT_EXTEND_8_64,
LEFT_PAD_HIGH_16_32,
LEFT_PAD_HIGH_16_64,
LEFT_PAD_HIGH_1_16,
LEFT_PAD_HIGH_1_32,
LEFT_PAD_HIGH_1_64,
LEFT_PAD_HIGH_1_8,
LEFT_PAD_HIGH_32_64,
LEFT_PAD_HIGH_8_16,
LEFT_PAD_HIGH_8_32,
LEFT_PAD_HIGH_8_64,
LEFT_PAD_LOW_16_32,
LEFT_PAD_LOW_16_64,
LEFT_PAD_LOW_1_16,
LEFT_PAD_LOW_1_32,
LEFT_PAD_LOW_1_64,
LEFT_PAD_LOW_1_8,
LEFT_PAD_LOW_32_64,
LEFT_PAD_LOW_8_16,
LEFT_PAD_LOW_8_32,
LEFT_PAD_LOW_8_64,
LEFT_ROTATE_16,
LEFT_ROTATE_32,
LEFT_ROTATE_64,
LEFT_ROTATE_8,
LEFT_SHIFT_16,
LEFT_SHIFT_32,
LEFT_SHIFT_64,
LEFT_SHIFT_8,
LEFT_SHIFT_WITH_16,
LEFT_SHIFT_WITH_32,
LEFT_SHIFT_WITH_64,
LEFT_SHIFT_WITH_8,
LEFTMOST_16_1,
LEFTMOST_16_2,
LEFTMOST_16_4,
LEFTMOST_16_8,
LEFTMOST_32_1,
LEFTMOST_32_16,
LEFTMOST_32_2,
LEFTMOST_32_4,
LEFTMOST_32_8,
LEFTMOST_64_1,
LEFTMOST_64_16,
LEFTMOST_64_2,
LEFTMOST_64_32,
LEFTMOST_64_4,
LEFTMOST_64_8,
LEFTMOST_8_1,
LEFTMOST_8_2,
LEFTMOST_8_4,
LINEAR_COMBINATION_1,
LINEAR_VERIFY_1,
LOCK_TIME,
LOW_1,
LOW_16,
LOW_32,
LOW_64,
LOW_8,
LT_16,
LT_32,
LT_64,
LT_8,
MAJ_1,
MAJ_16,
MAJ_32,
MAJ_64,
MAJ_8,
MAX_16,
MAX_32,
MAX_64,
MAX_8,
MEDIAN_16,
MEDIAN_32,
MEDIAN_64,
MEDIAN_8,
MIN_16,
MIN_32,
MIN_64,
MIN_8,
MODULO_16,
MODULO_32,
MODULO_64,
MODULO_8,
MULTIPLY_16,
MULTIPLY_32,
MULTIPLY_64,
MULTIPLY_8,
NEGATE_16,
NEGATE_32,
NEGATE_64,
NEGATE_8,
NUM_INPUTS,
NUM_OUTPUTS,
ONE_16,
ONE_32,
ONE_64,
ONE_8,
OR_1,
OR_16,
OR_32,
OR_64,
OR_8,
OUTPOINT_HASH,
OUTPUT_HASH,
OUTPUT_SCRIPT_HASH,
OUTPUT_SCRIPTS_HASH,
OUTPUT_VALUE,
OUTPUT_VALUES_HASH,
OUTPUTS_HASH,
PARSE_LOCK,
PARSE_SEQUENCE,
POINT_VERIFY_1,
RIGHT_EXTEND_16_32,
RIGHT_EXTEND_16_64,
RIGHT_EXTEND_32_64,
RIGHT_EXTEND_8_16,
RIGHT_EXTEND_8_32,
RIGHT_EXTEND_8_64,
RIGHT_PAD_HIGH_16_32,
RIGHT_PAD_HIGH_16_64,
RIGHT_PAD_HIGH_1_16,
RIGHT_PAD_HIGH_1_32,
RIGHT_PAD_HIGH_1_64,
RIGHT_PAD_HIGH_1_8,
RIGHT_PAD_HIGH_32_64,
RIGHT_PAD_HIGH_8_16,
RIGHT_PAD_HIGH_8_32,
RIGHT_PAD_HIGH_8_64,
RIGHT_PAD_LOW_16_32,
RIGHT_PAD_LOW_16_64,
RIGHT_PAD_LOW_1_16,
RIGHT_PAD_LOW_1_32,
RIGHT_PAD_LOW_1_64,
RIGHT_PAD_LOW_1_8,
RIGHT_PAD_LOW_32_64,
RIGHT_PAD_LOW_8_16,
RIGHT_PAD_LOW_8_32,
RIGHT_PAD_LOW_8_64,
RIGHT_ROTATE_16,
RIGHT_ROTATE_32,
RIGHT_ROTATE_64,
RIGHT_ROTATE_8,
RIGHT_SHIFT_16,
RIGHT_SHIFT_32,
RIGHT_SHIFT_64,
RIGHT_SHIFT_8,
RIGHT_SHIFT_WITH_16,
RIGHT_SHIFT_WITH_32,
RIGHT_SHIFT_WITH_64,
RIGHT_SHIFT_WITH_8,
RIGHTMOST_16_1,
RIGHTMOST_16_2,
RIGHTMOST_16_4,
RIGHTMOST_16_8,
RIGHTMOST_32_1,
RIGHTMOST_32_16,
RIGHTMOST_32_2,
RIGHTMOST_32_4,
RIGHTMOST_32_8,
RIGHTMOST_64_1,
RIGHTMOST_64_16,
RIGHTMOST_64_2,
RIGHTMOST_64_32,
RIGHTMOST_64_4,
RIGHTMOST_64_8,
RIGHTMOST_8_1,
RIGHTMOST_8_2,
RIGHTMOST_8_4,
SCALAR_ADD,
SCALAR_INVERT,
SCALAR_IS_ZERO,
SCALAR_MULTIPLY,
SCALAR_MULTIPLY_LAMBDA,
SCALAR_NEGATE,
SCALAR_NORMALIZE,
SCALAR_SQUARE,
SCALE,
SCRIPT_CMR,
SHA_256_BLOCK,
SHA_256_CTX_8_ADD_1,
SHA_256_CTX_8_ADD_128,
SHA_256_CTX_8_ADD_16,
SHA_256_CTX_8_ADD_2,
SHA_256_CTX_8_ADD_256,
SHA_256_CTX_8_ADD_32,
SHA_256_CTX_8_ADD_4,
SHA_256_CTX_8_ADD_512,
SHA_256_CTX_8_ADD_64,
SHA_256_CTX_8_ADD_8,
SHA_256_CTX_8_ADD_BUFFER_511,
SHA_256_CTX_8_FINALIZE,
SHA_256_CTX_8_INIT,
SHA_256_IV,
SIG_ALL_HASH,
SOME_1,
SOME_16,
SOME_32,
SOME_64,
SOME_8,
SUBTRACT_16,
SUBTRACT_32,
SUBTRACT_64,
SUBTRACT_8,
SWU,
TAP_ENV_HASH,
TAPDATA_INIT,
TAPLEAF_HASH,
TAPLEAF_VERSION,
TAPPATH,
TAPPATH_HASH,
TOTAL_INPUT_VALUE,
TOTAL_OUTPUT_VALUE,
TRANSACTION_ID,
TX_HASH,
TX_IS_FINAL,
TX_LOCK_DISTANCE,
TX_LOCK_DURATION,
TX_LOCK_HEIGHT,
TX_LOCK_TIME,
VERIFY,
VERSION,
XOR_1,
XOR_16,
XOR_32,
XOR_64,
XOR_8,
XOR_XOR_1,
XOR_XOR_16,
XOR_XOR_32,
XOR_XOR_64,
XOR_XOR_8,
================================================
FILE: C/bitcoin/primitiveEnumTy.inc
================================================
/* This file has been automatically generated. */
ty_u = 0,
ty_b = 1,
ty_w2 = 2,
ty_w4 = 3,
ty_w8 = 4,
ty_w16 = 5,
ty_w32 = 6,
ty_w64 = 7,
ty_w128 = 8,
ty_w256 = 9,
ty_w512 = 10,
ty_w1Ki = 11,
ty_w2Ki = 12,
ty_w4Ki = 13,
ty_w8Ki = 14,
ty_w16Ki = 15,
ty_w32Ki = 16,
ty_w64Ki = 17,
ty_w128Ki = 18,
ty_w256Ki = 19,
ty_w512Ki = 20,
ty_w1Mi = 21,
ty_w2Mi = 22,
ty_w4Mi = 23,
ty_w8Mi = 24,
ty_w16Mi = 25,
ty_w32Mi = 26,
ty_w64Mi = 27,
ty_w128Mi = 28,
ty_w256Mi = 29,
ty_w512Mi = 30,
ty_w1Gi = 31,
ty_w2Gi = 32,
ty_mw8,
ty_mw16,
ty_mw32,
ty_mw64,
ty_mw128,
ty_mw256,
ty_mw512,
ty_mw1Ki,
ty_mw2Ki,
ty_mmw256,
ty_msw16w16,
ty_mpw256w32,
ty_sw16w16,
ty_sw32w32,
ty_pbw2,
ty_pbw8,
ty_pbw16,
ty_pbw32,
ty_pbw64,
ty_pbw128,
ty_pbw256,
ty_pbpw4w8,
ty_pbpw4w16,
ty_pbpw8w32,
ty_pbpw8w64,
ty_pw2w8,
ty_pw2w16,
ty_pw2w32,
ty_pw2w64,
ty_pw4w8,
ty_pw4w16,
ty_pw4w32,
ty_pw4w64,
ty_pw8b,
ty_pw8w2,
ty_pw8w4,
ty_pw8w16,
ty_pw8w32,
ty_pw8w64,
ty_pw16b,
ty_pw16w2,
ty_pw16w4,
ty_pw16w8,
ty_pw16w32,
ty_pw16w64,
ty_pw32b,
ty_pw32w2,
ty_pw32w4,
ty_pw32w8,
ty_pw32w16,
ty_pw32w64,
ty_pw64b,
ty_pw64w2,
ty_pw64w4,
ty_pw64w8,
ty_pw64w16,
ty_pw64w32,
ty_pw64w128,
ty_pw64w256,
ty_pw128w64,
ty_pw256w32,
ty_pw256w512,
ty_pw256pbw256,
ty_pw256pw512w256,
ty_pw512w256,
ty_pmw16mw8,
ty_pmw32pmw16mw8,
ty_pmw64pmw32pmw16mw8,
ty_pmw128pmw64pmw32pmw16mw8,
ty_pmw256pmw128pmw64pmw32pmw16mw8,
ty_pmw512pmw256pmw128pmw64pmw32pmw16mw8,
ty_pmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8,
ty_pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8,
ty_ppw256w512w256,
ty_ppw256w512w512,
ty_ppw256pbw256w256,
ty_ppw256pw512w256w256,
ty_ppw512w256w256,
ty_ppw512w256w512,
ty_ppw512w256pw512w256,
ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256,
ty_pppw256w512w256w512,
ty_pppw256pbw256w256pbw256,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w8,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w16,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w32,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w64,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w128,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w256,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w512,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w1Ki,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w2Ki,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w4Ki,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256mw256,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pw256w32,
ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8,
================================================
FILE: C/bitcoin/primitiveInitTy.inc
================================================
/* This file has been automatically generated. */
(*bound_var)[ty_u] = (unification_var){ .isBound = true, .bound = { .kind = ONE }};
(*bound_var)[ty_b] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_u] } }};
(*bound_var)[ty_w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_b] } }};
(*bound_var)[ty_w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w2] } }};
(*bound_var)[ty_w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w4] } }};
(*bound_var)[ty_w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w8] } }};
(*bound_var)[ty_w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_w128] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w128], &(*bound_var)[ty_w128] } }};
(*bound_var)[ty_w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_w1Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w512], &(*bound_var)[ty_w512] } }};
(*bound_var)[ty_w2Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w1Ki], &(*bound_var)[ty_w1Ki] } }};
(*bound_var)[ty_w4Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2Ki], &(*bound_var)[ty_w2Ki] } }};
(*bound_var)[ty_w8Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4Ki], &(*bound_var)[ty_w4Ki] } }};
(*bound_var)[ty_w16Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8Ki], &(*bound_var)[ty_w8Ki] } }};
(*bound_var)[ty_w32Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16Ki], &(*bound_var)[ty_w16Ki] } }};
(*bound_var)[ty_w64Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32Ki], &(*bound_var)[ty_w32Ki] } }};
(*bound_var)[ty_w128Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64Ki], &(*bound_var)[ty_w64Ki] } }};
(*bound_var)[ty_w256Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w128Ki], &(*bound_var)[ty_w128Ki] } }};
(*bound_var)[ty_w512Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256Ki], &(*bound_var)[ty_w256Ki] } }};
(*bound_var)[ty_w1Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w512Ki], &(*bound_var)[ty_w512Ki] } }};
(*bound_var)[ty_w2Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w1Mi], &(*bound_var)[ty_w1Mi] } }};
(*bound_var)[ty_w4Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2Mi], &(*bound_var)[ty_w2Mi] } }};
(*bound_var)[ty_w8Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4Mi], &(*bound_var)[ty_w4Mi] } }};
(*bound_var)[ty_w16Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8Mi], &(*bound_var)[ty_w8Mi] } }};
(*bound_var)[ty_w32Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16Mi], &(*bound_var)[ty_w16Mi] } }};
(*bound_var)[ty_w64Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32Mi], &(*bound_var)[ty_w32Mi] } }};
(*bound_var)[ty_w128Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64Mi], &(*bound_var)[ty_w64Mi] } }};
(*bound_var)[ty_w256Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w128Mi], &(*bound_var)[ty_w128Mi] } }};
(*bound_var)[ty_w512Mi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256Mi], &(*bound_var)[ty_w256Mi] } }};
(*bound_var)[ty_w1Gi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w512Mi], &(*bound_var)[ty_w512Mi] } }};
(*bound_var)[ty_w2Gi] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w1Gi], &(*bound_var)[ty_w1Gi] } }};
(*bound_var)[ty_mw8] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w8] } }};
(*bound_var)[ty_mw16] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_mw32] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_mw64] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_mw128] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w128] } }};
(*bound_var)[ty_mw256] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_mw512] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w512] } }};
(*bound_var)[ty_mw1Ki] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w1Ki] } }};
(*bound_var)[ty_mw2Ki] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_w2Ki] } }};
(*bound_var)[ty_mmw256] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_mw256] } }};
(*bound_var)[ty_msw16w16] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_sw16w16] } }};
(*bound_var)[ty_mpw256w32] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_u], &(*bound_var)[ty_pw256w32] } }};
(*bound_var)[ty_sw16w16] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_sw32w32] = (unification_var){ .isBound = true, .bound = { .kind = SUM, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_pbw2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w2] } }};
(*bound_var)[ty_pbw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w8] } }};
(*bound_var)[ty_pbw16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_pbw32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_pbw64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_pbw128] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w128] } }};
(*bound_var)[ty_pbw256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_pbpw4w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_pw4w8] } }};
(*bound_var)[ty_pbpw4w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_pw4w16] } }};
(*bound_var)[ty_pbpw8w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_pw8w32] } }};
(*bound_var)[ty_pbpw8w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_b], &(*bound_var)[ty_pw8w64] } }};
(*bound_var)[ty_pw2w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w8] } }};
(*bound_var)[ty_pw2w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_pw2w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_pw2w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w2], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_pw4w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w8] } }};
(*bound_var)[ty_pw4w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_pw4w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_pw4w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w4], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_pw8b] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_b] } }};
(*bound_var)[ty_pw8w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w2] } }};
(*bound_var)[ty_pw8w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w4] } }};
(*bound_var)[ty_pw8w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_pw8w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_pw8w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w8], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_pw16b] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_b] } }};
(*bound_var)[ty_pw16w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w2] } }};
(*bound_var)[ty_pw16w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w4] } }};
(*bound_var)[ty_pw16w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w8] } }};
(*bound_var)[ty_pw16w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_pw16w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w16], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_pw32b] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_b] } }};
(*bound_var)[ty_pw32w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w2] } }};
(*bound_var)[ty_pw32w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w4] } }};
(*bound_var)[ty_pw32w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w8] } }};
(*bound_var)[ty_pw32w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_pw32w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w32], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_pw64b] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_b] } }};
(*bound_var)[ty_pw64w2] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w2] } }};
(*bound_var)[ty_pw64w4] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w4] } }};
(*bound_var)[ty_pw64w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w8] } }};
(*bound_var)[ty_pw64w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_pw64w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_pw64w128] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w128] } }};
(*bound_var)[ty_pw64w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w64], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_pw128w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w128], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_pw256w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_pw256w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_w512] } }};
(*bound_var)[ty_pw256pbw256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_pbw256] } }};
(*bound_var)[ty_pw256pw512w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w256], &(*bound_var)[ty_pw512w256] } }};
(*bound_var)[ty_pw512w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_w512], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw16], &(*bound_var)[ty_mw8] } }};
(*bound_var)[ty_pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw32], &(*bound_var)[ty_pmw16mw8] } }};
(*bound_var)[ty_pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw64], &(*bound_var)[ty_pmw32pmw16mw8] } }};
(*bound_var)[ty_pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw128], &(*bound_var)[ty_pmw64pmw32pmw16mw8] } }};
(*bound_var)[ty_pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw256], &(*bound_var)[ty_pmw128pmw64pmw32pmw16mw8] } }};
(*bound_var)[ty_pmw512pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw512], &(*bound_var)[ty_pmw256pmw128pmw64pmw32pmw16mw8] } }};
(*bound_var)[ty_pmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw1Ki], &(*bound_var)[ty_pmw512pmw256pmw128pmw64pmw32pmw16mw8] } }};
(*bound_var)[ty_pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_mw2Ki], &(*bound_var)[ty_pmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] } }};
(*bound_var)[ty_ppw256w512w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw256w512], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_ppw256w512w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw256w512], &(*bound_var)[ty_w512] } }};
(*bound_var)[ty_ppw256pbw256w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw256pbw256], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_ppw256pw512w256w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw256pw512w256], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_ppw512w256w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw512w256], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_ppw512w256w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw512w256], &(*bound_var)[ty_w512] } }};
(*bound_var)[ty_ppw512w256pw512w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pw512w256], &(*bound_var)[ty_pw512w256] } }};
(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_pmw256pmw128pmw64pmw32pmw16mw8], &(*bound_var)[ty_pw64w256] } }};
(*bound_var)[ty_pppw256w512w256w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppw256w512w256], &(*bound_var)[ty_w512] } }};
(*bound_var)[ty_pppw256pbw256w256pbw256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppw256pbw256w256], &(*bound_var)[ty_pbw256] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w8] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w16] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w16] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w32] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w64] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w64] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w128] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w128] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w256] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w512] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w512] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w1Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w1Ki] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w2Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w2Ki] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w4Ki] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_w4Ki] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256mw256] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_mw256] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pw256w32] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_pw256w32] } }};
(*bound_var)[ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] = (unification_var){ .isBound = true, .bound = { .kind = PRODUCT, .arg = { &(*bound_var)[ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256], &(*bound_var)[ty_pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8] } }};
================================================
FILE: C/bitcoin/primitiveJetNode.inc
================================================
/* This file has been automatically generated. */
[ADD_16] =
{ .tag = JET
, .jet = simplicity_add_16
, .cmr = {{0x49425a86u, 0xe20a676du, 0x8b87e3c1u, 0xa9b8ea6eu, 0xc75d859cu, 0x12c51bcbu, 0x7fa9f969u, 0x12c349cfu}}
, .sourceIx = ty_w32
, .targetIx = ty_pbw16
, .cost = 80 /* milli weight units */
}
,[ADD_32] =
{ .tag = JET
, .jet = simplicity_add_32
, .cmr = {{0x4668cd55u, 0xe8d15919u, 0x53327014u, 0xec64c8e7u, 0xd52b86b5u, 0x3e11c014u, 0x57eaf2c3u, 0xd3cebf9fu}}
, .sourceIx = ty_w64
, .targetIx = ty_pbw32
, .cost = 92 /* milli weight units */
}
,[ADD_64] =
{ .tag = JET
, .jet = simplicity_add_64
, .cmr = {{0xbe2b7519u, 0x303a67eeu, 0xa6b48295u, 0x0eda8343u, 0x5e1de855u, 0x9c394a23u, 0x6222ff5bu, 0xf089d346u}}
, .sourceIx = ty_w128
, .targetIx = ty_pbw64
, .cost = 105 /* milli weight units */
}
,[ADD_8] =
{ .tag = JET
, .jet = simplicity_add_8
, .cmr = {{0xdfa179adu, 0xf4550b28u, 0x4873bf30u, 0x123e0d4eu, 0x54069b08u, 0x5834ce56u, 0x5815ef7eu, 0x45784acbu}}
, .sourceIx = ty_w16
, .targetIx = ty_pbw8
, .cost = 97 /* milli weight units */
}
,[ALL_16] =
{ .tag = JET
, .jet = simplicity_all_16
, .cmr = {{0x24f482a5u, 0x13d33362u, 0x015d28dfu, 0x4bb6c3eeu, 0x08ab8afbu, 0xbd25571fu, 0x0ea89d8cu, 0xaba31404u}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 60 /* milli weight units */
}
,[ALL_32] =
{ .tag = JET
, .jet = simplicity_all_32
, .cmr = {{0xa716522du, 0x0f3787c8u, 0xb4d50764u, 0x7f1f807bu, 0x67f320d6u, 0xeb67b84bu, 0x609cec1du, 0x2f12218au}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 62 /* milli weight units */
}
,[ALL_64] =
{ .tag = JET
, .jet = simplicity_all_64
, .cmr = {{0x7aeefe2eu, 0xce24bab3u, 0x7c6e5430u, 0xeed419fcu, 0xd5f03791u, 0x2d1770cbu, 0x7d6520dcu, 0xe525291au}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 63 /* milli weight units */
}
,[ALL_8] =
{ .tag = JET
, .jet = simplicity_all_8
, .cmr = {{0x4637f40eu, 0x5f4726b0u, 0x0570765au, 0xc794e29eu, 0xd1bb2655u, 0xffc412b2u, 0xdc41258eu, 0x41aac624u}}
, .sourceIx = ty_w8
, .targetIx = ty_b
, .cost = 50 /* milli weight units */
}
,[AND_1] =
{ .tag = JET
, .jet = simplicity_and_1
, .cmr = {{0x10684d0du, 0xd72cb0a8u, 0x26a86383u, 0x4e011f50u, 0xfa0d558bu, 0xa77d6b9fu, 0x49a1ac22u, 0x902a6ad0u}}
, .sourceIx = ty_w2
, .targetIx = ty_b
, .cost = 77 /* milli weight units */
}
,[AND_16] =
{ .tag = JET
, .jet = simplicity_and_16
, .cmr = {{0x373c730fu, 0xad3e8847u, 0x991aa417u, 0xd9f080eeu, 0x1cb88a7fu, 0x7206f3fau, 0x840b1950u, 0x7761fb23u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 83 /* milli weight units */
}
,[AND_32] =
{ .tag = JET
, .jet = simplicity_and_32
, .cmr = {{0x13b02c4cu, 0x60ae6ea4u, 0x91161649u, 0xacf9a47au, 0x7025af84u, 0x7d5f581eu, 0x6f1cccfbu, 0x21d3001du}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 77 /* milli weight units */
}
,[AND_64] =
{ .tag = JET
, .jet = simplicity_and_64
, .cmr = {{0x92185535u, 0xd4505407u, 0xdea3c8a6u, 0x0826ede6u, 0x4a8fbb3du, 0xb486d56fu, 0x642d217cu, 0x29cbd795u}}
, .sourceIx = ty_w128
, .targetIx = ty_w64
, .cost = 78 /* milli weight units */
}
,[AND_8] =
{ .tag = JET
, .jet = simplicity_and_8
, .cmr = {{0x269a1b44u, 0x6266f8f4u, 0xa4a38fa7u, 0xe7e39182u, 0xf1521436u, 0x142badedu, 0xf3aa63fbu, 0x2f172d2fu}}
, .sourceIx = ty_w16
, .targetIx = ty_w8
, .cost = 98 /* milli weight units */
}
,[ANNEX_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_annex_hash
, .cmr = {{0x51fa1913u, 0xa6297348u, 0x4a700af3u, 0xff932694u, 0xd3890ae0u, 0xad87a455u, 0xdaf4906fu, 0x224a48d5u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256mw256
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 1491 /* milli weight units */
}
,[BIP_0340_VERIFY] =
{ .tag = JET
, .jet = simplicity_bip_0340_verify
, .cmr = {{0x491565feu, 0x23a7bdc1u, 0x842be749u, 0x509337f9u, 0x6890d5b3u, 0x58b36520u, 0x90da5566u, 0x54e29549u}}
, .sourceIx = ty_w1Ki
, .targetIx = ty_u
, .cost = 49421 /* milli weight units */
}
,[BUILD_TAPBRANCH] =
{ .tag = JET
, .jet = simplicity_bitcoin_build_tapbranch
, .cmr = {{0xef8e9291u, 0x9b2608eau, 0x6b5bcdd3u, 0x9c5178e5u, 0x46249553u, 0x914b0f8du, 0x33735d28u, 0x86e1a5e8u}}
, .sourceIx = ty_w512
, .targetIx = ty_w256
, .cost = 2554 /* milli weight units */
}
,[BUILD_TAPLEAF_SIMPLICITY] =
{ .tag = JET
, .jet = simplicity_bitcoin_build_tapleaf_simplicity
, .cmr = {{0x22411909u, 0x984147deu, 0x8f5a0428u, 0x358b4716u, 0xdb087664u, 0xa7285608u, 0x52b0e616u, 0xebc62d30u}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 1927 /* milli weight units */
}
,[BUILD_TAPTWEAK] =
{ .tag = JET
, .jet = simplicity_bitcoin_build_taptweak
, .cmr = {{0xf192db17u, 0x06608defu, 0x165dbddau, 0x72a38c88u, 0x82cb36c6u, 0xda47070du, 0x8a5f5896u, 0xfbda8434u}}
, .sourceIx = ty_w512
, .targetIx = ty_w256
, .cost = 77780 /* milli weight units */
}
,[CH_1] =
{ .tag = JET
, .jet = simplicity_ch_1
, .cmr = {{0x73b2a981u, 0xd721986fu, 0x8cded697u, 0xe06305d4u, 0x5854102du, 0xff20c0e5u, 0xb98ae176u, 0x232ff25bu}}
, .sourceIx = ty_pbw2
, .targetIx = ty_b
, .cost = 50 /* milli weight units */
}
,[CH_16] =
{ .tag = JET
, .jet = simplicity_ch_16
, .cmr = {{0x78de465eu, 0x61d9a50fu, 0x78252ff4u, 0xab23c9e6u, 0x3ae68c76u, 0x9d366612u, 0x71207dc6u, 0x93f469b4u}}
, .sourceIx = ty_pw16w32
, .targetIx = ty_w16
, .cost = 83 /* milli weight units */
}
,[CH_32] =
{ .tag = JET
, .jet = simplicity_ch_32
, .cmr = {{0xed93bef1u, 0xf66e3a75u, 0xe6120602u, 0xecee6740u, 0x653e7bd4u, 0x6e07eb77u, 0x144ef1bbu, 0x2c9de53du}}
, .sourceIx = ty_pw32w64
, .targetIx = ty_w32
, .cost = 69 /* milli weight units */
}
,[CH_64] =
{ .tag = JET
, .jet = simplicity_ch_64
, .cmr = {{0xced0079bu, 0x0bd1cc00u, 0x209a7cbcu, 0x23f13dfdu, 0x202808f0u, 0xf5257d8au, 0x50ac543eu, 0x64ee3a05u}}
, .sourceIx = ty_pw64w128
, .targetIx = ty_w64
, .cost = 78 /* milli weight units */
}
,[CH_8] =
{ .tag = JET
, .jet = simplicity_ch_8
, .cmr = {{0xc707ca72u, 0x3e24f6b2u, 0x5bf394a9u, 0x9a4d75e8u, 0x1379b467u, 0x8438ac78u, 0x9dee188eu, 0xdcce75fau}}
, .sourceIx = ty_pw8w16
, .targetIx = ty_w8
, .cost = 86 /* milli weight units */
}
,[CHECK_LOCK_DISTANCE] =
{ .tag = JET
, .jet = simplicity_bitcoin_check_lock_distance
, .cmr = {{0x38fdf7ddu, 0x28538670u, 0xfb34c1bfu, 0xe72f17e2u, 0xca5784f8u, 0x7fed88eau, 0xb584792bu, 0x3974bd18u}}
, .sourceIx = ty_w16
, .targetIx = ty_u
, .cost = 84 /* milli weight units */
}
,[CHECK_LOCK_DURATION] =
{ .tag = JET
, .jet = simplicity_bitcoin_check_lock_duration
, .cmr = {{0x77503832u, 0x6eae25c7u, 0x209b2443u, 0x06eaa9f9u, 0x204c7eceu, 0x2dd63b45u, 0x2e10017fu, 0xa4ea53cfu}}
, .sourceIx = ty_w16
, .targetIx = ty_u
, .cost = 78 /* milli weight units */
}
,[CHECK_LOCK_HEIGHT] =
{ .tag = JET
, .jet = simplicity_bitcoin_check_lock_height
, .cmr = {{0xb90f151fu, 0x45b4eb37u, 0x210621f9u, 0x700a36c8u, 0xc504bee0u, 0x67771163u, 0xa8b83a77u, 0x18e6686au}}
, .sourceIx = ty_w32
, .targetIx = ty_u
, .cost = 108 /* milli weight units */
}
,[CHECK_LOCK_TIME] =
{ .tag = JET
, .jet = simplicity_bitcoin_check_lock_time
, .cmr = {{0xa451ebb2u, 0x25d6b133u, 0xa5e63539u, 0x7800d487u, 0xb3968b0du, 0xe55c96ebu, 0x82f290ecu, 0xff9c2590u}}
, .sourceIx = ty_w32
, .targetIx = ty_u
, .cost = 123 /* milli weight units */
}
,[CHECK_SIG_VERIFY] =
{ .tag = JET
, .jet = simplicity_check_sig_verify
, .cmr = {{0xb5801554u, 0x6d285266u, 0x5dd21bf1u, 0x12662670u, 0x20fa5e27u, 0x5001dd46u, 0x18fa4156u, 0x25952e68u}}
, .sourceIx = ty_ppw256w512w512
, .targetIx = ty_u
, .cost = 50000 /* milli weight units */
}
,[COMPLEMENT_1] =
{ .tag = JET
, .jet = simplicity_complement_1
, .cmr = {{0x1bcfae13u, 0xd5d237a0u, 0xbb9b1d75u, 0x32047462u, 0xb27690deu, 0x5cac0e20u, 0x19298964u, 0x57934060u}}
, .sourceIx = ty_b
, .targetIx = ty_b
, .cost = 51 /* milli weight units */
}
,[COMPLEMENT_16] =
{ .tag = JET
, .jet = simplicity_complement_16
, .cmr = {{0x81ad4d2cu, 0x3d16bf34u, 0x0af3886du, 0x355cc5bdu, 0x1d5967e1u, 0x6ace924fu, 0x19ecf7d4u, 0x86d6c7e9u}}
, .sourceIx = ty_w16
, .targetIx = ty_w16
, .cost = 86 /* milli weight units */
}
,[COMPLEMENT_32] =
{ .tag = JET
, .jet = simplicity_complement_32
, .cmr = {{0x13742c18u, 0x04a96e6cu, 0x039528bfu, 0xd03b8cf2u, 0xb462526bu, 0xb181a3d8u, 0xb432f99au, 0xc4f5a7efu}}
, .sourceIx = ty_w32
, .targetIx = ty_w32
, .cost = 58 /* milli weight units */
}
,[COMPLEMENT_64] =
{ .tag = JET
, .jet = simplicity_complement_64
, .cmr = {{0x65b7bd09u, 0x3639c56du, 0xa285cefau, 0x2d046464u, 0x5e14dd13u, 0x642f3495u, 0x7d4737bdu, 0x52fac588u}}
, .sourceIx = ty_w64
, .targetIx = ty_w64
, .cost = 64 /* milli weight units */
}
,[COMPLEMENT_8] =
{ .tag = JET
, .jet = simplicity_complement_8
, .cmr = {{0x954b70dcu, 0xec539e6bu, 0x67dffec5u, 0x3cf24a66u, 0x9939608bu, 0x223f5f8bu, 0x6d129daau, 0x48ca1cf0u}}
, .sourceIx = ty_w8
, .targetIx = ty_w8
, .cost = 62 /* milli weight units */
}
,[CURRENT_ANNEX_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_current_annex_hash
, .cmr = {{0xced9022eu, 0xdc69241fu, 0xe70749a7u, 0xf5d489c3u, 0x135ee8c9u, 0x6fe64c44u, 0x64401f98u, 0x51d7a17du}}
, .sourceIx = ty_u
, .targetIx = ty_mw256
, .cost = 74 /* milli weight units */
}
,[CURRENT_INDEX] =
{ .tag = JET
, .jet = simplicity_bitcoin_current_index
, .cmr = {{0x0e8c964cu, 0x2f2b3490u, 0x362f3bbcu, 0x7483dea3u, 0x7fda810bu, 0x69314ff6u, 0x64fea0e3u, 0x2708ec8fu}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 66 /* milli weight units */
}
,[CURRENT_PREV_OUTPOINT] =
{ .tag = JET
, .jet = simplicity_bitcoin_current_prev_outpoint
, .cmr = {{0x6443391bu, 0x34408684u, 0x6d5a17a6u, 0x2e3e0628u, 0x2ad6962cu, 0x4dfced2fu, 0x6a83d0dfu, 0xbf6a5c54u}}
, .sourceIx = ty_u
, .targetIx = ty_pw256w32
, .cost = 130 /* milli weight units */
}
,[CURRENT_SCRIPT_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_current_script_hash
, .cmr = {{0x23498dd6u, 0x645ed138u, 0xb344937cu, 0xf654aaffu, 0xa627f85au, 0x47caa689u, 0x54f13f4cu, 0x6a4dc772u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 127 /* milli weight units */
}
,[CURRENT_SCRIPT_SIG_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_current_script_sig_hash
, .cmr = {{0x34a3c55du, 0x147374d8u, 0xf3a1761bu, 0xbab28696u, 0x8455404cu, 0x2ca03f69u, 0x393f6339u, 0xd0f58b59u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 126 /* milli weight units */
}
,[CURRENT_SEQUENCE] =
{ .tag = JET
, .jet = simplicity_bitcoin_current_sequence
, .cmr = {{0xc49f76acu, 0x79f8f15cu, 0x409ba815u, 0xc16edcb8u, 0xd11e9a07u, 0x565c8e09u, 0xb63e7fdfu, 0x3103009fu}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 66 /* milli weight units */
}
,[CURRENT_VALUE] =
{ .tag = JET
, .jet = simplicity_bitcoin_current_value
, .cmr = {{0x91b96e82u, 0x9e3b4972u, 0xb0cb091au, 0x0a904ba4u, 0x11338abfu, 0xc08da786u, 0xd5a84f04u, 0x9b5ba3b8u}}
, .sourceIx = ty_u
, .targetIx = ty_w64
, .cost = 85 /* milli weight units */
}
,[DECOMPRESS] =
{ .tag = JET
, .jet = simplicity_decompress
, .cmr = {{0x890056dfu, 0x828a766eu, 0xe9f65607u, 0x221e8946u, 0xfa77c256u, 0xbb96e231u, 0xe194d300u, 0x8cf356f6u}}
, .sourceIx = ty_pbw256
, .targetIx = ty_mw512
, .cost = 10495 /* milli weight units */
}
,[DECREMENT_16] =
{ .tag = JET
, .jet = simplicity_decrement_16
, .cmr = {{0x35fda38bu, 0x672c3831u, 0xd8ca11a4u, 0xf3a95962u, 0x22529eb1u, 0xc15f8c70u, 0x5013977du, 0x7dfb5d8bu}}
, .sourceIx = ty_w16
, .targetIx = ty_pbw16
, .cost = 58 /* milli weight units */
}
,[DECREMENT_32] =
{ .tag = JET
, .jet = simplicity_decrement_32
, .cmr = {{0x3b2b1939u, 0x552284f6u, 0x14694ba1u, 0x8dce70ceu, 0xe476ff42u, 0xdcd089e1u, 0xa3c0a42bu, 0xebd108f6u}}
, .sourceIx = ty_w32
, .targetIx = ty_pbw32
, .cost = 57 /* milli weight units */
}
,[DECREMENT_64] =
{ .tag = JET
, .jet = simplicity_decrement_64
, .cmr = {{0x7ef7bdd3u, 0x5db685aeu, 0x99055337u, 0x35a2c7a7u, 0xccbc1708u, 0xae636f93u, 0x1b5ce026u, 0xe5a17fedu}}
, .sourceIx = ty_w64
, .targetIx = ty_pbw64
, .cost = 79 /* milli weight units */
}
,[DECREMENT_8] =
{ .tag = JET
, .jet = simplicity_decrement_8
, .cmr = {{0xe364f2e5u, 0xc08ae011u, 0x8ebe993eu, 0x8b3c958cu, 0x2bcc6062u, 0xa33baab9u, 0x28c04b3eu, 0xc932f51bu}}
, .sourceIx = ty_w8
, .targetIx = ty_pbw8
, .cost = 77 /* milli weight units */
}
,[DIV_MOD_128_64] =
{ .tag = JET
, .jet = simplicity_div_mod_128_64
, .cmr = {{0x9a9443a2u, 0xb541e29fu, 0x272ffd56u, 0x7d1bf742u, 0xd68ccbe9u, 0x538a8729u, 0x1b0ca638u, 0x1563ac2cu}}
, .sourceIx = ty_pw128w64
, .targetIx = ty_w128
, .cost = 169 /* milli weight units */
}
,[DIV_MOD_16] =
{ .tag = JET
, .jet = simplicity_div_mod_16
, .cmr = {{0x39bcb5c0u, 0x1dc1805cu, 0x4919895cu, 0xb59e8f3bu, 0x41446717u, 0xf7ff48fdu, 0xc937dd03u, 0x8024a08au}}
, .sourceIx = ty_w32
, .targetIx = ty_w32
, .cost = 92 /* milli weight units */
}
,[DIV_MOD_32] =
{ .tag = JET
, .jet = simplicity_div_mod_32
, .cmr = {{0xfb1202f4u, 0xe8663a87u, 0xf568992au, 0x185024c7u, 0x0b4f079fu, 0xbe953001u, 0x0f6db284u, 0x218af6cdu}}
, .sourceIx = ty_w64
, .targetIx = ty_w64
, .cost = 90 /* milli weight units */
}
,[DIV_MOD_64] =
{ .tag = JET
, .jet = simplicity_div_mod_64
, .cmr = {{0x6764df5eu, 0x2aa03032u, 0x6ee544c6u, 0xe53ff38eu, 0xf0b28517u, 0x915eec65u, 0xc72ea57au, 0x129828ebu}}
, .sourceIx = ty_w128
, .targetIx = ty_w128
, .cost = 82 /* milli weight units */
}
,[DIV_MOD_8] =
{ .tag = JET
, .jet = simplicity_div_mod_8
, .cmr = {{0xd300244eu, 0x480dd974u, 0x1213e4cbu, 0x0eba836du, 0x3059e778u, 0xb8122f78u, 0x90032673u, 0x739c6a2cu}}
, .sourceIx = ty_w16
, .targetIx = ty_w16
, .cost = 91 /* milli weight units */
}
,[DIVIDE_16] =
{ .tag = JET
, .jet = simplicity_divide_16
, .cmr = {{0x52abfef1u, 0x79754c90u, 0xf9a4260fu, 0x323a8ca4u, 0x95159290u, 0x2b8ecbd6u, 0x4ba42656u, 0xfac05968u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 85 /* milli weight units */
}
,[DIVIDE_32] =
{ .tag = JET
, .jet = simplicity_divide_32
, .cmr = {{0x4a8ae535u, 0x44e147edu, 0x02250423u, 0x7934cc25u, 0x4479bcf9u, 0x3de1e197u, 0x4ddab3bbu, 0x516e606cu}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 82 /* milli weight units */
}
,[DIVIDE_64] =
{ .tag = JET
, .jet = simplicity_divide_64
, .cmr = {{0xd7025d05u, 0xadfae66bu, 0x4710d0ffu, 0x1e87e828u, 0x15573e9cu, 0xb631b4c7u, 0xd13d2f1bu, 0xe4dd26d2u}}
, .sourceIx = ty_w128
, .targetIx = ty_w64
, .cost = 81 /* milli weight units */
}
,[DIVIDE_8] =
{ .tag = JET
, .jet = simplicity_divide_8
, .cmr = {{0x40cd1dacu, 0xea24669bu, 0x6a589b61u, 0x475474afu, 0x31d14f8du, 0x46877084u, 0x52d3df37u, 0x30253126u}}
, .sourceIx = ty_w16
, .targetIx = ty_w8
, .cost = 85 /* milli weight units */
}
,[DIVIDES_16] =
{ .tag = JET
, .jet = simplicity_divides_16
, .cmr = {{0x10bb1818u, 0x0eab5badu, 0xdc165d03u, 0x37c4ada0u, 0x88e157b1u, 0xaa678334u, 0x2a4520a3u, 0x24dd9d2bu}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 84 /* milli weight units */
}
,[DIVIDES_32] =
{ .tag = JET
, .jet = simplicity_divides_32
, .cmr = {{0xf5e8e78cu, 0x82769a48u, 0xc9103e44u, 0xddb47f84u, 0x1d7693b0u, 0x419e5e7du, 0xa4e68b78u, 0xb237a572u}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 80 /* milli weight units */
}
,[DIVIDES_64] =
{ .tag = JET
, .jet = simplicity_divides_64
, .cmr = {{0x9ebd55fau, 0xe418885eu, 0xea04c3cdu, 0xfff531b7u, 0xd714d059u, 0x4fa7da87u, 0xeb6555d3u, 0x6b953db2u}}
, .sourceIx = ty_w128
, .targetIx = ty_b
, .cost = 67 /* milli weight units */
}
,[DIVIDES_8] =
{ .tag = JET
, .jet = simplicity_divides_8
, .cmr = {{0xa236bc3eu, 0x5cf4d256u, 0x408ba38cu, 0x1eaee736u, 0x9a9c402fu, 0x74bcd1c8u, 0x02f9094fu, 0xbf36803du}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 73 /* milli weight units */
}
,[EQ_1] =
{ .tag = JET
, .jet = simplicity_eq_1
, .cmr = {{0x6549f986u, 0x203a6497u, 0x356e432bu, 0x2aa160d6u, 0xee870b11u, 0x190865bdu, 0x36a47cb0u, 0x470433a5u}}
, .sourceIx = ty_w2
, .targetIx = ty_b
, .cost = 63 /* milli weight units */
}
,[EQ_16] =
{ .tag = JET
, .jet = simplicity_eq_16
, .cmr = {{0x0c5402b0u, 0xadc8fc65u, 0x701bb75bu, 0x3254c835u, 0xf8fec130u, 0x81cd35e1u, 0x328f2bd7u, 0xdbd23fa6u}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 68 /* milli weight units */
}
,[EQ_256] =
{ .tag = JET
, .jet = simplicity_eq_256
, .cmr = {{0x260e1d13u, 0x6dd744fcu, 0xb0507a2du, 0x277027a7u, 0x724354ebu, 0x176b2fbfu, 0x31c6c7d7u, 0xfb3ecd6fu}}
, .sourceIx = ty_w512
, .targetIx = ty_b
, .cost = 188 /* milli weight units */
}
,[EQ_32] =
{ .tag = JET
, .jet = simplicity_eq_32
, .cmr = {{0xf5d6edc8u, 0xb6164e12u, 0x5bbbef08u, 0xc9e08a1eu, 0x6fd492f5u, 0xbdca6fdcu, 0x8b5f5a6fu, 0x05c5ab96u}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 74 /* milli weight units */
}
,[EQ_64] =
{ .tag = JET
, .jet = simplicity_eq_64
, .cmr = {{0x1f93acb8u, 0x092fa06du, 0xeaf3c387u, 0xf54a18ffu, 0xeaa69a47u, 0xa6f5caf4u, 0xae497e5cu, 0xc2b36c43u}}
, .sourceIx = ty_w128
, .targetIx = ty_b
, .cost = 82 /* milli weight units */
}
,[EQ_8] =
{ .tag = JET
, .jet = simplicity_eq_8
, .cmr = {{0xd752fa7fu, 0x51473014u, 0xebb69e1eu, 0x1d2c86d5u, 0x1148b6bau, 0xa02137a4u, 0x8f62d57eu, 0xaf8df1cdu}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 76 /* milli weight units */
}
,[FE_ADD] =
{ .tag = JET
, .jet = simplicity_fe_add
, .cmr = {{0xa6c90e02u, 0xfde4ee6eu, 0xef666737u, 0x492e14afu, 0xc8762504u, 0x974af5d5u, 0x472bb943u, 0x3ad2d294u}}
, .sourceIx = ty_w512
, .targetIx = ty_w256
, .cost = 777 /* milli weight units */
}
,[FE_INVERT] =
{ .tag = JET
, .jet = simplicity_fe_invert
, .cmr = {{0x7c4abaceu, 0x33c72b3bu, 0xe1fd0ee3u, 0x9fc6cb3eu, 0xe5c8f11eu, 0xf21998c0u, 0x602b5215u, 0xaa2a75c2u}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 3237 /* milli weight units */
}
,[FE_IS_ODD] =
{ .tag = JET
, .jet = simplicity_fe_is_odd
, .cmr = {{0x30f5171fu, 0x58f1089du, 0x5dcfb6e6u, 0x683f5adeu, 0x984c0799u, 0x763ca738u, 0x3f75df1cu, 0xa0813efeu}}
, .sourceIx = ty_w256
, .targetIx = ty_b
, .cost = 313 /* milli weight units */
}
,[FE_IS_ZERO] =
{ .tag = JET
, .jet = simplicity_fe_is_zero
, .cmr = {{0xb0b74d86u, 0x51ff557cu, 0xa96044ddu, 0x97281338u, 0xa8f7d3acu, 0xb3847d03u, 0xacbf3d32u, 0xd96fae55u}}
, .sourceIx = ty_w256
, .targetIx = ty_b
, .cost = 277 /* milli weight units */
}
,[FE_MULTIPLY] =
{ .tag = JET
, .jet = simplicity_fe_multiply
, .cmr = {{0x506b9319u, 0xc17a14a9u, 0x469d4627u, 0x61a3303au, 0xb47ddb3au, 0x3079fba3u, 0x4073aa55u, 0x4216a388u}}
, .sourceIx = ty_w512
, .targetIx = ty_w256
, .cost = 813 /* milli weight units */
}
,[FE_MULTIPLY_BETA] =
{ .tag = JET
, .jet = simplicity_fe_multiply_beta
, .cmr = {{0x6e180eeau, 0xbe8422b7u, 0x9968e711u, 0xdd00a4b6u, 0x578bb275u, 0xbef47fe5u, 0xff968f14u, 0x72d76f2au}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 607 /* milli weight units */
}
,[FE_NEGATE] =
{ .tag = JET
, .jet = simplicity_fe_negate
, .cmr = {{0xd437ea00u, 0x339880b3u, 0x83d85fb2u, 0xaeaf201bu, 0xbe8ffc83u, 0x705062f9u, 0xc968590du, 0x5db337f6u}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 541 /* milli weight units */
}
,[FE_NORMALIZE] =
{ .tag = JET
, .jet = simplicity_fe_normalize
, .cmr = {{0xec0c3dd9u, 0xc5286364u, 0x78bec0e1u, 0x60e50ad9u, 0xbf452c5bu, 0x6f84e940u, 0xe16584ebu, 0x085ace38u}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 656 /* milli weight units */
}
,[FE_SQUARE] =
{ .tag = JET
, .jet = simplicity_fe_square
, .cmr = {{0xb904772du, 0x74a185b8u, 0x28eb1547u, 0x28d249c5u, 0x084711e9u, 0xa1832b89u, 0xcaf2af59u, 0xf960e118u}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 570 /* milli weight units */
}
,[FE_SQUARE_ROOT] =
{ .tag = JET
, .jet = simplicity_fe_square_root
, .cmr = {{0x16fb9aceu, 0xbe8b5b87u, 0xf2ea7db6u, 0xaa3a2af8u, 0x8ca2b58fu, 0x02cdc87eu, 0x7ce6be0cu, 0x1ffce014u}}
, .sourceIx = ty_w256
, .targetIx = ty_mw256
, .cost = 10162 /* milli weight units */
}
,[FEE] =
{ .tag = JET
, .jet = simplicity_bitcoin_fee
, .cmr = {{0xfb9ca939u, 0x81673d1du, 0x23aed24du, 0x612c1f5du, 0xc7cd49f8u, 0x6d348e67u, 0xa15bc4a7u, 0x130ae185u}}
, .sourceIx = ty_u
, .targetIx = ty_w64
, .cost = 65 /* milli weight units */
}
,[FULL_ADD_16] =
{ .tag = JET
, .jet = simplicity_full_add_16
, .cmr = {{0xc503b078u, 0xdde399c6u, 0x3ac4a232u, 0xbd2a329bu, 0x04308c75u, 0xeaec53a2u, 0xf889b8dfu, 0x0d033472u}}
, .sourceIx = ty_pbw32
, .targetIx = ty_pbw16
, .cost = 106 /* milli weight units */
}
,[FULL_ADD_32] =
{ .tag = JET
, .jet = simplicity_full_add_32
, .cmr = {{0xa7afd040u, 0xfcb0b2f2u, 0x7190781au, 0xe53a6ccau, 0x00e9fe59u, 0x531115c2u, 0x58ccb69du, 0x3be5a213u}}
, .sourceIx = ty_pbw64
, .targetIx = ty_pbw32
, .cost = 96 /* milli weight units */
}
,[FULL_ADD_64] =
{ .tag = JET
, .jet = simplicity_full_add_64
, .cmr = {{0x80a3ef6cu, 0xdb84ae7cu, 0x8dbcf3a1u, 0x842484c0u, 0x98df6f19u, 0x427a5a4au, 0xdfe76cd5u, 0xff2836cau}}
, .sourceIx = ty_pbw128
, .targetIx = ty_pbw64
, .cost = 93 /* milli weight units */
}
,[FULL_ADD_8] =
{ .tag = JET
, .jet = simplicity_full_add_8
, .cmr = {{0x4b9076b8u, 0xc1ad56c9u, 0xdb6bb3bau, 0xf5938954u, 0x46ce61c7u, 0x4f797eb8u, 0xb230d205u, 0x421c9617u}}
, .sourceIx = ty_pbw16
, .targetIx = ty_pbw8
, .cost = 131 /* milli weight units */
}
,[FULL_DECREMENT_16] =
{ .tag = JET
, .jet = simplicity_full_decrement_16
, .cmr = {{0xfba3c978u, 0x6ea307f6u, 0xd85434fdu, 0xa2562482u, 0x43a00bacu, 0x9a5353b6u, 0x1ed39c60u, 0x55b693b0u}}
, .sourceIx = ty_pbw16
, .targetIx = ty_pbw16
, .cost = 60 /* milli weight units */
}
,[FULL_DECREMENT_32] =
{ .tag = JET
, .jet = simplicity_full_decrement_32
, .cmr = {{0x623d21d0u, 0x467922c0u, 0x01c56568u, 0x61d0ddb8u, 0x60c0c9a8u, 0x6bd4cfdcu, 0x37a14c14u, 0x06e3446eu}}
, .sourceIx = ty_pbw32
, .targetIx = ty_pbw32
, .cost = 71 /* milli weight units */
}
,[FULL_DECREMENT_64] =
{ .tag = JET
, .jet = simplicity_full_decrement_64
, .cmr = {{0x148b3ee1u, 0xf749ea0bu, 0xfba763beu, 0xe999a296u, 0x77456eaeu, 0x9ef53ad8u, 0x78f8b614u, 0x94f08f00u}}
, .sourceIx = ty_pbw64
, .targetIx = ty_pbw64
, .cost = 71 /* milli weight units */
}
,[FULL_DECREMENT_8] =
{ .tag = JET
, .jet = simplicity_full_decrement_8
, .cmr = {{0xb41afe97u, 0x4eaa1182u, 0xac461052u, 0x1e282781u, 0x318ce295u, 0xa3f23f0bu, 0x876ae269u, 0x673fb1dfu}}
, .sourceIx = ty_pbw8
, .targetIx = ty_pbw8
, .cost = 68 /* milli weight units */
}
,[FULL_INCREMENT_16] =
{ .tag = JET
, .jet = simplicity_full_increment_16
, .cmr = {{0xa68eccdbu, 0x9ead2926u, 0xc3e45b4bu, 0xae431cc4u, 0x66d58b8fu, 0xacc95a1bu, 0x4844b912u, 0xdf5676dfu}}
, .sourceIx = ty_pbw16
, .targetIx = ty_pbw16
, .cost = 70 /* milli weight units */
}
,[FULL_INCREMENT_32] =
{ .tag = JET
, .jet = simplicity_full_increment_32
, .cmr = {{0xd0eb0e94u, 0xa5c25713u, 0xeb944cadu, 0x4d701c6au, 0x968809bcu, 0x1af903fdu, 0xb11e6fadu, 0x0bb31b10u}}
, .sourceIx = ty_pbw32
, .targetIx = ty_pbw32
, .cost = 57 /* milli weight units */
}
,[FULL_INCREMENT_64] =
{ .tag = JET
, .jet = simplicity_full_increment_64
, .cmr = {{0xc003d2e9u, 0xb0a510c2u, 0xdd783e7du, 0x64eb87b3u, 0x3855d329u, 0x90dfc286u, 0x266e478du, 0xa4e74791u}}
, .sourceIx = ty_pbw64
, .targetIx = ty_pbw64
, .cost = 68 /* milli weight units */
}
,[FULL_INCREMENT_8] =
{ .tag = JET
, .jet = simplicity_full_increment_8
, .cmr = {{0x0bea2429u, 0x18f2dd17u, 0x64777811u, 0xe4442863u, 0x935225b0u, 0xf8b239c2u, 0x3752f9d8u, 0x5392a139u}}
, .sourceIx = ty_pbw8
, .targetIx = ty_pbw8
, .cost = 73 /* milli weight units */
}
,[FULL_LEFT_SHIFT_16_1] =
{ .tag = JET
, .jet = simplicity_full_left_shift_16_1
, .cmr = {{0xb366a816u, 0x922fc455u, 0x010fe88au, 0x5f6a5cf2u, 0xcea917e1u, 0x2bd140aeu, 0x6d43b641u, 0xe57f42b3u}}
, .sourceIx = ty_pw16b
, .targetIx = ty_pbw16
, .cost = 76 /* milli weight units */
}
,[FULL_LEFT_SHIFT_16_2] =
{ .tag = JET
, .jet = simplicity_full_left_shift_16_2
, .cmr = {{0x27960d0du, 0xf2fbbc38u, 0x993d86fbu, 0x8f0cd2c3u, 0x434edb11u, 0x048213c1u, 0x411893cau, 0x9933b2eeu}}
, .sourceIx = ty_pw16w2
, .targetIx = ty_pw2w16
, .cost = 59 /* milli weight units */
}
,[FULL_LEFT_SHIFT_16_4] =
{ .tag = JET
, .jet = simplicity_full_left_shift_16_4
, .cmr = {{0x655137beu, 0xc5c0368fu, 0x29bc992cu, 0x88421a15u, 0x98564039u, 0x7b617fc4u, 0x8d33210fu, 0xc0053ad1u}}
, .sourceIx = ty_pw16w4
, .targetIx = ty_pw4w16
, .cost = 68 /* milli weight units */
}
,[FULL_LEFT_SHIFT_16_8] =
{ .tag = JET
, .jet = simplicity_full_left_shift_16_8
, .cmr = {{0x168f576au, 0xa56ea47eu, 0x070646e7u, 0x8896beb2u, 0x498b1ae6u, 0xb1ff9c78u, 0x6270e955u, 0x65841929u}}
, .sourceIx = ty_pw16w8
, .targetIx = ty_pw8w16
, .cost = 68 /* milli weight units */
}
,[FULL_LEFT_SHIFT_32_1] =
{ .tag = JET
, .jet = simplicity_full_left_shift_32_1
, .cmr = {{0xd7cd5224u, 0x49118e81u, 0x00a7662fu, 0x4df039f8u, 0xcaebf433u, 0xeb039edcu, 0x42e88237u, 0x92ccea8au}}
, .sourceIx = ty_pw32b
, .targetIx = ty_pbw32
, .cost = 58 /* milli weight units */
}
,[FULL_LEFT_SHIFT_32_16] =
{ .tag = JET
, .jet = simplicity_full_left_shift_32_16
, .cmr = {{0x8bd80d4du, 0x2f8b2246u, 0xc12315c4u, 0x2841b4e4u, 0x0a71ae76u, 0x966a0895u, 0x4d666b86u, 0x32867437u}}
, .sourceIx = ty_pw32w16
, .targetIx = ty_pw16w32
, .cost = 52 /* milli weight units */
}
,[FULL_LEFT_SHIFT_32_2] =
{ .tag = JET
, .jet = simplicity_full_left_shift_32_2
, .cmr = {{0x13063d62u, 0x93832931u, 0x1fb7dabbu, 0x15c3fe58u, 0xc2887683u, 0x0097ecc6u, 0xbfdd480bu, 0xe1988146u}}
, .sourceIx = ty_pw32w2
, .targetIx = ty_pw2w32
, .cost = 73 /* milli weight units */
}
,[FULL_LEFT_SHIFT_32_4] =
{ .tag = JET
, .jet = simplicity_full_left_shift_32_4
, .cmr = {{0x25a1b5ddu, 0xe5db284eu, 0x8a882126u, 0x7c265301u, 0x14bbe671u, 0xcfafb44au, 0x60d75027u, 0x67db782eu}}
, .sourceIx = ty_pw32w4
, .targetIx = ty_pw4w32
, .cost = 59 /* milli weight units */
}
,[FULL_LEFT_SHIFT_32_8] =
{ .tag = JET
, .jet = simplicity_full_left_shift_32_8
, .cmr = {{0xce5470afu, 0xbfadbfbau, 0x68f9b2d5u, 0xb0645a44u, 0x08be6f85u, 0xa69c7f09u, 0xd0964553u, 0x68048764u}}
, .sourceIx = ty_pw32w8
, .targetIx = ty_pw8w32
, .cost = 60 /* milli weight units */
}
,[FULL_LEFT_SHIFT_64_1] =
{ .tag = JET
, .jet = simplicity_full_left_shift_64_1
, .cmr = {{0x051f3605u, 0x86c379acu, 0x2ce399cbu, 0xeb687e77u, 0x53b15d73u, 0x03dd316cu, 0xbd123012u, 0x087cc66fu}}
, .sourceIx = ty_pw64b
, .targetIx = ty_pbw64
, .cost = 74 /* milli weight units */
}
,[FULL_LEFT_SHIFT_64_16] =
{ .tag = JET
, .jet = simplicity_full_left_shift_64_16
, .cmr = {{0xb248be4du, 0xfcb88c5du, 0x89b1ca61u, 0x86a041e9u, 0x02b4c8a6u, 0x2bb16e09u, 0xfe15616eu, 0x0e3abd6du}}
, .sourceIx = ty_pw64w16
, .targetIx = ty_pw16w64
, .cost = 69 /* milli weight units */
}
,[FULL_LEFT_SHIFT_64_2] =
{ .tag = JET
, .jet = simplicity_full_left_shift_64_2
, .cmr = {{0x34bb5162u, 0x6b1d6b89u, 0x7abc155du, 0x034fe066u, 0x3a0ec0fdu, 0x8f640e5fu, 0xe1bf3cb7u, 0x670a2925u}}
, .sourceIx = ty_pw64w2
, .targetIx = ty_pw2w64
, .cost = 70 /* milli weight units */
}
,[FULL_LEFT_SHIFT_64_32] =
{ .tag = JET
, .jet = simplicity_full_left_shift_64_32
, .cmr = {{0x9dac8cd7u, 0xfd8b4888u, 0x9e55c5aau, 0x12fe97b7u, 0x29febc04u, 0x1a9fff44u, 0xc4d9b6f1u, 0xe07eb442u}}
, .sourceIx = ty_pw64w32
, .targetIx = ty_pw32w64
, .cost = 73 /* milli weight units */
}
,[FULL_LEFT_SHIFT_64_4] =
{ .tag = JET
, .jet = simplicity_full_left_shift_64_4
, .cmr = {{0x94b73dadu, 0xc3eeeb2eu, 0xe4a4d444u, 0xdd0f72acu, 0x306201f2u, 0xffcf714bu, 0x8ebe7982u, 0x744c0c7eu}}
, .sourceIx = ty_pw64w4
, .targetIx = ty_pw4w64
, .cost = 66 /* milli weight units */
}
,[FULL_LEFT_SHIFT_64_8] =
{ .tag = JET
, .jet = simplicity_full_left_shift_64_8
, .cmr = {{0x0ef71475u, 0x7ecf11cau, 0x3c73ce25u, 0xef24ee72u, 0x95dd4171u, 0xcc16287fu, 0xe6971bd6u, 0x7b478b46u}}
, .sourceIx = ty_pw64w8
, .targetIx = ty_pw8w64
, .cost = 68 /* milli weight units */
}
,[FULL_LEFT_SHIFT_8_1] =
{ .tag = JET
, .jet = simplicity_full_left_shift_8_1
, .cmr = {{0x9bfa48b7u, 0xad510091u, 0xba608544u, 0x62d859efu, 0xd1a2aa18u, 0x731b5f0cu, 0x9e2ba4d8u, 0x9d3aa843u}}
, .sourceIx = ty_pw8b
, .targetIx = ty_pbw8
, .cost = 60 /* milli weight units */
}
,[FULL_LEFT_SHIFT_8_2] =
{ .tag = JET
, .jet = simplicity_full_left_shift_8_2
, .cmr = {{0x797c2087u, 0x01b2a4e1u, 0x049e83d6u, 0x95f554b9u, 0x84f5db28u, 0x21525558u, 0x7c373421u, 0x51b7241du}}
, .sourceIx = ty_pw8w2
, .targetIx = ty_pw2w8
, .cost = 64 /* milli weight units */
}
,[FULL_LEFT_SHIFT_8_4] =
{ .tag = JET
, .jet = simplicity_full_left_shift_8_4
, .cmr = {{0x37bdac91u, 0x538f2219u, 0xcb89df0eu, 0xf9f197cdu, 0x68031f27u, 0x67e894f0u, 0x01c26fffu, 0x5eeb58cdu}}
, .sourceIx = ty_pw8w4
, .targetIx = ty_pw4w8
, .cost = 72 /* milli weight units */
}
,[FULL_MULTIPLY_16] =
{ .tag = JET
, .jet = simplicity_full_multiply_16
, .cmr = {{0x09baff92u, 0x1e9f14d1u, 0x208d1dd8u, 0x264cf1f3u, 0xb854c9afu, 0x21f778b2u, 0xb55a8a42u, 0x6dfe8928u}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 99 /* milli weight units */
}
,[FULL_MULTIPLY_32] =
{ .tag = JET
, .jet = simplicity_full_multiply_32
, .cmr = {{0x10c4b8c4u, 0xc0acd973u, 0x90f85cb3u, 0xf5ffe36au, 0x292037c1u, 0x90eebab3u, 0xe98934feu, 0x93b2ed90u}}
, .sourceIx = ty_w128
, .targetIx = ty_w64
, .cost = 87 /* milli weight units */
}
,[FULL_MULTIPLY_64] =
{ .tag = JET
, .jet = simplicity_full_multiply_64
, .cmr = {{0x2db19dbau, 0x90ef867bu, 0x5a3e914bu, 0x89fda2dau, 0x637ca80cu, 0x4267e198u, 0x1837ee3cu, 0x6fe3daf5u}}
, .sourceIx = ty_w256
, .targetIx = ty_w128
, .cost = 103 /* milli weight units */
}
,[FULL_MULTIPLY_8] =
{ .tag = JET
, .jet = simplicity_full_multiply_8
, .cmr = {{0x7f46ee72u, 0x84f39e73u, 0x4275a250u, 0x9a0b737eu, 0xd939115fu, 0x0219a574u, 0xd469cd30u, 0xb819efe3u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 95 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_16_1] =
{ .tag = JET
, .jet = simplicity_full_right_shift_16_1
, .cmr = {{0x7ebe0c66u, 0xc3c7dc16u, 0xa5469e91u, 0x79098417u, 0xac5f20a3u, 0x9cc41ac3u, 0x82fb1dbdu, 0x98e8e30fu}}
, .sourceIx = ty_pbw16
, .targetIx = ty_pw16b
, .cost = 55 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_16_2] =
{ .tag = JET
, .jet = simplicity_full_right_shift_16_2
, .cmr = {{0x8db0c216u, 0x19c62d63u, 0xd4c27bfcu, 0xf647d709u, 0xce37bed0u, 0x5718e93eu, 0x4515e29eu, 0xf3730cf4u}}
, .sourceIx = ty_pw2w16
, .targetIx = ty_pw16w2
, .cost = 60 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_16_4] =
{ .tag = JET
, .jet = simplicity_full_right_shift_16_4
, .cmr = {{0x5c74b132u, 0x06317917u, 0xe070e5fcu, 0x1c82f4c5u, 0xc2fbe9f3u, 0x1b812946u, 0xba230d8cu, 0x94d40616u}}
, .sourceIx = ty_pw4w16
, .targetIx = ty_pw16w4
, .cost = 64 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_16_8] =
{ .tag = JET
, .jet = simplicity_full_right_shift_16_8
, .cmr = {{0x1105818au, 0xc948d7bbu, 0x634707e6u, 0x9dbf1f67u, 0x9058a13du, 0x35fac2a6u, 0x4df97262u, 0xf242b63bu}}
, .sourceIx = ty_pw8w16
, .targetIx = ty_pw16w8
, .cost = 55 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_32_1] =
{ .tag = JET
, .jet = simplicity_full_right_shift_32_1
, .cmr = {{0x9b42c8f3u, 0x3bc5750eu, 0x2a83aadbu, 0xf29cc7fcu, 0xb950fe5au, 0x40aa0ec5u, 0x2452e533u, 0xf825a115u}}
, .sourceIx = ty_pbw32
, .targetIx = ty_pw32b
, .cost = 49 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_32_16] =
{ .tag = JET
, .jet = simplicity_full_right_shift_32_16
, .cmr = {{0x0ae5659cu, 0x2fa75794u, 0x78ebd57cu, 0x4c98aee7u, 0x77015645u, 0xb2843181u, 0x64fcbd30u, 0x65fc873cu}}
, .sourceIx = ty_pw16w32
, .targetIx = ty_pw32w16
, .cost = 48 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_32_2] =
{ .tag = JET
, .jet = simplicity_full_right_shift_32_2
, .cmr = {{0x57fb1c03u, 0xc2eb17f6u, 0x23478734u, 0xfd6937f9u, 0xe3ef027cu, 0x1560038fu, 0xa6066905u, 0x1789e368u}}
, .sourceIx = ty_pw2w32
, .targetIx = ty_pw32w2
, .cost = 66 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_32_4] =
{ .tag = JET
, .jet = simplicity_full_right_shift_32_4
, .cmr = {{0x8582cdfau, 0x74ef466bu, 0x8127b197u, 0x88134593u, 0x998e4969u, 0x00b38f0fu, 0x3d375818u, 0xd673451eu}}
, .sourceIx = ty_pw4w32
, .targetIx = ty_pw32w4
, .cost = 49 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_32_8] =
{ .tag = JET
, .jet = simplicity_full_right_shift_32_8
, .cmr = {{0xd905932eu, 0xbfca2a38u, 0x619d807eu, 0x28ff2e0du, 0x3be08a26u, 0x0676d257u, 0xefa040c3u, 0x05aadc33u}}
, .sourceIx = ty_pw8w32
, .targetIx = ty_pw32w8
, .cost = 66 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_64_1] =
{ .tag = JET
, .jet = simplicity_full_right_shift_64_1
, .cmr = {{0x3c15209bu, 0x99d2845eu, 0x225e14e1u, 0xe9e5e6a4u, 0x878bc8ceu, 0xa3f9f36bu, 0x8b535ac6u, 0x83e29d00u}}
, .sourceIx = ty_pbw64
, .targetIx = ty_pw64b
, .cost = 60 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_64_16] =
{ .tag = JET
, .jet = simplicity_full_right_shift_64_16
, .cmr = {{0x0285257bu, 0x090d8da1u, 0x28ef64a8u, 0x0c8d16fdu, 0xc3bf5ce5u, 0x0fcd56feu, 0xc5f90255u, 0xd9c8df47u}}
, .sourceIx = ty_pw16w64
, .targetIx = ty_pw64w16
, .cost = 73 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_64_2] =
{ .tag = JET
, .jet = simplicity_full_right_shift_64_2
, .cmr = {{0x7ec2dd65u, 0xc9e013e3u, 0xe4ce90fbu, 0xeb3fb1c7u, 0x8ccc5d2au, 0x7d26d8afu, 0x77f99de8u, 0x4cf72973u}}
, .sourceIx = ty_pw2w64
, .targetIx = ty_pw64w2
, .cost = 76 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_64_32] =
{ .tag = JET
, .jet = simplicity_full_right_shift_64_32
, .cmr = {{0x356f7dd4u, 0x6ba33f84u, 0xb06672fdu, 0xe9a2972eu, 0x80f3ea96u, 0x5ae8bc0bu, 0xff67aa2fu, 0x69f10b56u}}
, .sourceIx = ty_pw32w64
, .targetIx = ty_pw64w32
, .cost = 73 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_64_4] =
{ .tag = JET
, .jet = simplicity_full_right_shift_64_4
, .cmr = {{0x05464a33u, 0x35afbb09u, 0xd046828au, 0x922c4da0u, 0xeceeb109u, 0x77e46801u, 0xc93cdd66u, 0x8f22ee63u}}
, .sourceIx = ty_pw4w64
, .targetIx = ty_pw64w4
, .cost = 56 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_64_8] =
{ .tag = JET
, .jet = simplicity_full_right_shift_64_8
, .cmr = {{0x70172e1au, 0x6948bf40u, 0x120e68fbu, 0x8b4b23bcu, 0x355a1200u, 0x2ccc1db6u, 0x47c89b12u, 0xd10ec506u}}
, .sourceIx = ty_pw8w64
, .targetIx = ty_pw64w8
, .cost = 68 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_8_1] =
{ .tag = JET
, .jet = simplicity_full_right_shift_8_1
, .cmr = {{0x5669dbfcu, 0xc633ec0bu, 0xdf59e22fu, 0x03ed4b64u, 0x192095f5u, 0xdf20ffc1u, 0x2dd90d7cu, 0xda11374fu}}
, .sourceIx = ty_pbw8
, .targetIx = ty_pw8b
, .cost = 59 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_8_2] =
{ .tag = JET
, .jet = simplicity_full_right_shift_8_2
, .cmr = {{0x1f944361u, 0x09df52b3u, 0x45fa3a89u, 0xac2a49edu, 0xc9d285f2u, 0x1f45ed11u, 0xd775f7f7u, 0xf39d3e8fu}}
, .sourceIx = ty_pw2w8
, .targetIx = ty_pw8w2
, .cost = 49 /* milli weight units */
}
,[FULL_RIGHT_SHIFT_8_4] =
{ .tag = JET
, .jet = simplicity_full_right_shift_8_4
, .cmr = {{0x714698a2u, 0x7684b5bau, 0xa6b6480eu, 0xe3b257cbu, 0xb7cdab74u, 0x72f371a6u, 0x270618c0u, 0xab12908bu}}
, .sourceIx = ty_pw4w8
, .targetIx = ty_pw8w4
, .cost = 51 /* milli weight units */
}
,[FULL_SUBTRACT_16] =
{ .tag = JET
, .jet = simplicity_full_subtract_16
, .cmr = {{0x40096152u, 0xb54e7425u, 0x4555a65du, 0xccc629dfu, 0x57b979c8u, 0x47005450u, 0x36fe190au, 0x6af3d38au}}
, .sourceIx = ty_pbw32
, .targetIx = ty_pbw16
, .cost = 99 /* milli weight units */
}
,[FULL_SUBTRACT_32] =
{ .tag = JET
, .jet = simplicity_full_subtract_32
, .cmr = {{0xe7930d64u, 0x35a9680bu, 0xefb49db7u, 0xd87c2f50u, 0xafd46d98u, 0x880ded50u, 0xe5055fa3u, 0x09e1afcau}}
, .sourceIx = ty_pbw64
, .targetIx = ty_pbw32
, .cost = 92 /* milli weight units */
}
,[FULL_SUBTRACT_64] =
{ .tag = JET
, .jet = simplicity_full_subtract_64
, .cmr = {{0xff281df8u, 0xc42a3159u, 0xd9ffa925u, 0x16ca893eu, 0x23b0eb93u, 0x8b4cb0b3u, 0xf134468eu, 0x9f4ebc46u}}
, .sourceIx = ty_pbw128
, .targetIx = ty_pbw64
, .cost = 109 /* milli weight units */
}
,[FULL_SUBTRACT_8] =
{ .tag = JET
, .jet = simplicity_full_subtract_8
, .cmr = {{0x7e3dcfe4u, 0x56ae3c5cu, 0x87debf04u, 0x7189c274u, 0x82a4ff4eu, 0x8cfd1f17u, 0x30c87d2bu, 0x7bff73bau}}
, .sourceIx = ty_pbw16
, .targetIx = ty_pbw8
, .cost = 106 /* milli weight units */
}
,[GE_IS_ON_CURVE] =
{ .tag = JET
, .jet = simplicity_ge_is_on_curve
, .cmr = {{0x7d448719u, 0xf5f9572bu, 0xf5402e12u, 0xd193aff6u, 0x77482d66u, 0xff3dcf27u, 0x48f25c6bu, 0x7377028cu}}
, .sourceIx = ty_w512
, .targetIx = ty_b
, .cost = 688 /* milli weight units */
}
,[GE_NEGATE] =
{ .tag = JET
, .jet = simplicity_ge_negate
, .cmr = {{0x3d2c8de4u, 0xc7015fd3u, 0x132695fdu, 0x66dfcf0fu, 0x1778c791u, 0x85268e9fu, 0xae7789dau, 0x538eca59u}}
, .sourceIx = ty_w512
, .targetIx = ty_w512
, .cost = 1071 /* milli weight units */
}
,[GEJ_ADD] =
{ .tag = JET
, .jet = simplicity_gej_add
, .cmr = {{0x45ba7f3du, 0x1e1e6d34u, 0x9fcf8698u, 0x7b0e7f7au, 0xce662e82u, 0x201d3502u, 0x60454e2fu, 0xfeecb54du}}
, .sourceIx = ty_ppw512w256pw512w256
, .targetIx = ty_pw512w256
, .cost = 3000 /* milli weight units */
}
,[GEJ_DOUBLE] =
{ .tag = JET
, .jet = simplicity_gej_double
, .cmr = {{0x23e978f3u, 0x4154119bu, 0xdefc5d13u, 0xfcfd0a34u, 0xa75e3726u, 0xd6cb2581u, 0x3370ad7du, 0x9de5e133u}}
, .sourceIx = ty_pw512w256
, .targetIx = ty_pw512w256
, .cost = 1862 /* milli weight units */
}
,[GEJ_EQUIV] =
{ .tag = JET
, .jet = simplicity_gej_equiv
, .cmr = {{0xb94b2aacu, 0x73a67f44u, 0x95859913u, 0x4de23017u, 0x9e9d6bb6u, 0x47fd0611u, 0x158aaba7u, 0x0b73e400u}}
, .sourceIx = ty_ppw512w256pw512w256
, .targetIx = ty_b
, .cost = 2376 /* milli weight units */
}
,[GEJ_GE_ADD] =
{ .tag = JET
, .jet = simplicity_gej_ge_add
, .cmr = {{0xf1160b6fu, 0x5ee2c582u, 0xe49566e6u, 0xc386b380u, 0x94abc1a7u, 0x182d33a1u, 0x501fa2aau, 0xf00af3eau}}
, .sourceIx = ty_ppw512w256w512
, .targetIx = ty_pw512w256
, .cost = 2609 /* milli weight units */
}
,[GEJ_GE_ADD_EX] =
{ .tag = JET
, .jet = simplicity_gej_ge_add_ex
, .cmr = {{0xc3d7347fu, 0xfe2d9c83u, 0x9aac567eu, 0x2998e016u, 0xaf394e2au, 0x1929314bu, 0x52e31eedu, 0x678e30bfu}}
, .sourceIx = ty_ppw512w256w512
, .targetIx = ty_pw256pw512w256
, .cost = 2860 /* milli weight units */
}
,[GEJ_GE_EQUIV] =
{ .tag = JET
, .jet = simplicity_gej_ge_equiv
, .cmr = {{0x27c29969u, 0x139f8d57u, 0xedc9895cu, 0x30403df0u, 0x15c50ce7u, 0x21c381fbu, 0x197c0c04u, 0x03f1db0cu}}
, .sourceIx = ty_ppw512w256w512
, .targetIx = ty_b
, .cost = 1823 /* milli weight units */
}
,[GEJ_INFINITY] =
{ .tag = JET
, .jet = simplicity_gej_infinity
, .cmr = {{0xaafb9380u, 0xd61a7f14u, 0x7846806bu, 0x2cc374fbu, 0xe82dd1aeu, 0xd485b98au, 0x0f164b3au, 0x54c2c0b0u}}
, .sourceIx = ty_u
, .targetIx = ty_pw512w256
, .cost = 765 /* milli weight units */
}
,[GEJ_IS_INFINITY] =
{ .tag = JET
, .jet = simplicity_gej_is_infinity
, .cmr = {{0xdb495fd1u, 0x3142e9b3u, 0x3763fc6du, 0x48d2fb0eu, 0x71b0d9d9u, 0x9bd726f4u, 0x7ad13fc5u, 0x560670a2u}}
, .sourceIx = ty_pw512w256
, .targetIx = ty_b
, .cost = 701 /* milli weight units */
}
,[GEJ_IS_ON_CURVE] =
{ .tag = JET
, .jet = simplicity_gej_is_on_curve
, .cmr = {{0xbf4ca13fu, 0xf212e34bu, 0xf17d90c1u, 0x2e453d08u, 0xac7daa4au, 0x47d57e85u, 0xb43f2d43u, 0x66d43ddau}}
, .sourceIx = ty_pw512w256
, .targetIx = ty_b
, .cost = 1039 /* milli weight units */
}
,[GEJ_NEGATE] =
{ .tag = JET
, .jet = simplicity_gej_negate
, .cmr = {{0x01bd1a35u, 0x1fb8164cu, 0x813d916du, 0x07774999u, 0x6b7db118u, 0xd31586cau, 0x9d75e756u, 0x3518f454u}}
, .sourceIx = ty_pw512w256
, .targetIx = ty_pw512w256
, .cost = 1549 /* milli weight units */
}
,[GEJ_NORMALIZE] =
{ .tag = JET
, .jet = simplicity_gej_normalize
, .cmr = {{0xec597d17u, 0xe2efb6d2u, 0xa002d50eu, 0x677527d3u, 0xd4a2907au, 0x119d68f1u, 0x2284b9a1u, 0xb0d2303au}}
, .sourceIx = ty_pw512w256
, .targetIx = ty_mw512
, .cost = 4184 /* milli weight units */
}
,[GEJ_RESCALE] =
{ .tag = JET
, .jet = simplicity_gej_rescale
, .cmr = {{0x2977d953u, 0xef7a1156u, 0xcec6db2du, 0xc2925412u, 0x75cbc82fu, 0xb829fd67u, 0x1b972e89u, 0xebed0c24u}}
, .sourceIx = ty_ppw512w256w256
, .targetIx = ty_pw512w256
, .cost = 2011 /* milli weight units */
}
,[GEJ_X_EQUIV] =
{ .tag = JET
, .jet = simplicity_gej_x_equiv
, .cmr = {{0xf9f189fcu, 0x00b61f72u, 0xf10baaa2u, 0x1bcd88e5u, 0xd22e0aa9u, 0xb7509ae1u, 0x62a183a4u, 0xb664a4afu}}
, .sourceIx = ty_pw256pw512w256
, .targetIx = ty_b
, .cost = 1103 /* milli weight units */
}
,[GEJ_Y_IS_ODD] =
{ .tag = JET
, .jet = simplicity_gej_y_is_odd
, .cmr = {{0x9eb6e453u, 0x5fb69bf6u, 0x09916599u, 0xf1345ad7u, 0x735da3f3u, 0x948d0686u, 0x908e44f4u, 0x5b2ff60cu}}
, .sourceIx = ty_pw512w256
, .targetIx = ty_b
, .cost = 3702 /* milli weight units */
}
,[GENERATE] =
{ .tag = JET
, .jet = simplicity_generate
, .cmr = {{0x148885acu, 0x73813113u, 0xc523e809u, 0xbea47ffdu, 0x8b1daf37u, 0x8d9dd54bu, 0xf966ccb8u, 0x83b1a984u}}
, .sourceIx = ty_w256
, .targetIx = ty_pw512w256
, .cost = 49851 /* milli weight units */
}
,[HASH_TO_CURVE] =
{ .tag = JET
, .jet = simplicity_hash_to_curve
, .cmr = {{0xef4f548bu, 0x3c6c7517u, 0x5f2ce2d1u, 0x993b2d19u, 0x9beb16c0u, 0xa140175cu, 0x48a1277eu, 0xfc43a99bu}}
, .sourceIx = ty_w256
, .targetIx = ty_w512
, .cost = 69844 /* milli weight units */
}
,[HIGH_1] =
{ .tag = JET
, .jet = simplicity_high_1
, .cmr = {{0xb109cf1cu, 0xce35f7e9u, 0xb649671au, 0x9b45dbc2u, 0x4099a713u, 0xaeb9a89cu, 0xc4cf6ef6u, 0xed8b308bu}}
, .sourceIx = ty_u
, .targetIx = ty_b
, .cost = 42 /* milli weight units */
}
,[HIGH_16] =
{ .tag = JET
, .jet = simplicity_high_16
, .cmr = {{0x035dadd9u, 0xd7bf7433u, 0x6445e71du, 0xdc4d8202u, 0x24ff7e38u, 0xe0b8d52bu, 0xec9729b5u, 0x72b531f9u}}
, .sourceIx = ty_u
, .targetIx = ty_w16
, .cost = 50 /* milli weight units */
}
,[HIGH_32] =
{ .tag = JET
, .jet = simplicity_high_32
, .cmr = {{0xc5f1df0du, 0x64a2737au, 0x631b3aaeu, 0x8f260e8bu, 0x8dc1957bu, 0xd092911bu, 0x91d2078au, 0xd21e418au}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 64 /* milli weight units */
}
,[HIGH_64] =
{ .tag = JET
, .jet = simplicity_high_64
, .cmr = {{0xa312633eu, 0x0a2305e6u, 0x9b3f341du, 0x91d683ddu, 0x94196a2fu, 0x9005c9b1u, 0x872a2c15u, 0xad46cf17u}}
, .sourceIx = ty_u
, .targetIx = ty_w64
, .cost = 52 /* milli weight units */
}
,[HIGH_8] =
{ .tag = JET
, .jet = simplicity_high_8
, .cmr = {{0xcbd78d50u, 0xaf779985u, 0x5adc4903u, 0xdbbefc13u, 0x45d51484u, 0xf03d3c75u, 0x5caaa5cau, 0xa97d4a14u}}
, .sourceIx = ty_u
, .targetIx = ty_w8
, .cost = 59 /* milli weight units */
}
,[INCREMENT_16] =
{ .tag = JET
, .jet = simplicity_increment_16
, .cmr = {{0x86774949u, 0x39b27b86u, 0xcb5a8c7fu, 0x8172ad55u, 0x509531c9u, 0xb0e11e99u, 0x757e296cu, 0xc3c7c192u}}
, .sourceIx = ty_w16
, .targetIx = ty_pbw16
, .cost = 56 /* milli weight units */
}
,[INCREMENT_32] =
{ .tag = JET
, .jet = simplicity_increment_32
, .cmr = {{0x6bdbab7cu, 0xfc16c503u, 0x363c2f07u, 0x7e02c335u, 0xda406175u, 0xd192fbefu, 0x50c07fc2u, 0x79b3f40cu}}
, .sourceIx = ty_w32
, .targetIx = ty_pbw32
, .cost = 73 /* milli weight units */
}
,[INCREMENT_64] =
{ .tag = JET
, .jet = simplicity_increment_64
, .cmr = {{0x20e75e71u, 0x7cb76d46u, 0x95564f7cu, 0x20221b7au, 0x01431387u, 0x38f151aau, 0x195eb170u, 0xec13c049u}}
, .sourceIx = ty_w64
, .targetIx = ty_pbw64
, .cost = 64 /* milli weight units */
}
,[INCREMENT_8] =
{ .tag = JET
, .jet = simplicity_increment_8
, .cmr = {{0x5f4e056eu, 0xf4ed8d68u, 0xbf911fc5u, 0xcb69037eu, 0xbf6c9221u, 0x7343a890u, 0x5d38c432u, 0xc183233cu}}
, .sourceIx = ty_w8
, .targetIx = ty_pbw8
, .cost = 69 /* milli weight units */
}
,[INPUT_ANNEX_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_annex_hash
, .cmr = {{0x945b147eu, 0x5f0edb83u, 0x2d62348cu, 0xaeeac224u, 0x56eee944u, 0x65376dbfu, 0x596b9d62u, 0x985b01b6u}}
, .sourceIx = ty_w32
, .targetIx = ty_mmw256
, .cost = 77 /* milli weight units */
}
,[INPUT_ANNEXES_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_annexes_hash
, .cmr = {{0x89b60270u, 0x44141f20u, 0x65b6f236u, 0xcfcc13b9u, 0x68485e00u, 0x746b7859u, 0x286903c6u, 0x8c7f880du}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 124 /* milli weight units */
}
,[INPUT_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_hash
, .cmr = {{0x3ad22231u, 0xd6b9dff6u, 0xa0b4dbcfu, 0xf044e11cu, 0x082e0468u, 0x4e73ce95u, 0xc205e0c4u, 0x496e5ecau}}
, .sourceIx = ty_w32
, .targetIx = ty_mw256
, .cost = 832 /* milli weight units */
}
,[INPUT_OUTPOINTS_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_outpoints_hash
, .cmr = {{0x1759c6f4u, 0x70b9aba6u, 0x2a31791eu, 0xa01056e3u, 0x608bdf22u, 0xf5dd43bfu, 0x7db00ea5u, 0x823f7cceu}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 126 /* milli weight units */
}
,[INPUT_PREV_OUTPOINT] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_prev_outpoint
, .cmr = {{0x5d171242u, 0x09ee0521u, 0x24e55238u, 0xe0b6a6feu, 0x85a48688u, 0xc1e15e61u, 0x81de94f7u, 0x8db04018u}}
, .sourceIx = ty_w32
, .targetIx = ty_mpw256w32
, .cost = 140 /* milli weight units */
}
,[INPUT_SCRIPT_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_script_hash
, .cmr = {{0x0562412fu, 0x021da481u, 0x9b019c8cu, 0xd887d530u, 0x492b9f94u, 0x2c4ebf21u, 0xae39ed32u, 0x330d7cfeu}}
, .sourceIx = ty_w32
, .targetIx = ty_mw256
, .cost = 143 /* milli weight units */
}
,[INPUT_SCRIPT_SIG_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_script_sig_hash
, .cmr = {{0x1c7efb37u, 0xcbc4b996u, 0xd9b8c617u, 0x08e66573u, 0xce87c1f0u, 0xaa0522d0u, 0x65ba9025u, 0x056e3f80u}}
, .sourceIx = ty_w32
, .targetIx = ty_mw256
, .cost = 137 /* milli weight units */
}
,[INPUT_SCRIPT_SIGS_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_script_sigs_hash
, .cmr = {{0xe729c5f5u, 0x8a938908u, 0x1a5ca845u, 0xf76cb980u, 0xf08599ceu, 0xb3c7d7eau, 0xe1145b53u, 0xa60ae3d5u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 127 /* milli weight units */
}
,[INPUT_SCRIPTS_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_scripts_hash
, .cmr = {{0xf177671du, 0x60960e46u, 0x3a9a8f7eu, 0x1f5213aau, 0xba9122d2u, 0xdb75fe91u, 0xf8f1cf91u, 0xbe001907u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 129 /* milli weight units */
}
,[INPUT_SEQUENCE] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_sequence
, .cmr = {{0x5dd17fe1u, 0x550f48f7u, 0xbaed4d06u, 0x8008d4a1u, 0xff98cbebu, 0xe2541c5du, 0xc77ac53au, 0xd83fa779u}}
, .sourceIx = ty_w32
, .targetIx = ty_mw32
, .cost = 78 /* milli weight units */
}
,[INPUT_SEQUENCES_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_sequences_hash
, .cmr = {{0x55973d64u, 0x43457472u, 0x81377364u, 0xbad2a80bu, 0x758f4566u, 0x60c18de5u, 0xc01a3882u, 0x071d50e8u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 125 /* milli weight units */
}
,[INPUT_UTXO_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_utxo_hash
, .cmr = {{0x931e4e95u, 0xe0a64760u, 0x276e91b5u, 0xdc746780u, 0xd0697d0au, 0xf5aaf5bbu, 0xc81dbeb3u, 0x98596abbu}}
, .sourceIx = ty_w32
, .targetIx = ty_mw256
, .cost = 824 /* milli weight units */
}
,[INPUT_UTXOS_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_utxos_hash
, .cmr = {{0xd6f90cd1u, 0x04e1a5c6u, 0x1a4b5000u, 0xad9aba8du, 0x43004bf9u, 0x43df325fu, 0xa636d1a2u, 0x2beca0cbu}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 122 /* milli weight units */
}
,[INPUT_VALUE] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_value
, .cmr = {{0x7d3c3f95u, 0x5b2cf0d0u, 0xd1280a1bu, 0xb1204692u, 0x92d1329cu, 0x83a9c2ffu, 0x7e7e1eb3u, 0xf69783a3u}}
, .sourceIx = ty_w32
, .targetIx = ty_mw64
, .cost = 81 /* milli weight units */
}
,[INPUT_VALUES_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_input_values_hash
, .cmr = {{0x29839eadu, 0x0eb03fe4u, 0x6542e36du, 0x71e9e6afu, 0xdf969301u, 0x533d74eeu, 0x099b1266u, 0xa250552cu}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 126 /* milli weight units */
}
,[INPUTS_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_inputs_hash
, .cmr = {{0xabbfe1c7u, 0xd115c419u, 0x1f504839u, 0xf98c3f20u, 0x422b84e7u, 0xfa14da14u, 0x02896c4du, 0x98bfa8d8u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 122 /* milli weight units */
}
,[INTERNAL_KEY] =
{ .tag = JET
, .jet = simplicity_bitcoin_internal_key
, .cmr = {{0x37483699u, 0x2810022fu, 0x88e0145bu, 0xcad77f4au, 0x8491fa80u, 0x83cb51c3u, 0x01fcf7a1u, 0x3478c2ccu}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 124 /* milli weight units */
}
,[IS_ONE_16] =
{ .tag = JET
, .jet = simplicity_is_one_16
, .cmr = {{0x1bd3a253u, 0xdb243fcau, 0x45533799u, 0xfe914838u, 0xc38e3806u, 0xb12bd7e8u, 0x5ca71207u, 0xa88462b0u}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 64 /* milli weight units */
}
,[IS_ONE_32] =
{ .tag = JET
, .jet = simplicity_is_one_32
, .cmr = {{0x78b1bae0u, 0x99ec9c59u, 0xcbf41262u, 0x51c1e967u, 0x41b350d5u, 0x63bd74d5u, 0x4418ba78u, 0xebea25bfu}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 64 /* milli weight units */
}
,[IS_ONE_64] =
{ .tag = JET
, .jet = simplicity_is_one_64
, .cmr = {{0x817b95a5u, 0x395efbecu, 0xbb8515a5u, 0x5b3ffe1au, 0x4d7bac6eu, 0x23dbca54u, 0xad606666u, 0x2f202b93u}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 66 /* milli weight units */
}
,[IS_ONE_8] =
{ .tag = JET
, .jet = simplicity_is_one_8
, .cmr = {{0xf6925491u, 0xd34b3774u, 0x2cb08decu, 0x193ee512u, 0x5f933cadu, 0xcc232aedu, 0xeedb572du, 0x1260ffd5u}}
, .sourceIx = ty_w8
, .targetIx = ty_b
, .cost = 47 /* milli weight units */
}
,[IS_ZERO_16] =
{ .tag = JET
, .jet = simplicity_is_zero_16
, .cmr = {{0x1ba7213bu, 0x588be092u, 0xb446599cu, 0x2a60ff54u, 0x67136a79u, 0x7599610bu, 0xd7a5f178u, 0x04e32a2cu}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 52 /* milli weight units */
}
,[IS_ZERO_32] =
{ .tag = JET
, .jet = simplicity_is_zero_32
, .cmr = {{0x5ebf1466u, 0x93f0e2d2u, 0xf9361b47u, 0x6dba3485u, 0x8b832d66u, 0xfacf713bu, 0xfb32c3bbu, 0x8db9eebfu}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 58 /* milli weight units */
}
,[IS_ZERO_64] =
{ .tag = JET
, .jet = simplicity_is_zero_64
, .cmr = {{0x19ab9ac0u, 0xcf426682u, 0x19ba6cb8u, 0x97e487feu, 0x3680937fu, 0xffa8d203u, 0x511db75du, 0xbb10c7e5u}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 68 /* milli weight units */
}
,[IS_ZERO_8] =
{ .tag = JET
, .jet = simplicity_is_zero_8
, .cmr = {{0x8eff6208u, 0x4407e9afu, 0xd540f318u, 0xf66bcf31u, 0xdf1d42a5u, 0xc161cae3u, 0x5a294818u, 0x0ca2aa2eu}}
, .sourceIx = ty_w8
, .targetIx = ty_b
, .cost = 59 /* milli weight units */
}
,[LE_16] =
{ .tag = JET
, .jet = simplicity_le_16
, .cmr = {{0x016705a7u, 0xd7dce1afu, 0xc63eab84u, 0x203f5f42u, 0xd6b6bbadu, 0x75cee38cu, 0xec5a515bu, 0x5997489fu}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 83 /* milli weight units */
}
,[LE_32] =
{ .tag = JET
, .jet = simplicity_le_32
, .cmr = {{0x5351fc5du, 0xebe5b298u, 0xad7057e4u, 0xa5a76a3bu, 0x9c658acdu, 0xe7d1bb52u, 0xe5889ca1u, 0xe38f5efbu}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 99 /* milli weight units */
}
,[LE_64] =
{ .tag = JET
, .jet = simplicity_le_64
, .cmr = {{0xae2de1e0u, 0xcf730d1du, 0xcc96d7ccu, 0xfe71168au, 0x240deaf8u, 0x04615a7bu, 0xa920dc16u, 0xfd6ea45fu}}
, .sourceIx = ty_w128
, .targetIx = ty_b
, .cost = 79 /* milli weight units */
}
,[LE_8] =
{ .tag = JET
, .jet = simplicity_le_8
, .cmr = {{0xaf29f616u, 0x8ebdc09eu, 0xfbe0e639u, 0xcb750b12u, 0x05788f90u, 0x21d666efu, 0xcefe13f1u, 0x2f9671f0u}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 93 /* milli weight units */
}
,[LEFT_EXTEND_16_32] =
{ .tag = JET
, .jet = simplicity_left_extend_16_32
, .cmr = {{0x289997fbu, 0xa1fae7ecu, 0x1c4531c5u, 0x0bbf8671u, 0xb897139bu, 0xdd3aad97u, 0xa3763957u, 0x4a047c80u}}
, .sourceIx = ty_w16
, .targetIx = ty_w32
, .cost = 72 /* milli weight units */
}
,[LEFT_EXTEND_16_64] =
{ .tag = JET
, .jet = simplicity_left_extend_16_64
, .cmr = {{0x5dff21f6u, 0xe6124775u, 0xc578eaf4u, 0x855c0b01u, 0x64f7879bu, 0x1760f902u, 0x7cb50f7bu, 0x5acb4918u}}
, .sourceIx = ty_w16
, .targetIx = ty_w64
, .cost = 69 /* milli weight units */
}
,[LEFT_EXTEND_1_16] =
{ .tag = JET
, .jet = simplicity_left_extend_1_16
, .cmr = {{0x8c87d756u, 0xd14bd3d9u, 0xa7869081u, 0x2912b894u, 0x29c0171au, 0x41103a58u, 0xc6e9f225u, 0x141a0222u}}
, .sourceIx = ty_b
, .targetIx = ty_w16
, .cost = 50 /* milli weight units */
}
,[LEFT_EXTEND_1_32] =
{ .tag = JET
, .jet = simplicity_left_extend_1_32
, .cmr = {{0xc8f154d4u, 0x6d2e7895u, 0xda1b33c2u, 0xb315e6d4u, 0xd4851ddeu, 0xe28aef8bu, 0x70709061u, 0x6bc7eea0u}}
, .sourceIx = ty_b
, .targetIx = ty_w32
, .cost = 48 /* milli weight units */
}
,[LEFT_EXTEND_1_64] =
{ .tag = JET
, .jet = simplicity_left_extend_1_64
, .cmr = {{0xa3404df6u, 0x8cc92075u, 0x4c6e1847u, 0x207db384u, 0x5d11c749u, 0x09d07ca8u, 0x2ad1f1ccu, 0x67bf3a9bu}}
, .sourceIx = ty_b
, .targetIx = ty_w64
, .cost = 49 /* milli weight units */
}
,[LEFT_EXTEND_1_8] =
{ .tag = JET
, .jet = simplicity_left_extend_1_8
, .cmr = {{0x3bca3397u, 0xb83c27f3u, 0x6316f8b8u, 0xb303350au, 0xfe8ba007u, 0x8f77f1d4u, 0x2a9b7892u, 0xb2a4dbeeu}}
, .sourceIx = ty_b
, .targetIx = ty_w8
, .cost = 46 /* milli weight units */
}
,[LEFT_EXTEND_32_64] =
{ .tag = JET
, .jet = simplicity_left_extend_32_64
, .cmr = {{0x42cbeb01u, 0xfe7a3a6du, 0xd3311db3u, 0x365f91e5u, 0xc118c7e4u, 0x1f03aae7u, 0xb283de6bu, 0xb9053e6bu}}
, .sourceIx = ty_w32
, .targetIx = ty_w64
, .cost = 69 /* milli weight units */
}
,[LEFT_EXTEND_8_16] =
{ .tag = JET
, .jet = simplicity_left_extend_8_16
, .cmr = {{0x9a57c96au, 0xf5714896u, 0xb724de45u, 0xeb9fe97du, 0x73697de6u, 0x2e8dad78u, 0x71eb58f5u, 0x81a011bbu}}
, .sourceIx = ty_w8
, .targetIx = ty_w16
, .cost = 58 /* milli weight units */
}
,[LEFT_EXTEND_8_32] =
{ .tag = JET
, .jet = simplicity_left_extend_8_32
, .cmr = {{0xd624bd40u, 0x40763cb1u, 0x3ccad498u, 0xf53d38c1u, 0x12f19295u, 0x6826dafeu, 0xc9ac9165u, 0x792b347au}}
, .sourceIx = ty_w8
, .targetIx = ty_w32
, .cost = 86 /* milli weight units */
}
,[LEFT_EXTEND_8_64] =
{ .tag = JET
, .jet = simplicity_left_extend_8_64
, .cmr = {{0x9dc4a205u, 0x4d5d2634u, 0x2ac590b6u, 0x67f1b01du, 0xf54fd0cdu, 0xaa405ef8u, 0xcbb76fd8u, 0xf9b00ee5u}}
, .sourceIx = ty_w8
, .targetIx = ty_w64
, .cost = 98 /* milli weight units */
}
,[LEFT_PAD_HIGH_16_32] =
{ .tag = JET
, .jet = simplicity_left_pad_high_16_32
, .cmr = {{0x0545c4b5u, 0x8f004a21u, 0xe7f129a4u, 0xc0518997u, 0x1714caa2u, 0xd91d1dfdu, 0x5fad3e63u, 0x24499428u}}
, .sourceIx = ty_w16
, .targetIx = ty_w32
, .cost = 71 /* milli weight units */
}
,[LEFT_PAD_HIGH_16_64] =
{ .tag = JET
, .jet = simplicity_left_pad_high_16_64
, .cmr = {{0x1c61d03du, 0x493bbd05u, 0x822259d1u, 0x730a8d7au, 0x5f55b0bau, 0x2a9391a6u, 0xc8881eb4u, 0x7504affdu}}
, .sourceIx = ty_w16
, .targetIx = ty_w64
, .cost = 82 /* milli weight units */
}
,[LEFT_PAD_HIGH_1_16] =
{ .tag = JET
, .jet = simplicity_left_pad_high_1_16
, .cmr = {{0x56fdf54fu, 0x1fcd1982u, 0x5e7c3b79u, 0x0615c1d3u, 0xfe82886cu, 0x747bc487u, 0x5987f505u, 0x16945fb3u}}
, .sourceIx = ty_b
, .targetIx = ty_w16
, .cost = 106 /* milli weight units */
}
,[LEFT_PAD_HIGH_1_32] =
{ .tag = JET
, .jet = simplicity_left_pad_high_1_32
, .cmr = {{0xdb33059au, 0xbe2d432du, 0x67f42b1eu, 0x942756dcu, 0xa6cde637u, 0x85e5bd43u, 0x0dc8f4aeu, 0xfc31b8dfu}}
, .sourceIx = ty_b
, .targetIx = ty_w32
, .cost = 220 /* milli weight units */
}
,[LEFT_PAD_HIGH_1_64] =
{ .tag = JET
, .jet = simplicity_left_pad_high_1_64
, .cmr = {{0x1d669c1fu, 0xa5fd3ef6u, 0x6eb4aef6u, 0x186e3ec1u, 0x36ee7584u, 0x10df3edeu, 0xbb31bf26u, 0xd4562051u}}
, .sourceIx = ty_b
, .targetIx = ty_w64
, .cost = 302 /* milli weight units */
}
,[LEFT_PAD_HIGH_1_8] =
{ .tag = JET
, .jet = simplicity_left_pad_high_1_8
, .cmr = {{0x9a1bad3du, 0x8ab90030u, 0x3da202f0u, 0xf449f0b7u, 0xe6795c2au, 0x7c121718u, 0x800ac40cu, 0x87d82729u}}
, .sourceIx = ty_b
, .targetIx = ty_w8
, .cost = 73 /* milli weight units */
}
,[LEFT_PAD_HIGH_32_64] =
{ .tag = JET
, .jet = simplicity_left_pad_high_32_64
, .cmr = {{0x3920cc4bu, 0x33baf7efu, 0xa5caf9e7u, 0x80014467u, 0x06f6e4e8u, 0x26567405u, 0x7eed8717u, 0x78089e94u}}
, .sourceIx = ty_w32
, .targetIx = ty_w64
, .cost = 69 /* milli weight units */
}
,[LEFT_PAD_HIGH_8_16] =
{ .tag = JET
, .jet = simplicity_left_pad_high_8_16
, .cmr = {{0x752e29f2u, 0xfe2becc3u, 0xf66290feu, 0x44e1aeb3u, 0x784180ddu, 0x905e1962u, 0x4e195f21u, 0x6c07c57cu}}
, .sourceIx = ty_w8
, .targetIx = ty_w16
, .cost = 65 /* milli weight units */
}
,[LEFT_PAD_HIGH_8_32] =
{ .tag = JET
, .jet = simplicity_left_pad_high_8_32
, .cmr = {{0xbee88f1cu, 0x8c30634cu, 0x6e95caccu, 0x0e9add49u, 0x413221fdu, 0xabbd8d4cu, 0x0accf1cau, 0xe2d2a778u}}
, .sourceIx = ty_w8
, .targetIx = ty_w32
, .cost = 105 /* milli weight units */
}
,[LEFT_PAD_HIGH_8_64] =
{ .tag = JET
, .jet = simplicity_left_pad_high_8_64
, .cmr = {{0x392387f6u, 0xdc04bfc5u, 0x4dd4a281u, 0x19c81d15u, 0xd7a5809bu, 0xbf62fcc2u, 0x7dc55cf8u, 0x2e9e5ee6u}}
, .sourceIx = ty_w8
, .targetIx = ty_w64
, .cost = 113 /* milli weight units */
}
,[LEFT_PAD_LOW_16_32] =
{ .tag = JET
, .jet = simplicity_left_pad_low_16_32
, .cmr = {{0x4ffd6cb3u, 0x40230582u, 0x1dd89970u, 0xd722d1c1u, 0x3f1ff773u, 0x9fd5f34bu, 0xa16c7365u, 0x3b044718u}}
, .sourceIx = ty_w16
, .targetIx = ty_w32
, .cost = 65 /* milli weight units */
}
,[LEFT_PAD_LOW_16_64] =
{ .tag = JET
, .jet = simplicity_left_pad_low_16_64
, .cmr = {{0xbe3eb85cu, 0x5f199153u, 0xfb1c4613u, 0x5c04facfu, 0xdbc6f1b7u, 0x8c2bb7aeu, 0x75f155bcu, 0x3ea08a8bu}}
, .sourceIx = ty_w16
, .targetIx = ty_w64
, .cost = 68 /* milli weight units */
}
,[LEFT_PAD_LOW_1_16] =
{ .tag = JET
, .jet = simplicity_left_pad_low_1_16
, .cmr = {{0xddd0153eu, 0xf312f28du, 0x642cd94cu, 0xb36f3297u, 0x75b00da8u, 0x8fccc4ceu, 0xa1bae89bu, 0xad13be6bu}}
, .sourceIx = ty_b
, .targetIx = ty_w16
, .cost = 59 /* milli weight units */
}
,[LEFT_PAD_LOW_1_32] =
{ .tag = JET
, .jet = simplicity_left_pad_low_1_32
, .cmr = {{0xbc9d3114u, 0x35467bc0u, 0x8b1008e5u, 0x47aa7a07u, 0xe83b1514u, 0x6861a9e9u, 0xb5413be3u, 0x1b82b6b5u}}
, .sourceIx = ty_b
, .targetIx = ty_w32
, .cost = 47 /* milli weight units */
}
,[LEFT_PAD_LOW_1_64] =
{ .tag = JET
, .jet = simplicity_left_pad_low_1_64
, .cmr = {{0x8bc62f93u, 0x60894e48u, 0xa4732c95u, 0x769c8faau, 0xe9568f9du, 0xe8e8a200u, 0x836bd4e5u, 0x0b02cd84u}}
, .sourceIx = ty_b
, .targetIx = ty_w64
, .cost = 46 /* milli weight units */
}
,[LEFT_PAD_LOW_1_8] =
{ .tag = JET
, .jet = simplicity_left_pad_low_1_8
, .cmr = {{0xf66cd7a4u, 0x2b320f97u, 0xc19f2d54u, 0x16cde087u, 0x253a2791u, 0x2965d55bu, 0x65712ad8u, 0x09b83cfdu}}
, .sourceIx = ty_b
, .targetIx = ty_w8
, .cost = 48 /* milli weight units */
}
,[LEFT_PAD_LOW_32_64] =
{ .tag = JET
, .jet = simplicity_left_pad_low_32_64
, .cmr = {{0xa33a07b9u, 0xbcf945f6u, 0x4f072b8bu, 0x9c914839u, 0xa585bfa9u, 0xf3425b14u, 0x7754ab55u, 0xa8ba6c0fu}}
, .sourceIx = ty_w32
, .targetIx = ty_w64
, .cost = 62 /* milli weight units */
}
,[LEFT_PAD_LOW_8_16] =
{ .tag = JET
, .jet = simplicity_left_pad_low_8_16
, .cmr = {{0x2a516a79u, 0x3f97c45fu, 0xeaebb1ccu, 0x961a156du, 0x80354928u, 0x79789d6eu, 0xdc9b57e7u, 0x2f11e5b5u}}
, .sourceIx = ty_w8
, .targetIx = ty_w16
, .cost = 56 /* milli weight units */
}
,[LEFT_PAD_LOW_8_32] =
{ .tag = JET
, .jet = simplicity_left_pad_low_8_32
, .cmr = {{0x1aa2e4d0u, 0x4bd69055u, 0x123dd6aau, 0xfe27f5f7u, 0xf47c3b30u, 0x90c3a827u, 0x2973fe2fu, 0x75165a5du}}
, .sourceIx = ty_w8
, .targetIx = ty_w32
, .cost = 75 /* milli weight units */
}
,[LEFT_PAD_LOW_8_64] =
{ .tag = JET
, .jet = simplicity_left_pad_low_8_64
, .cmr = {{0xb652e0aeu, 0xdd0f4f66u, 0xf6a1cd4bu, 0xebf875ffu, 0x7bbb2dd9u, 0x9b065b2du, 0xb5b5b590u, 0x5361614du}}
, .sourceIx = ty_w8
, .targetIx = ty_w64
, .cost = 116 /* milli weight units */
}
,[LEFT_ROTATE_16] =
{ .tag = JET
, .jet = simplicity_left_rotate_16
, .cmr = {{0x8a12ff6au, 0x4bf23715u, 0xdd3b766bu, 0x9967c715u, 0x8bf3ed74u, 0xb3dce730u, 0xaffcf466u, 0x16478ecbu}}
, .sourceIx = ty_pw4w16
, .targetIx = ty_w16
, .cost = 88 /* milli weight units */
}
,[LEFT_ROTATE_32] =
{ .tag = JET
, .jet = simplicity_left_rotate_32
, .cmr = {{0x2fcb5217u, 0x2fd49c36u, 0x217deae0u, 0xc2371432u, 0x1f69f5f1u, 0x3f6e94b2u, 0xbdfe4b74u, 0x88697fd5u}}
, .sourceIx = ty_pw8w32
, .targetIx = ty_w32
, .cost = 62 /* milli weight units */
}
,[LEFT_ROTATE_64] =
{ .tag = JET
, .jet = simplicity_left_rotate_64
, .cmr = {{0x72ccd6c4u, 0xe5fdf68au, 0xd33b6d58u, 0xfb372be4u, 0xf1b80eefu, 0x701f9db7u, 0xe5ed859bu, 0x96b36209u}}
, .sourceIx = ty_pw8w64
, .targetIx = ty_w64
, .cost = 68 /* milli weight units */
}
,[LEFT_ROTATE_8] =
{ .tag = JET
, .jet = simplicity_left_rotate_8
, .cmr = {{0x1aaec9f3u, 0xb75d89f8u, 0x2a649845u, 0x8c4483cbu, 0x9a784489u, 0x05f3bb39u, 0xfc083f14u, 0xddccdc9bu}}
, .sourceIx = ty_pw4w8
, .targetIx = ty_w8
, .cost = 66 /* milli weight units */
}
,[LEFT_SHIFT_16] =
{ .tag = JET
, .jet = simplicity_left_shift_16
, .cmr = {{0x37ac6387u, 0x21ab097au, 0x9602ba4du, 0xc92e19b5u, 0xa185b232u, 0x9f1aa600u, 0xcb9c1561u, 0x5a0081f8u}}
, .sourceIx = ty_pw4w16
, .targetIx = ty_w16
, .cost = 109 /* milli weight units */
}
,[LEFT_SHIFT_32] =
{ .tag = JET
, .jet = simplicity_left_shift_32
, .cmr = {{0x8e3c473bu, 0x2867f154u, 0x73b3632du, 0xbfdd9977u, 0x5551ef5fu, 0x9dba475eu, 0x9cf09075u, 0x8070f0bfu}}
, .sourceIx = ty_pw8w32
, .targetIx = ty_w32
, .cost = 79 /* milli weight units */
}
,[LEFT_SHIFT_64] =
{ .tag = JET
, .jet = simplicity_left_shift_64
, .cmr = {{0x5049f404u, 0xd173299au, 0x3aee04cbu, 0xc2462cb3u, 0x4c8069c1u, 0xb6db7fedu, 0x0e388ff6u, 0xd467a086u}}
, .sourceIx = ty_pw8w64
, .targetIx = ty_w64
, .cost = 70 /* milli weight units */
}
,[LEFT_SHIFT_8] =
{ .tag = JET
, .jet = simplicity_left_shift_8
, .cmr = {{0x832f636eu, 0x63446cefu, 0xba8df3a4u, 0x6efbb361u, 0x59c18854u, 0x567768adu, 0xc9b8db8au, 0x07492a58u}}
, .sourceIx = ty_pw4w8
, .targetIx = ty_w8
, .cost = 72 /* milli weight units */
}
,[LEFT_SHIFT_WITH_16] =
{ .tag = JET
, .jet = simplicity_left_shift_with_16
, .cmr = {{0xe64762b1u, 0xc5e6144au, 0x7181eaafu, 0x4dd9d9b3u, 0xaa43aad9u, 0x55158198u, 0xee2090ebu, 0xd9e4bb0du}}
, .sourceIx = ty_pbpw4w16
, .targetIx = ty_w16
, .cost = 72 /* milli weight units */
}
,[LEFT_SHIFT_WITH_32] =
{ .tag = JET
, .jet = simplicity_left_shift_with_32
, .cmr = {{0x6476ba89u, 0x95f83b5eu, 0xe1ebc22cu, 0xb416f558u, 0x157f2e57u, 0x699a5cafu, 0x84291ff3u, 0xfc1483c1u}}
, .sourceIx = ty_pbpw8w32
, .targetIx = ty_w32
, .cost = 87 /* milli weight units */
}
,[LEFT_SHIFT_WITH_64] =
{ .tag = JET
, .jet = simplicity_left_shift_with_64
, .cmr = {{0x06b8fe67u, 0xcfc58632u, 0x2397af02u, 0x4fde2911u, 0xf7ae87a0u, 0x6abc6c59u, 0x30934097u, 0x15691c19u}}
, .sourceIx = ty_pbpw8w64
, .targetIx = ty_w64
, .cost = 97 /* milli weight units */
}
,[LEFT_SHIFT_WITH_8] =
{ .tag = JET
, .jet = simplicity_left_shift_with_8
, .cmr = {{0xb1ac9c68u, 0x2358c45bu, 0xabf40695u, 0x56fe6e37u, 0x5b4554deu, 0x9e10c591u, 0xc1483984u, 0x47ac180eu}}
, .sourceIx = ty_pbpw4w8
, .targetIx = ty_w8
, .cost = 104 /* milli weight units */
}
,[LEFTMOST_16_1] =
{ .tag = JET
, .jet = simplicity_leftmost_16_1
, .cmr = {{0x5bff4cb5u, 0x587605d5u, 0xfd059d77u, 0x33490d7du, 0xd22d278bu, 0x599e06d3u, 0xb5db6d79u, 0xf3c923bdu}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 68 /* milli weight units */
}
,[LEFTMOST_16_2] =
{ .tag = JET
, .jet = simplicity_leftmost_16_2
, .cmr = {{0x536db486u, 0xb12227e5u, 0xb09d6febu, 0xd2776b1au, 0xbbc67499u, 0x96aa783eu, 0xd7e53744u, 0x6bbf151bu}}
, .sourceIx = ty_w16
, .targetIx = ty_w2
, .cost = 58 /* milli weight units */
}
,[LEFTMOST_16_4] =
{ .tag = JET
, .jet = simplicity_leftmost_16_4
, .cmr = {{0xf2321367u, 0x496d1a77u, 0xeea05e95u, 0xe3b807d3u, 0xba5f0513u, 0x6ce0912au, 0xe717c83au, 0x0261b2e1u}}
, .sourceIx = ty_w16
, .targetIx = ty_w4
, .cost = 51 /* milli weight units */
}
,[LEFTMOST_16_8] =
{ .tag = JET
, .jet = simplicity_leftmost_16_8
, .cmr = {{0x24148ef3u, 0x0ad43ebeu, 0xc5637283u, 0x22c3ce11u, 0x79aed7a7u, 0x8216d799u, 0x888bf18bu, 0x39570671u}}
, .sourceIx = ty_w16
, .targetIx = ty_w8
, .cost = 62 /* milli weight units */
}
,[LEFTMOST_32_1] =
{ .tag = JET
, .jet = simplicity_leftmost_32_1
, .cmr = {{0xb92e15ecu, 0x5da07ee8u, 0xed397cb9u, 0xf60a4c5du, 0xa8386293u, 0x1a907359u, 0xd27caeb6u, 0x0e60ef8au}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 53 /* milli weight units */
}
,[LEFTMOST_32_16] =
{ .tag = JET
, .jet = simplicity_leftmost_32_16
, .cmr = {{0xadb027b2u, 0x06567358u, 0x5326c01cu, 0x3be2faebu, 0x386349e2u, 0x9009b657u, 0x6ee53a85u, 0x5512cc67u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 63 /* milli weight units */
}
,[LEFTMOST_32_2] =
{ .tag = JET
, .jet = simplicity_leftmost_32_2
, .cmr = {{0xb75b31c5u, 0x59123d3du, 0x63359859u, 0x32b8b1b2u, 0x664ee597u, 0xafb15fd1u, 0xa499d007u, 0xcff2755cu}}
, .sourceIx = ty_w32
, .targetIx = ty_w2
, .cost = 62 /* milli weight units */
}
,[LEFTMOST_32_4] =
{ .tag = JET
, .jet = simplicity_leftmost_32_4
, .cmr = {{0xcb757e47u, 0x1e9d9a40u, 0x771dd1cfu, 0x3c1bf5d2u, 0x3c17ed68u, 0xcdbdb22du, 0xada17a73u, 0xa7b407b2u}}
, .sourceIx = ty_w32
, .targetIx = ty_w4
, .cost = 61 /* milli weight units */
}
,[LEFTMOST_32_8] =
{ .tag = JET
, .jet = simplicity_leftmost_32_8
, .cmr = {{0xbfc534b4u, 0x9e06006eu, 0x19f3b68eu, 0x0a02391cu, 0x149f9a34u, 0xf43ee36bu, 0x9f1d79a7u, 0x9c9a9e4du}}
, .sourceIx = ty_w32
, .targetIx = ty_w8
, .cost = 60 /* milli weight units */
}
,[LEFTMOST_64_1] =
{ .tag = JET
, .jet = simplicity_leftmost_64_1
, .cmr = {{0x1b1d4e92u, 0x384b8b15u, 0x9ba0d806u, 0x558b5494u, 0xe3614eedu, 0xe03c946cu, 0xeaf141f3u, 0x6f01c79bu}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 65 /* milli weight units */
}
,[LEFTMOST_64_16] =
{ .tag = JET
, .jet = simplicity_leftmost_64_16
, .cmr = {{0x0debdc1au, 0xa0433034u, 0x42e18fe0u, 0x3d8a99d2u, 0xbe6bb8a8u, 0x691aba19u, 0x566259e3u, 0x6760f7f9u}}
, .sourceIx = ty_w64
, .targetIx = ty_w16
, .cost = 62 /* milli weight units */
}
,[LEFTMOST_64_2] =
{ .tag = JET
, .jet = simplicity_leftmost_64_2
, .cmr = {{0x839ecfa3u, 0x18705c25u, 0x3d0c52ffu, 0x27b90464u, 0x923d8c0eu, 0x55a82c0du, 0x16240239u, 0x7f365378u}}
, .sourceIx = ty_w64
, .targetIx = ty_w2
, .cost = 61 /* milli weight units */
}
,[LEFTMOST_64_32] =
{ .tag = JET
, .jet = simplicity_leftmost_64_32
, .cmr = {{0x929197a9u, 0x642861a7u, 0x7bd66258u, 0x051197beu, 0x86ff08e6u, 0x28e30f7eu, 0xfcbd2c4du, 0xfecf9bddu}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 77 /* milli weight units */
}
,[LEFTMOST_64_4] =
{ .tag = JET
, .jet = simplicity_leftmost_64_4
, .cmr = {{0x02bd1645u, 0xd575f04bu, 0x3cbbaa6du, 0x8ca986efu, 0x1c8cd0ffu, 0xe1658903u, 0x939db764u, 0x562a2647u}}
, .sourceIx = ty_w64
, .targetIx = ty_w4
, .cost = 80 /* milli weight units */
}
,[LEFTMOST_64_8] =
{ .tag = JET
, .jet = simplicity_leftmost_64_8
, .cmr = {{0x3558b31bu, 0x3b6e8f9au, 0x288fdc72u, 0xf24602beu, 0x05581910u, 0x71a54a99u, 0xfa03a025u, 0x34f88005u}}
, .sourceIx = ty_w64
, .targetIx = ty_w8
, .cost = 54 /* milli weight units */
}
,[LEFTMOST_8_1] =
{ .tag = JET
, .jet = simplicity_leftmost_8_1
, .cmr = {{0x2865efd4u, 0x2983cbe3u, 0xf816373au, 0xb8a882f1u, 0x8317194du, 0xc1aba38du, 0xa0304b8cu, 0x144b1da4u}}
, .sourceIx = ty_w8
, .targetIx = ty_b
, .cost = 54 /* milli weight units */
}
,[LEFTMOST_8_2] =
{ .tag = JET
, .jet = simplicity_leftmost_8_2
, .cmr = {{0x51964cb0u, 0x7405a8d2u, 0x3d218774u, 0x1a9ed304u, 0xbcb469d9u, 0xac9f5d92u, 0x55825cfdu, 0xa3da07c0u}}
, .sourceIx = ty_w8
, .targetIx = ty_w2
, .cost = 71 /* milli weight units */
}
,[LEFTMOST_8_4] =
{ .tag = JET
, .jet = simplicity_leftmost_8_4
, .cmr = {{0x883c94f8u, 0xa26cdab7u, 0xbc5cd631u, 0xe52255a8u, 0x5ef6e070u, 0x766457f6u, 0x321e2ccbu, 0x119d9b2bu}}
, .sourceIx = ty_w8
, .targetIx = ty_w4
, .cost = 65 /* milli weight units */
}
,[LINEAR_COMBINATION_1] =
{ .tag = JET
, .jet = simplicity_linear_combination_1
, .cmr = {{0x3410a9eeu, 0x333df8c8u, 0xa01c1411u, 0x5b544327u, 0xe324e287u, 0xaa1107e0u, 0x1955bd20u, 0x506ea987u}}
, .sourceIx = ty_ppw256pw512w256w256
, .targetIx = ty_pw512w256
, .cost = 85743 /* milli weight units */
}
,[LINEAR_VERIFY_1] =
{ .tag = JET
, .jet = simplicity_linear_verify_1
, .cmr = {{0xdc66d331u, 0xc17f3fddu, 0xa3994698u, 0x1b39b357u, 0xd0555c35u, 0x62ecae02u, 0xaa2dad16u, 0x3e6c9a2eu}}
, .sourceIx = ty_pppw256w512w256w512
, .targetIx = ty_u
, .cost = 43579 /* milli weight units */
}
,[LOCK_TIME] =
{ .tag = JET
, .jet = simplicity_bitcoin_lock_time
, .cmr = {{0x9ae0acc3u, 0x7bc20447u, 0x79b07c3du, 0x4602a5fdu, 0xe8bc33f8u, 0x79f66b73u, 0x9b10f01au, 0xeb1154ecu}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 66 /* milli weight units */
}
,[LOW_1] =
{ .tag = JET
, .jet = simplicity_low_1
, .cmr = {{0xfe6214f9u, 0x67156dcdu, 0xe6dd49fdu, 0xc55efb86u, 0x5069feabu, 0xfff0fe93u, 0x1dba8531u, 0x34eed130u}}
, .sourceIx = ty_u
, .targetIx = ty_b
, .cost = 40 /* milli weight units */
}
,[LOW_16] =
{ .tag = JET
, .jet = simplicity_low_16
, .cmr = {{0x7493cf69u, 0x8a4882e5u, 0xc3579d06u, 0x518e7ecau, 0x2b8428f6u, 0x2e2b5138u, 0x02abe622u, 0x170c20feu}}
, .sourceIx = ty_u
, .targetIx = ty_w16
, .cost = 60 /* milli weight units */
}
,[LOW_32] =
{ .tag = JET
, .jet = simplicity_low_32
, .cmr = {{0x362d66a4u, 0xf0aeb965u, 0x84a56757u, 0x8271b1f7u, 0xbbfcc2deu, 0x0dcf9579u, 0x6b6f7a82u, 0x6b2a8af7u}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 52 /* milli weight units */
}
,[LOW_64] =
{ .tag = JET
, .jet = simplicity_low_64
, .cmr = {{0x973323bcu, 0x2b92e428u, 0x04d2e4f5u, 0x8b86f65bu, 0x56f91deeu, 0xb4810eabu, 0x8a1deda9u, 0x697a0872u}}
, .sourceIx = ty_u
, .targetIx = ty_w64
, .cost = 50 /* milli weight units */
}
,[LOW_8] =
{ .tag = JET
, .jet = simplicity_low_8
, .cmr = {{0xcd1a8558u, 0xef99a322u, 0x60217a76u, 0x49ff5140u, 0xda69da70u, 0x0672690bu, 0x27917b07u, 0xd7c14c67u}}
, .sourceIx = ty_u
, .targetIx = ty_w8
, .cost = 45 /* milli weight units */
}
,[LT_16] =
{ .tag = JET
, .jet = simplicity_lt_16
, .cmr = {{0x04aca87eu, 0x3e17f805u, 0xa21cf291u, 0x7aee9957u, 0xb950b2dbu, 0x5d7ae5c8u, 0x26d4ac2eu, 0xc97b5a52u}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 83 /* milli weight units */
}
,[LT_32] =
{ .tag = JET
, .jet = simplicity_lt_32
, .cmr = {{0x23a0a5c1u, 0x97747e3au, 0x9579e90eu, 0x0f22f84au, 0x29bfb5f0u, 0x7b84b59bu, 0x26688a0cu, 0xd59dfebdu}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 89 /* milli weight units */
}
,[LT_64] =
{ .tag = JET
, .jet = simplicity_lt_64
, .cmr = {{0xd299901cu, 0x7b5b3a59u, 0xffc8dd09u, 0x545a3238u, 0x24b779a9u, 0x9b2d1a2fu, 0x87452d9eu, 0x4befaf30u}}
, .sourceIx = ty_w128
, .targetIx = ty_b
, .cost = 71 /* milli weight units */
}
,[LT_8] =
{ .tag = JET
, .jet = simplicity_lt_8
, .cmr = {{0xdd94413bu, 0x529c298cu, 0x1696e9fbu, 0x08e66767u, 0xb3f8337au, 0xc02e44b0u, 0x68e94014u, 0xf7c41f2au}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 86 /* milli weight units */
}
,[MAJ_1] =
{ .tag = JET
, .jet = simplicity_maj_1
, .cmr = {{0x0e6fb40fu, 0xe31a3a52u, 0x6b44cf0bu, 0x7c7936c7u, 0x77cbba89u, 0x65a72552u, 0x32a7cf53u, 0xa922885au}}
, .sourceIx = ty_pbw2
, .targetIx = ty_b
, .cost = 54 /* milli weight units */
}
,[MAJ_16] =
{ .tag = JET
, .jet = simplicity_maj_16
, .cmr = {{0x38669ce5u, 0xe1e17147u, 0x5400731bu, 0xeeb60bcau, 0xfad66604u, 0xc9394016u, 0x0cd71288u, 0x35559342u}}
, .sourceIx = ty_pw16w32
, .targetIx = ty_w16
, .cost = 85 /* milli weight units */
}
,[MAJ_32] =
{ .tag = JET
, .jet = simplicity_maj_32
, .cmr = {{0x5554349bu, 0x584f5c38u, 0x72c7f4f2u, 0x57829e2au, 0xe822d823u, 0x424ceb95u, 0x98f08318u, 0x586a8807u}}
, .sourceIx = ty_pw32w64
, .targetIx = ty_w32
, .cost = 73 /* milli weight units */
}
,[MAJ_64] =
{ .tag = JET
, .jet = simplicity_maj_64
, .cmr = {{0x734903bau, 0xefb71d5eu, 0xa41648ffu, 0x43eee698u, 0x94e063b3u, 0x88ea422fu, 0x96aede19u, 0x3ceab839u}}
, .sourceIx = ty_pw64w128
, .targetIx = ty_w64
, .cost = 79 /* milli weight units */
}
,[MAJ_8] =
{ .tag = JET
, .jet = simplicity_maj_8
, .cmr = {{0xba47a399u, 0xdc9435e1u, 0x8e080a4eu, 0x18af7c65u, 0x7fd39f7cu, 0xe7d6052eu, 0x46902311u, 0xb078d585u}}
, .sourceIx = ty_pw8w16
, .targetIx = ty_w8
, .cost = 64 /* milli weight units */
}
,[MAX_16] =
{ .tag = JET
, .jet = simplicity_max_16
, .cmr = {{0xaa552374u, 0x6cabfaf5u, 0x668e9e07u, 0x37e56b06u, 0x062251d7u, 0xe80ab9b9u, 0x106d8f17u, 0x2dc84dd6u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 80 /* milli weight units */
}
,[MAX_32] =
{ .tag = JET
, .jet = simplicity_max_32
, .cmr = {{0x6922965du, 0x144345c9u, 0x13ecb30bu, 0x5ed47e88u, 0xdae35c12u, 0x21f26aa9u, 0x2dd5a5f6u, 0x15dbdb53u}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 70 /* milli weight units */
}
,[MAX_64] =
{ .tag = JET
, .jet = simplicity_max_64
, .cmr = {{0x8a9be907u, 0xb6a4c30au, 0xbcc0f22du, 0x013074c2u, 0xd56bb081u, 0xf2621857u, 0xd538cc97u, 0x131e4409u}}
, .sourceIx = ty_w128
, .targetIx = ty_w64
, .cost = 75 /* milli weight units */
}
,[MAX_8] =
{ .tag = JET
, .jet = simplicity_max_8
, .cmr = {{0xb4bf9323u, 0x4022e860u, 0xfe76c0b5u, 0x360e8b36u, 0xff81ee67u, 0x05b593acu, 0xdf655ac6u, 0xe6d7aebau}}
, .sourceIx = ty_w16
, .targetIx = ty_w8
, .cost = 79 /* milli weight units */
}
,[MEDIAN_16] =
{ .tag = JET
, .jet = simplicity_median_16
, .cmr = {{0x17e2e87fu, 0x0760f4fbu, 0x3c9fd0beu, 0xd000d739u, 0x73ab60f5u, 0xe6c2c1fau, 0xb17f9b23u, 0xee6aca48u}}
, .sourceIx = ty_pw16w32
, .targetIx = ty_w16
, .cost = 80 /* milli weight units */
}
,[MEDIAN_32] =
{ .tag = JET
, .jet = simplicity_median_32
, .cmr = {{0x1160ae8eu, 0xa8d30f9au, 0x2233c48eu, 0x731240f8u, 0x4493b828u, 0xb55793e2u, 0xf4042a19u, 0x82ac26a5u}}
, .sourceIx = ty_pw32w64
, .targetIx = ty_w32
, .cost = 77 /* milli weight units */
}
,[MEDIAN_64] =
{ .tag = JET
, .jet = simplicity_median_64
, .cmr = {{0xc8737364u, 0x9e7e4050u, 0xbb73337eu, 0x08eb5de4u, 0x5228ab86u, 0xad4e1f41u, 0x91e5202au, 0xa6afa0c5u}}
, .sourceIx = ty_pw64w128
, .targetIx = ty_w64
, .cost = 89 /* milli weight units */
}
,[MEDIAN_8] =
{ .tag = JET
, .jet = simplicity_median_8
, .cmr = {{0xc3b4e089u, 0x8a21bde9u, 0x4daed37au, 0x20adf90cu, 0x8be5691au, 0x03b6a1e5u, 0x56385d42u, 0xeb19022bu}}
, .sourceIx = ty_pw8w16
, .targetIx = ty_w8
, .cost = 77 /* milli weight units */
}
,[MIN_16] =
{ .tag = JET
, .jet = simplicity_min_16
, .cmr = {{0x5fd0051eu, 0xdb3719a6u, 0x45b272a0u, 0x2108efbbu, 0x3d9bc0f6u, 0x0621bf5au, 0x5babe116u, 0xd555d578u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 83 /* milli weight units */
}
,[MIN_32] =
{ .tag = JET
, .jet = simplicity_min_32
, .cmr = {{0xd80782a2u, 0xb5d86ab6u, 0xb9c9c3fbu, 0x778a3473u, 0xf600b185u, 0xfe1925eeu, 0x9fc2e877u, 0x7ed26601u}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 96 /* milli weight units */
}
,[MIN_64] =
{ .tag = JET
, .jet = simplicity_min_64
, .cmr = {{0xc5c09d50u, 0x1338e9a5u, 0x12cf8976u, 0xca4b32b9u, 0x2480bef6u, 0xaeb29d36u, 0xd590d35bu, 0xf9f9ece1u}}
, .sourceIx = ty_w128
, .targetIx = ty_w64
, .cost = 82 /* milli weight units */
}
,[MIN_8] =
{ .tag = JET
, .jet = simplicity_min_8
, .cmr = {{0x81d21e12u, 0x81423881u, 0x802c0e0cu, 0x7d22bd34u, 0xd26bd12au, 0x4c4f1b70u, 0x68e7e183u, 0x820848e9u}}
, .sourceIx = ty_w16
, .targetIx = ty_w8
, .cost = 78 /* milli weight units */
}
,[MODULO_16] =
{ .tag = JET
, .jet = simplicity_modulo_16
, .cmr = {{0xb6b87cfau, 0xb67e5519u, 0xf1c998dau, 0x479437bbu, 0x79e674f7u, 0x15e9a2e5u, 0x38eec5ecu, 0x18e18ea5u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 85 /* milli weight units */
}
,[MODULO_32] =
{ .tag = JET
, .jet = simplicity_modulo_32
, .cmr = {{0x8d486e83u, 0x1654f38au, 0x32da35ebu, 0x7bb655a6u, 0xed694dbfu, 0xa058957du, 0x9f5cbfccu, 0x5792c65bu}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 81 /* milli weight units */
}
,[MODULO_64] =
{ .tag = JET
, .jet = simplicity_modulo_64
, .cmr = {{0x14df20d9u, 0x3dfdefe2u, 0x559bac50u, 0xed38193bu, 0xd78bd63fu, 0x929d86fbu, 0x4f29a7c5u, 0xaf3242adu}}
, .sourceIx = ty_w128
, .targetIx = ty_w64
, .cost = 71 /* milli weight units */
}
,[MODULO_8] =
{ .tag = JET
, .jet = simplicity_modulo_8
, .cmr = {{0x2c758a7cu, 0x0f59e800u, 0xe94f3dc5u, 0xa001bf8eu, 0xd9435f75u, 0xa2d96930u, 0xc57eaab0u, 0xcd80af5cu}}
, .sourceIx = ty_w16
, .targetIx = ty_w8
, .cost = 85 /* milli weight units */
}
,[MULTIPLY_16] =
{ .tag = JET
, .jet = simplicity_multiply_16
, .cmr = {{0x75bd41f2u, 0xd2b339f0u, 0x69bfdfd8u, 0x02d61e6cu, 0xa8e3bad6u, 0xfb6d95b6u, 0x72095b93u, 0x345f047fu}}
, .sourceIx = ty_w32
, .targetIx = ty_w32
, .cost = 79 /* milli weight units */
}
,[MULTIPLY_32] =
{ .tag = JET
, .jet = simplicity_multiply_32
, .cmr = {{0x84cbe6ceu, 0x87037992u, 0x13877c1bu, 0xd505c764u, 0x34336900u, 0x2e502c43u, 0xd97f3d57u, 0x772d6c87u}}
, .sourceIx = ty_w64
, .targetIx = ty_w64
, .cost = 78 /* milli weight units */
}
,[MULTIPLY_64] =
{ .tag = JET
, .jet = simplicity_multiply_64
, .cmr = {{0x92987b80u, 0x1b92f679u, 0xeb961368u, 0x8444a178u, 0x8750a850u, 0x6e03a921u, 0x8c21ecc7u, 0x2082dc6au}}
, .sourceIx = ty_w128
, .targetIx = ty_w128
, .cost = 72 /* milli weight units */
}
,[MULTIPLY_8] =
{ .tag = JET
, .jet = simplicity_multiply_8
, .cmr = {{0x764cab71u, 0xdb9459a7u, 0x696d944au, 0x50095b1au, 0xebdfd928u, 0x4bdb7496u, 0xa7b30241u, 0xccba3eceu}}
, .sourceIx = ty_w16
, .targetIx = ty_w16
, .cost = 79 /* milli weight units */
}
,[NEGATE_16] =
{ .tag = JET
, .jet = simplicity_negate_16
, .cmr = {{0xe760ee40u, 0x29c34f89u, 0x7406ffdeu, 0xa5558486u, 0x62e89c98u, 0x3e6070bdu, 0x0272ad0fu, 0xa342efa3u}}
, .sourceIx = ty_w16
, .targetIx = ty_pbw16
, .cost = 69 /* milli weight units */
}
,[NEGATE_32] =
{ .tag = JET
, .jet = simplicity_negate_32
, .cmr = {{0x8495b740u, 0x09ad07c9u, 0x302a25aeu, 0x56c3e973u, 0x3f00c2bau, 0xa410eac4u, 0xa58e75dbu, 0x83af1d22u}}
, .sourceIx = ty_w32
, .targetIx = ty_pbw32
, .cost = 56 /* milli weight units */
}
,[NEGATE_64] =
{ .tag = JET
, .jet = simplicity_negate_64
, .cmr = {{0x34e89fafu, 0x345afd5eu, 0x7b290014u, 0x52fc5fc2u, 0xe3783af7u, 0xf2101643u, 0xbd76706au, 0x6fc3f36au}}
, .sourceIx = ty_w64
, .targetIx = ty_pbw64
, .cost = 56 /* milli weight units */
}
,[NEGATE_8] =
{ .tag = JET
, .jet = simplicity_negate_8
, .cmr = {{0xe81be0b1u, 0x5c671ab8u, 0xdf1f4869u, 0xc57f1111u, 0x18cb6683u, 0x54975c63u, 0x66ecb2b8u, 0xbb7c15cfu}}
, .sourceIx = ty_w8
, .targetIx = ty_pbw8
, .cost = 69 /* milli weight units */
}
,[NUM_INPUTS] =
{ .tag = JET
, .jet = simplicity_bitcoin_num_inputs
, .cmr = {{0x5c5ac4ffu, 0x6da56cb3u, 0x72b23266u, 0x6e8334b9u, 0xe2cfb0dcu, 0xb418f161u, 0xbff149e8u, 0x4ec92c3eu}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 74 /* milli weight units */
}
,[NUM_OUTPUTS] =
{ .tag = JET
, .jet = simplicity_bitcoin_num_outputs
, .cmr = {{0x98a1cca7u, 0x05dfcfafu, 0xd3a69e9au, 0xdc05ba47u, 0xe1fefa6au, 0x29f34286u, 0x2048e496u, 0x8648c3d7u}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 68 /* milli weight units */
}
,[ONE_16] =
{ .tag = JET
, .jet = simplicity_one_16
, .cmr = {{0x2e5e3d95u, 0xe4531688u, 0x8e4f3709u, 0xef832b9fu, 0xd9e15f30u, 0x719bf55fu, 0xc2e0e09au, 0x3657d882u}}
, .sourceIx = ty_u
, .targetIx = ty_w16
, .cost = 45 /* milli weight units */
}
,[ONE_32] =
{ .tag = JET
, .jet = simplicity_one_32
, .cmr = {{0x06426b85u, 0x3c1bcb33u, 0x8aedbe1fu, 0x89a6d9b7u, 0xa3da038cu, 0xd00a4471u, 0x18369349u, 0x669e2976u}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 45 /* milli weight units */
}
,[ONE_64] =
{ .tag = JET
, .jet = simplicity_one_64
, .cmr = {{0xab1d2cd9u, 0x9678da3cu, 0x128d39adu, 0x9fe6ffa9u, 0x55c16e5eu, 0xf2c25bb4u, 0x31831559u, 0x6951f427u}}
, .sourceIx = ty_u
, .targetIx = ty_w64
, .cost = 45 /* milli weight units */
}
,[ONE_8] =
{ .tag = JET
, .jet = simplicity_one_8
, .cmr = {{0x3cc5f523u, 0xd6a6355du, 0xc924ee0au, 0xc1f5fe2cu, 0x521275e3u, 0xaa9f21d3u, 0x1b082db2u, 0xac230d9du}}
, .sourceIx = ty_u
, .targetIx = ty_w8
, .cost = 46 /* milli weight units */
}
,[OR_1] =
{ .tag = JET
, .jet = simplicity_or_1
, .cmr = {{0xc4659643u, 0x69fca209u, 0x7f83530cu, 0x87bcbc90u, 0xc306579du, 0x9f3bfeddu, 0xf4a172a4u, 0xea0b58ecu}}
, .sourceIx = ty_w2
, .targetIx = ty_b
, .cost = 56 /* milli weight units */
}
,[OR_16] =
{ .tag = JET
, .jet = simplicity_or_16
, .cmr = {{0x5a985e04u, 0x3b85273bu, 0x90f90e20u, 0xf82b7532u, 0x3351cf2au, 0x4e62a7f9u, 0xcb2f0596u, 0x402e9e28u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 78 /* milli weight units */
}
,[OR_32] =
{ .tag = JET
, .jet = simplicity_or_32
, .cmr = {{0x3552383au, 0x57ffb48du, 0x63a0337au, 0xf0dd6efau, 0xb6b46c5du, 0xe1720e42u, 0x0bdd1c82u, 0x276bc9a9u}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 80 /* milli weight units */
}
,[OR_64] =
{ .tag = JET
, .jet = simplicity_or_64
, .cmr = {{0x51a173dau, 0xdca01ac6u, 0xf62e75d5u, 0xcd3522f0u, 0x9fde62b1u, 0x1513e068u, 0x422852a4u, 0x9167b606u}}
, .sourceIx = ty_w128
, .targetIx = ty_w64
, .cost = 71 /* milli weight units */
}
,[OR_8] =
{ .tag = JET
, .jet = simplicity_or_8
, .cmr = {{0x79efbdcbu, 0x537bebcbu, 0x188d1116u, 0xb78a109bu, 0xffbc2a6cu, 0xe3d1f870u, 0x154a7956u, 0x091b342fu}}
, .sourceIx = ty_w16
, .targetIx = ty_w8
, .cost = 81 /* milli weight units */
}
,[OUTPOINT_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_outpoint_hash
, .cmr = {{0x3a1ae90eu, 0x167fb40du, 0x6e13b451u, 0xad67410du, 0x8dd991c8u, 0x7d6a4a59u, 0xcc76c63fu, 0x3b9e5e56u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pw256w32
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 1788 /* milli weight units */
}
,[OUTPUT_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_output_hash
, .cmr = {{0x91211fc6u, 0x011a6493u, 0x00c6bee9u, 0x4fdd48a9u, 0x7fa2a9b6u, 0xf284be01u, 0x5d462d17u, 0xde664ac3u}}
, .sourceIx = ty_w32
, .targetIx = ty_mw256
, .cost = 822 /* milli weight units */
}
,[OUTPUT_SCRIPT_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_output_script_hash
, .cmr = {{0xbdfdb231u, 0xf4f1a62cu, 0x9d7b0393u, 0x1e7f19a4u, 0x546af234u, 0x754cbf70u, 0x059fdd42u, 0xbbbc4126u}}
, .sourceIx = ty_w32
, .targetIx = ty_mw256
, .cost = 135 /* milli weight units */
}
,[OUTPUT_SCRIPTS_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_output_scripts_hash
, .cmr = {{0xff20bc43u, 0x65e71707u, 0x571c6e17u, 0x38e1ed32u, 0x6f7c351du, 0xe13022aeu, 0xa3d6406bu, 0x8aee8e3bu}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 123 /* milli weight units */
}
,[OUTPUT_VALUE] =
{ .tag = JET
, .jet = simplicity_bitcoin_output_value
, .cmr = {{0x933643b6u, 0xc5a6220au, 0xbbca6f35u, 0x09feff6du, 0x13efa6c9u, 0xfae95924u, 0x575364f2u, 0xb164d2bcu}}
, .sourceIx = ty_w32
, .targetIx = ty_mw64
, .cost = 82 /* milli weight units */
}
,[OUTPUT_VALUES_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_output_values_hash
, .cmr = {{0x22899379u, 0x0057066fu, 0x2016971du, 0xf55e6f67u, 0xd252efb6u, 0xdaabd0fcu, 0x566a8d21u, 0x56efbbfcu}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 119 /* milli weight units */
}
,[OUTPUTS_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_outputs_hash
, .cmr = {{0xf2eb6d0fu, 0x018e6f15u, 0xe35baa82u, 0xe57e14feu, 0x343796f2u, 0x196826beu, 0xd7c78755u, 0x98d6641du}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 117 /* milli weight units */
}
,[PARSE_LOCK] =
{ .tag = JET
, .jet = simplicity_parse_lock
, .cmr = {{0x3db84535u, 0xfa3d90efu, 0x0b581e22u, 0xb61d2127u, 0x844b2116u, 0xe84f814au, 0x5cbac52du, 0xf515f2d2u}}
, .sourceIx = ty_w32
, .targetIx = ty_sw32w32
, .cost = 82 /* milli weight units */
}
,[PARSE_SEQUENCE] =
{ .tag = JET
, .jet = simplicity_parse_sequence
, .cmr = {{0x38b2533fu, 0x5fede869u, 0xbaa17069u, 0x83df4c89u, 0xd62d5f90u, 0x800b47eau, 0xb2111331u, 0x1a5aaec9u}}
, .sourceIx = ty_w32
, .targetIx = ty_msw16w16
, .cost = 93 /* milli weight units */
}
,[POINT_VERIFY_1] =
{ .tag = JET
, .jet = simplicity_point_verify_1
, .cmr = {{0xbe2a9890u, 0xf1d5b615u, 0x147f8241u, 0xe0609b5cu, 0xac01ece0u, 0xa3f92368u, 0x67b2bfdeu, 0xa1b8044eu}}
, .sourceIx = ty_pppw256pbw256w256pbw256
, .targetIx = ty_u
, .cost = 41394 /* milli weight units */
}
,[RIGHT_EXTEND_16_32] =
{ .tag = JET
, .jet = simplicity_right_extend_16_32
, .cmr = {{0xdbf18d87u, 0xa7892139u, 0xa388e9a9u, 0x83c48992u, 0xac35a845u, 0x56ee0defu, 0xc1dadf0cu, 0x5f471a26u}}
, .sourceIx = ty_w16
, .targetIx = ty_w32
, .cost = 73 /* milli weight units */
}
,[RIGHT_EXTEND_16_64] =
{ .tag = JET
, .jet = simplicity_right_extend_16_64
, .cmr = {{0xd011acc7u, 0x94e3c478u, 0x9accd0d5u, 0xfe4997d3u, 0x34d91f08u, 0x31a1eb35u, 0x04b4cb2du, 0xdf4797afu}}
, .sourceIx = ty_w16
, .targetIx = ty_w64
, .cost = 70 /* milli weight units */
}
,[RIGHT_EXTEND_32_64] =
{ .tag = JET
, .jet = simplicity_right_extend_32_64
, .cmr = {{0xa5aa5db1u, 0xe535e723u, 0x2ad36dafu, 0xba6d5a20u, 0x0d54eb85u, 0x3b75dc70u, 0xa594ed64u, 0xaa6bd9abu}}
, .sourceIx = ty_w32
, .targetIx = ty_w64
, .cost = 62 /* milli weight units */
}
,[RIGHT_EXTEND_8_16] =
{ .tag = JET
, .jet = simplicity_right_extend_8_16
, .cmr = {{0x8106d58au, 0x8066ee6eu, 0x15e55ca5u, 0x2cb7afd8u, 0xe3277587u, 0xbfd7dec0u, 0xbe37d406u, 0x742a3931u}}
, .sourceIx = ty_w8
, .targetIx = ty_w16
, .cost = 63 /* milli weight units */
}
,[RIGHT_EXTEND_8_32] =
{ .tag = JET
, .jet = simplicity_right_extend_8_32
, .cmr = {{0xdfa4bafau, 0x432a5338u, 0xd374deb6u, 0xb724b7f6u, 0xeae55861u, 0xfe731d43u, 0x048aa304u, 0xd1f7f9a2u}}
, .sourceIx = ty_w8
, .targetIx = ty_w32
, .cost = 69 /* milli weight units */
}
,[RIGHT_EXTEND_8_64] =
{ .tag = JET
, .jet = simplicity_right_extend_8_64
, .cmr = {{0x620a3703u, 0x8b6fa127u, 0x495f0b46u, 0x496f6435u, 0xdd2dad7eu, 0xf0c0fd2cu, 0xd65f54dcu, 0x185e997bu}}
, .sourceIx = ty_w8
, .targetIx = ty_w64
, .cost = 141 /* milli weight units */
}
,[RIGHT_PAD_HIGH_16_32] =
{ .tag = JET
, .jet = simplicity_right_pad_high_16_32
, .cmr = {{0x2b6abc38u, 0x321a7c54u, 0x2fb16974u, 0x621ced80u, 0x880db519u, 0xbb486093u, 0x426e8ce1u, 0x8e0169b1u}}
, .sourceIx = ty_w16
, .targetIx = ty_w32
, .cost = 66 /* milli weight units */
}
,[RIGHT_PAD_HIGH_16_64] =
{ .tag = JET
, .jet = simplicity_right_pad_high_16_64
, .cmr = {{0xad90d8ffu, 0xa57450b3u, 0xb5e90962u, 0x25349ed8u, 0xf072e101u, 0x7293f392u, 0xef854e03u, 0x19abc934u}}
, .sourceIx = ty_w16
, .targetIx = ty_w64
, .cost = 81 /* milli weight units */
}
,[RIGHT_PAD_HIGH_1_16] =
{ .tag = JET
, .jet = simplicity_right_pad_high_1_16
, .cmr = {{0x288158b1u, 0xc910877bu, 0x7eea3dfcu, 0xf2b2b788u, 0x922808b6u, 0xd6fa75f8u, 0x96771904u, 0x8b141249u}}
, .sourceIx = ty_b
, .targetIx = ty_w16
, .cost = 114 /* milli weight units */
}
,[RIGHT_PAD_HIGH_1_32] =
{ .tag = JET
, .jet = simplicity_right_pad_high_1_32
, .cmr = {{0xee2ad77fu, 0x668d3d6au, 0x2e68506eu, 0x4904cf50u, 0xa08460e1u, 0xd2b86a81u, 0xe14e41f8u, 0xda4cddf2u}}
, .sourceIx = ty_b
, .targetIx = ty_w32
, .cost = 220 /* milli weight units */
}
,[RIGHT_PAD_HIGH_1_64] =
{ .tag = JET
, .jet = simplicity_right_pad_high_1_64
, .cmr = {{0x3d6a7fe6u, 0x9a11642au, 0xced6842bu, 0x89aa1bb8u, 0x413e3990u, 0x63cc1678u, 0x6af7c033u, 0xdad58b95u}}
, .sourceIx = ty_b
, .targetIx = ty_w64
, .cost = 313 /* milli weight units */
}
,[RIGHT_PAD_HIGH_1_8] =
{ .tag = JET
, .jet = simplicity_right_pad_high_1_8
, .cmr = {{0x2844bdfdu, 0x6aba29dfu, 0x03f93aa6u, 0xaeb21c06u, 0x4028db05u, 0xff77d8d9u, 0x1cfdcdefu, 0xb190c5bdu}}
, .sourceIx = ty_b
, .targetIx = ty_w8
, .cost = 73 /* milli weight units */
}
,[RIGHT_PAD_HIGH_32_64] =
{ .tag = JET
, .jet = simplicity_right_pad_high_32_64
, .cmr = {{0xb432e532u, 0x1ae1714cu, 0xe19529d8u, 0x5f24ff89u, 0x87910ebcu, 0xf015f87fu, 0x15bbed55u, 0xf0a0e892u}}
, .sourceIx = ty_w32
, .targetIx = ty_w64
, .cost = 62 /* milli weight units */
}
,[RIGHT_PAD_HIGH_8_16] =
{ .tag = JET
, .jet = simplicity_right_pad_high_8_16
, .cmr = {{0x6f2d96c9u, 0x5413ca9au, 0xa8cc550fu, 0x2573e166u, 0x9956d607u, 0x692cf1cau, 0x6dc76d2fu, 0x2b4a3ac8u}}
, .sourceIx = ty_w8
, .targetIx = ty_w16
, .cost = 75 /* milli weight units */
}
,[RIGHT_PAD_HIGH_8_32] =
{ .tag = JET
, .jet = simplicity_right_pad_high_8_32
, .cmr = {{0xdf2c7f92u, 0x9900a449u, 0x01e6ff65u, 0x276a951au, 0xeb95df25u, 0x0b139714u, 0xd4195404u, 0xd77898edu}}
, .sourceIx = ty_w8
, .targetIx = ty_w32
, .cost = 81 /* milli weight units */
}
,[RIGHT_PAD_HIGH_8_64] =
{ .tag = JET
, .jet = simplicity_right_pad_high_8_64
, .cmr = {{0x79c01da3u, 0xe60b9c69u, 0x35ce3e15u, 0x98b17840u, 0xaf82dcb0u, 0xddc63aefu, 0x4a06e7f9u, 0xca5d2741u}}
, .sourceIx = ty_w8
, .targetIx = ty_w64
, .cost = 118 /* milli weight units */
}
,[RIGHT_PAD_LOW_16_32] =
{ .tag = JET
, .jet = simplicity_right_pad_low_16_32
, .cmr = {{0x6f201027u, 0xcc759802u, 0x30a07085u, 0x9c3e3802u, 0x36a1cb10u, 0xe61a01aau, 0x1f6d231du, 0x15142f25u}}
, .sourceIx = ty_w16
, .targetIx = ty_w32
, .cost = 62 /* milli weight units */
}
,[RIGHT_PAD_LOW_16_64] =
{ .tag = JET
, .jet = simplicity_right_pad_low_16_64
, .cmr = {{0xb86e1f0bu, 0xfec65598u, 0xd0a3d1ecu, 0x960305b9u, 0x6745673eu, 0x1b16bf32u, 0x7a716805u, 0x83d71d90u}}
, .sourceIx = ty_w16
, .targetIx = ty_w64
, .cost = 98 /* milli weight units */
}
,[RIGHT_PAD_LOW_1_16] =
{ .tag = JET
, .jet = simplicity_right_pad_low_1_16
, .cmr = {{0x052a6499u, 0xc93ee6bcu, 0x1ae657f8u, 0x5fd4d4feu, 0x677abceeu, 0x540d1340u, 0x33542e9au, 0xb60a63ddu}}
, .sourceIx = ty_b
, .targetIx = ty_w16
, .cost = 60 /* milli weight units */
}
,[RIGHT_PAD_LOW_1_32] =
{ .tag = JET
, .jet = simplicity_right_pad_low_1_32
, .cmr = {{0x5b70d428u, 0x960e95ccu, 0x40d51846u, 0xf53a4d0au, 0x35c9015du, 0x1500b6bcu, 0x849b7283u, 0x5e2bd440u}}
, .sourceIx = ty_b
, .targetIx = ty_w32
, .cost = 47 /* milli weight units */
}
,[RIGHT_PAD_LOW_1_64] =
{ .tag = JET
, .jet = simplicity_right_pad_low_1_64
, .cmr = {{0x44efeb87u, 0xca2ad7fdu, 0x4b73f163u, 0x07c7f059u, 0x02656f35u, 0x090fb0a4u, 0x326c6489u, 0x88ae1d39u}}
, .sourceIx = ty_b
, .targetIx = ty_w64
, .cost = 57 /* milli weight units */
}
,[RIGHT_PAD_LOW_1_8] =
{ .tag = JET
, .jet = simplicity_right_pad_low_1_8
, .cmr = {{0x9340398bu, 0xcc8ea83eu, 0xc840be72u, 0x9dbb8b81u, 0x207824eeu, 0x875d1582u, 0x59d6dad2u, 0x0a83930cu}}
, .sourceIx = ty_b
, .targetIx = ty_w8
, .cost = 48 /* milli weight units */
}
,[RIGHT_PAD_LOW_32_64] =
{ .tag = JET
, .jet = simplicity_right_pad_low_32_64
, .cmr = {{0x693e2810u, 0x1e04fda4u, 0x3b97e611u, 0xf0fe9800u, 0x0e14302eu, 0x5dcd6ed6u, 0x5eee42e3u, 0x4014242fu}}
, .sourceIx = ty_w32
, .targetIx = ty_w64
, .cost = 74 /* milli weight units */
}
,[RIGHT_PAD_LOW_8_16] =
{ .tag = JET
, .jet = simplicity_right_pad_low_8_16
, .cmr = {{0x096b25c3u, 0xc8415f04u, 0xd8832743u, 0xeb2f8456u, 0xd5f0a644u, 0x913d3ec5u, 0x9d34f455u, 0x2501fa20u}}
, .sourceIx = ty_w8
, .targetIx = ty_w16
, .cost = 62 /* milli weight units */
}
,[RIGHT_PAD_LOW_8_32] =
{ .tag = JET
, .jet = simplicity_right_pad_low_8_32
, .cmr = {{0xfc7f5722u, 0xa62aa220u, 0x18cc81cdu, 0x00a9326cu, 0x7fe9c63au, 0xbce2bda4u, 0xc0e66a3fu, 0x47c67c53u}}
, .sourceIx = ty_w8
, .targetIx = ty_w32
, .cost = 69 /* milli weight units */
}
,[RIGHT_PAD_LOW_8_64] =
{ .tag = JET
, .jet = simplicity_right_pad_low_8_64
, .cmr = {{0xa5bb7d5eu, 0xfca0e48du, 0x9d80c502u, 0x7115b485u, 0x781051e0u, 0xef46e4d6u, 0x08317a1cu, 0x4261bc46u}}
, .sourceIx = ty_w8
, .targetIx = ty_w64
, .cost = 98 /* milli weight units */
}
,[RIGHT_ROTATE_16] =
{ .tag = JET
, .jet = simplicity_right_rotate_16
, .cmr = {{0x482ea7e1u, 0x214501d9u, 0x3c9ad16fu, 0xa8b97bf5u, 0xb384fc2bu, 0x54789b8cu, 0xd9e784ccu, 0xd0eb9d57u}}
, .sourceIx = ty_pw4w16
, .targetIx = ty_w16
, .cost = 67 /* milli weight units */
}
,[RIGHT_ROTATE_32] =
{ .tag = JET
, .jet = simplicity_right_rotate_32
, .cmr = {{0x0941b6eeu, 0xea9af819u, 0x5b028afcu, 0x0bd2a534u, 0x218bf90du, 0x1a0e373du, 0x74741854u, 0x0b726d73u}}
, .sourceIx = ty_pw8w32
, .targetIx = ty_w32
, .cost = 77 /* milli weight units */
}
,[RIGHT_ROTATE_64] =
{ .tag = JET
, .jet = simplicity_right_rotate_64
, .cmr = {{0x444dbbc3u, 0xdd2a11a5u, 0xc7b0439fu, 0xdba99ac7u, 0x4a11b8eeu, 0xb2db301eu, 0x243ea891u, 0x22907152u}}
, .sourceIx = ty_pw8w64
, .targetIx = ty_w64
, .cost = 64 /* milli weight units */
}
,[RIGHT_ROTATE_8] =
{ .tag = JET
, .jet = simplicity_right_rotate_8
, .cmr = {{0x7265a30cu, 0x2e836e65u, 0x544aba91u, 0x1b64d18fu, 0xa69b1765u, 0x45856c77u, 0xc4f0d76fu, 0xc3f58351u}}
, .sourceIx = ty_pw4w8
, .targetIx = ty_w8
, .cost = 72 /* milli weight units */
}
,[RIGHT_SHIFT_16] =
{ .tag = JET
, .jet = simplicity_right_shift_16
, .cmr = {{0xcd57a3d3u, 0xab2d92d4u, 0xf0865504u, 0x3a8b8bb6u, 0x738981fau, 0xe6da0134u, 0xb4dedaceu, 0x5f008860u}}
, .sourceIx = ty_pw4w16
, .targetIx = ty_w16
, .cost = 60 /* milli weight units */
}
,[RIGHT_SHIFT_32] =
{ .tag = JET
, .jet = simplicity_right_shift_32
, .cmr = {{0xd6b326b1u, 0xa32357a3u, 0x32807d3fu, 0xa1b156c2u, 0x8b1622f7u, 0x38def126u, 0x81467f34u, 0x9bd3494bu}}
, .sourceIx = ty_pw8w32
, .targetIx = ty_w32
, .cost = 69 /* milli weight units */
}
,[RIGHT_SHIFT_64] =
{ .tag = JET
, .jet = simplicity_right_shift_64
, .cmr = {{0xb2095f2du, 0x47335d5fu, 0x98c85434u, 0xa2faf5b0u, 0xf75cf899u, 0x012a34bbu, 0xcd0a14cbu, 0xedb61107u}}
, .sourceIx = ty_pw8w64
, .targetIx = ty_w64
, .cost = 68 /* milli weight units */
}
,[RIGHT_SHIFT_8] =
{ .tag = JET
, .jet = simplicity_right_shift_8
, .cmr = {{0x4b2b1aa2u, 0xef732173u, 0x170d621au, 0x38deb261u, 0xe473c07cu, 0x558b055au, 0x25a86e4eu, 0x321afc04u}}
, .sourceIx = ty_pw4w8
, .targetIx = ty_w8
, .cost = 63 /* milli weight units */
}
,[RIGHT_SHIFT_WITH_16] =
{ .tag = JET
, .jet = simplicity_right_shift_with_16
, .cmr = {{0x14b77685u, 0x47b3d3f4u, 0x7ee5c2b8u, 0x0d9bdae2u, 0xaec1f9c6u, 0x594ed312u, 0x7b12645au, 0xdcf59754u}}
, .sourceIx = ty_pbpw4w16
, .targetIx = ty_w16
, .cost = 83 /* milli weight units */
}
,[RIGHT_SHIFT_WITH_32] =
{ .tag = JET
, .jet = simplicity_right_shift_with_32
, .cmr = {{0x327b6e98u, 0xa6fd340cu, 0x60cf83aau, 0x64993311u, 0x4cb8d84fu, 0x590e0121u, 0x3a261001u, 0x2b4607eau}}
, .sourceIx = ty_pbpw8w32
, .targetIx = ty_w32
, .cost = 78 /* milli weight units */
}
,[RIGHT_SHIFT_WITH_64] =
{ .tag = JET
, .jet = simplicity_right_shift_with_64
, .cmr = {{0x062fa74au, 0xf3476e59u, 0x387be08eu, 0x6949a005u, 0x43bc84a2u, 0xb689ea39u, 0xad6eed7fu, 0x756785d4u}}
, .sourceIx = ty_pbpw8w64
, .targetIx = ty_w64
, .cost = 72 /* milli weight units */
}
,[RIGHT_SHIFT_WITH_8] =
{ .tag = JET
, .jet = simplicity_right_shift_with_8
, .cmr = {{0x141be47eu, 0x967b2fd7u, 0xc7126c5au, 0xdf2dfe47u, 0x315bbc10u, 0x53bbe605u, 0xb38898dbu, 0xed49f227u}}
, .sourceIx = ty_pbpw4w8
, .targetIx = ty_w8
, .cost = 71 /* milli weight units */
}
,[RIGHTMOST_16_1] =
{ .tag = JET
, .jet = simplicity_rightmost_16_1
, .cmr = {{0x3f3c4346u, 0x87174226u, 0x5e87f001u, 0xb46de7d1u, 0x98751b34u, 0xfaa18018u, 0xde60c846u, 0x8d9b98a4u}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 70 /* milli weight units */
}
,[RIGHTMOST_16_2] =
{ .tag = JET
, .jet = simplicity_rightmost_16_2
, .cmr = {{0xc18b9fddu, 0x340a267au, 0xc16d4f39u, 0xee754356u, 0x52aaca52u, 0x5650b51au, 0x45879804u, 0x8e627d51u}}
, .sourceIx = ty_w16
, .targetIx = ty_w2
, .cost = 65 /* milli weight units */
}
,[RIGHTMOST_16_4] =
{ .tag = JET
, .jet = simplicity_rightmost_16_4
, .cmr = {{0xc6c53fa7u, 0x1e230cf0u, 0x585158f4u, 0x70588bacu, 0x5c518f84u, 0xf9fc2386u, 0x52f175fbu, 0x6ea18c11u}}
, .sourceIx = ty_w16
, .targetIx = ty_w4
, .cost = 72 /* milli weight units */
}
,[RIGHTMOST_16_8] =
{ .tag = JET
, .jet = simplicity_rightmost_16_8
, .cmr = {{0xee769c1cu, 0xc8a3fdd1u, 0x838fc9f0u, 0x490ce703u, 0x93fd91bau, 0x3cbd4abdu, 0x08649fb9u, 0xc44311bdu}}
, .sourceIx = ty_w16
, .targetIx = ty_w8
, .cost = 69 /* milli weight units */
}
,[RIGHTMOST_32_1] =
{ .tag = JET
, .jet = simplicity_rightmost_32_1
, .cmr = {{0x1c442369u, 0xfb81f611u, 0xd328010bu, 0x864bccb7u, 0xf35ed477u, 0xdfa38555u, 0x74c13564u, 0xcdbdb860u}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 70 /* milli weight units */
}
,[RIGHTMOST_32_16] =
{ .tag = JET
, .jet = simplicity_rightmost_32_16
, .cmr = {{0xadd2c339u, 0x0d9af7c2u, 0x4a159a37u, 0xd69d4484u, 0xd2c24a2cu, 0xb5b0eb2du, 0x3c493d98u, 0x12acfd74u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 56 /* milli weight units */
}
,[RIGHTMOST_32_2] =
{ .tag = JET
, .jet = simplicity_rightmost_32_2
, .cmr = {{0x00b8815au, 0xd7423dd5u, 0x8cb98be8u, 0x2cad2667u, 0x5c3bf54au, 0x0bedbadeu, 0x3464b4feu, 0x5a4e8ce6u}}
, .sourceIx = ty_w32
, .targetIx = ty_w2
, .cost = 74 /* milli weight units */
}
,[RIGHTMOST_32_4] =
{ .tag = JET
, .jet = simplicity_rightmost_32_4
, .cmr = {{0x84fa5a54u, 0xf7729f9du, 0x68994beau, 0xb93ae79bu, 0x8c4a10d5u, 0xb7ae9727u, 0xaa1716e5u, 0x7d033b74u}}
, .sourceIx = ty_w32
, .targetIx = ty_w4
, .cost = 57 /* milli weight units */
}
,[RIGHTMOST_32_8] =
{ .tag = JET
, .jet = simplicity_rightmost_32_8
, .cmr = {{0x7d3805d3u, 0xc78c4eeau, 0x91e3d35eu, 0xfdd47eedu, 0xd421af84u, 0xd2191032u, 0x9332a0b5u, 0x487fab63u}}
, .sourceIx = ty_w32
, .targetIx = ty_w8
, .cost = 55 /* milli weight units */
}
,[RIGHTMOST_64_1] =
{ .tag = JET
, .jet = simplicity_rightmost_64_1
, .cmr = {{0xd3b164c5u, 0xdc66cc7eu, 0xf9234fedu, 0xe4dc7f0du, 0xa5cd71c1u, 0xc1d4cad6u, 0x0fb4ec57u, 0x3e2b8a75u}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 61 /* milli weight units */
}
,[RIGHTMOST_64_16] =
{ .tag = JET
, .jet = simplicity_rightmost_64_16
, .cmr = {{0xeae43478u, 0xf9f2f452u, 0xefac15eeu, 0xe60f8b52u, 0x53d80a2du, 0x32129b4eu, 0x5ba38300u, 0xad9852fdu}}
, .sourceIx = ty_w64
, .targetIx = ty_w16
, .cost = 63 /* milli weight units */
}
,[RIGHTMOST_64_2] =
{ .tag = JET
, .jet = simplicity_rightmost_64_2
, .cmr = {{0x9cd4a98bu, 0xbdb8a335u, 0x85c00f47u, 0xd6adab7au, 0xf54286fbu, 0x8ae60f72u, 0x3011fb84u, 0xc0ee78f9u}}
, .sourceIx = ty_w64
, .targetIx = ty_w2
, .cost = 65 /* milli weight units */
}
,[RIGHTMOST_64_32] =
{ .tag = JET
, .jet = simplicity_rightmost_64_32
, .cmr = {{0x7f2420aeu, 0x5b0f5a3fu, 0x6f2e60b6u, 0x1f8a415cu, 0x088b94b2u, 0x1c1a62a3u, 0xfdaac749u, 0xdbdf4c71u}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 64 /* milli weight units */
}
,[RIGHTMOST_64_4] =
{ .tag = JET
, .jet = simplicity_rightmost_64_4
, .cmr = {{0xe265552au, 0x24fbcdecu, 0x0583d718u, 0x3e48ebc2u, 0xff6d3165u, 0x57bac591u, 0x5c03cb23u, 0x35d23295u}}
, .sourceIx = ty_w64
, .targetIx = ty_w4
, .cost = 57 /* milli weight units */
}
,[RIGHTMOST_64_8] =
{ .tag = JET
, .jet = simplicity_rightmost_64_8
, .cmr = {{0x98cd95f9u, 0x5d46641bu, 0x049e77bfu, 0x90eea598u, 0xadf29ee5u, 0x00e65072u, 0x87548bb1u, 0xcdaf784du}}
, .sourceIx = ty_w64
, .targetIx = ty_w8
, .cost = 49 /* milli weight units */
}
,[RIGHTMOST_8_1] =
{ .tag = JET
, .jet = simplicity_rightmost_8_1
, .cmr = {{0x0876fcd4u, 0x698591f3u, 0x31910157u, 0x4ce153fcu, 0xdfe94f58u, 0x1aac5e75u, 0xf3cd7446u, 0xdf56f3c7u}}
, .sourceIx = ty_w8
, .targetIx = ty_b
, .cost = 65 /* milli weight units */
}
,[RIGHTMOST_8_2] =
{ .tag = JET
, .jet = simplicity_rightmost_8_2
, .cmr = {{0xb9f7b290u, 0xafe7f189u, 0xe32aebf2u, 0xcc4ddca9u, 0x6bb00764u, 0xc7be2887u, 0xdce054d0u, 0x9e38c353u}}
, .sourceIx = ty_w8
, .targetIx = ty_w2
, .cost = 63 /* milli weight units */
}
,[RIGHTMOST_8_4] =
{ .tag = JET
, .jet = simplicity_rightmost_8_4
, .cmr = {{0xf28e9af5u, 0xaf4c9ccau, 0x4b43cc6au, 0xdf9d9d8du, 0x169c87c5u, 0x559f9f3cu, 0xcac8f235u, 0x2b629f18u}}
, .sourceIx = ty_w8
, .targetIx = ty_w4
, .cost = 56 /* milli weight units */
}
,[SCALAR_ADD] =
{ .tag = JET
, .jet = simplicity_scalar_add
, .cmr = {{0x11ddbebau, 0xebf42180u, 0xa0b7eddfu, 0xfdc48ec7u, 0x511330fbu, 0x3315fa65u, 0xd58aff66u, 0xb9caf2d4u}}
, .sourceIx = ty_w512
, .targetIx = ty_w256
, .cost = 778 /* milli weight units */
}
,[SCALAR_INVERT] =
{ .tag = JET
, .jet = simplicity_scalar_invert
, .cmr = {{0xa6392725u, 0xbb2dadbbu, 0x1e76df2du, 0xec57df55u, 0xc3fcc577u, 0x3b62218au, 0xec55a75eu, 0x14f3d60du}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 3178 /* milli weight units */
}
,[SCALAR_IS_ZERO] =
{ .tag = JET
, .jet = simplicity_scalar_is_zero
, .cmr = {{0xf75eda06u, 0xce6af09fu, 0xae37db4eu, 0x6225e6a8u, 0xac86a236u, 0x37627d62u, 0x6409190fu, 0xf3b39d90u}}
, .sourceIx = ty_w256
, .targetIx = ty_b
, .cost = 271 /* milli weight units */
}
,[SCALAR_MULTIPLY] =
{ .tag = JET
, .jet = simplicity_scalar_multiply
, .cmr = {{0x4a61672au, 0xcec48877u, 0x56de1db6u, 0x0421a12bu, 0x901a858au, 0x6ee6352eu, 0x559d4ce5u, 0x973352beu}}
, .sourceIx = ty_w512
, .targetIx = ty_w256
, .cost = 793 /* milli weight units */
}
,[SCALAR_MULTIPLY_LAMBDA] =
{ .tag = JET
, .jet = simplicity_scalar_multiply_lambda
, .cmr = {{0x49ea9c3fu, 0xb1d8ff52u, 0xd2db0346u, 0x9fdfe850u, 0x503fddebu, 0x45e16d26u, 0xe8928addu, 0x25870e91u}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 567 /* milli weight units */
}
,[SCALAR_NEGATE] =
{ .tag = JET
, .jet = simplicity_scalar_negate
, .cmr = {{0x1dbf8b49u, 0x1ec66580u, 0x3f633330u, 0xd3ffb0e7u, 0x81e67c18u, 0x01ac9d49u, 0xbbf43589u, 0xabf782bfu}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 516 /* milli weight units */
}
,[SCALAR_NORMALIZE] =
{ .tag = JET
, .jet = simplicity_scalar_normalize
, .cmr = {{0x4633180eu, 0xa02c4df7u, 0x819d3d54u, 0xa401734fu, 0x965b31acu, 0xc784054eu, 0xbfb73168u, 0x16b029ecu}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 500 /* milli weight units */
}
,[SCALAR_SQUARE] =
{ .tag = JET
, .jet = simplicity_scalar_square
, .cmr = {{0x8a279e6fu, 0x613aa9e9u, 0x34f2f2a3u, 0x43c0d329u, 0x1c3670e2u, 0x97ddae20u, 0x529e8250u, 0x69efea0eu}}
, .sourceIx = ty_w256
, .targetIx = ty_w256
, .cost = 571 /* milli weight units */
}
,[SCALE] =
{ .tag = JET
, .jet = simplicity_scale
, .cmr = {{0x126e2212u, 0x5bac80b9u, 0x9b7b7343u, 0xb4e5e586u, 0x60821610u, 0x5d4de6f7u, 0x94add34eu, 0x23b195cau}}
, .sourceIx = ty_pw256pw512w256
, .targetIx = ty_pw512w256
, .cost = 73548 /* milli weight units */
}
,[SCRIPT_CMR] =
{ .tag = JET
, .jet = simplicity_bitcoin_script_cmr
, .cmr = {{0xa8a4a622u, 0x10b5e495u, 0x0e253424u, 0x7c7411d1u, 0xc8ff2286u, 0x5b5456bbu, 0xb21638e9u, 0x14f5e528u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 122 /* milli weight units */
}
,[SHA_256_BLOCK] =
{ .tag = JET
, .jet = simplicity_sha_256_block
, .cmr = {{0x4535f3e1u, 0xab9f1b75u, 0x7a069137u, 0xe1d5b1cau, 0xad8e31f7u, 0x8dc5fbd0u, 0x734649f9u, 0x40a7fc96u}}
, .sourceIx = ty_pw256w512
, .targetIx = ty_w256
, .cost = 765 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_1] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_1
, .cmr = {{0x9a4711b8u, 0xc5690e58u, 0x7e5f79e6u, 0x8d6eca04u, 0x7458aa63u, 0xb8bc9ee5u, 0x68086a4au, 0x1b56d834u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w8
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 664 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_128] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_128
, .cmr = {{0x1cb1db8au, 0x055b3197u, 0xacf0f08cu, 0xe9c635adu, 0xd695b60fu, 0x234b18e0u, 0xb323c937u, 0xb0385aeau}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w1Ki
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 1778 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_16] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_16
, .cmr = {{0xe0845475u, 0xebb90140u, 0xfa4e01afu, 0x8a943599u, 0x1ad87af9u, 0x8c08aeceu, 0x110e99cbu, 0xcecdee79u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w128
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 781 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_2] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_2
, .cmr = {{0x7d69138fu, 0x1c942beeu, 0x2fdf600cu, 0xe44b36ffu, 0x97839dc2u, 0xbbdafbd5u, 0xfab4dfbcu, 0x3c976f29u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w16
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 674 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_256] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_256
, .cmr = {{0x4f5c29d5u, 0x3686c060u, 0x62b38324u, 0xf8aff17eu, 0xc556a295u, 0xff098b10u, 0xe705dd22u, 0xe13bc3c9u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w2Ki
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 2894 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_32] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_32
, .cmr = {{0xd57b67b1u, 0x74e78e38u, 0xf9bca8e0u, 0x7add61c7u, 0x53e2c156u, 0xd8e9832au, 0xa6620455u, 0x00f51a80u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w256
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 928 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_4] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_4
, .cmr = {{0x95da3299u, 0x3f5c7d00u, 0x83064cdfu, 0xf1bec3b9u, 0x36c63833u, 0x7adec547u, 0x487af232u, 0xd69fdf65u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w32
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 656 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_512] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_512
, .cmr = {{0x4acb163au, 0xa48f09d5u, 0xf26d2b2au, 0xb188a6c6u, 0xb6c4aedfu, 0x23c91900u, 0x1c02ee15u, 0xb337a96eu}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w4Ki
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 5161 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_64] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_64
, .cmr = {{0x52e53ec5u, 0x770f9be4u, 0x069aeefcu, 0xb21322b1u, 0x3ab6e394u, 0x1fdc2c85u, 0xf4b41be6u, 0x7d38ea7eu}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w512
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 1220 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_8] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_8
, .cmr = {{0xc26b28afu, 0xe5e866d8u, 0x4616814du, 0x1a13fb86u, 0x30b9e84eu, 0x5d781556u, 0xc6d8236eu, 0xfb45dff9u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256w64
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 694 /* milli weight units */
}
,[SHA_256_CTX_8_ADD_BUFFER_511] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_add_buffer_511
, .cmr = {{0xad699046u, 0x48a8238du, 0x00d85163u, 0xfce81963u, 0xa0047ab5u, 0x82be97a4u, 0x14006559u, 0x79cfdd28u}}
, .sourceIx = ty_pppmw256pmw128pmw64pmw32pmw16mw8pw64w256pmw2Kipmw1Kipmw512pmw256pmw128pmw64pmw32pmw16mw8
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 5137 /* milli weight units */
}
,[SHA_256_CTX_8_FINALIZE] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_finalize
, .cmr = {{0x8e45bdc3u, 0x87d4edfau, 0x733525f3u, 0xab19e42bu, 0x58ecb1b5u, 0xf6dccf94u, 0xedbf5995u, 0x8ae3e116u}}
, .sourceIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .targetIx = ty_w256
, .cost = 833 /* milli weight units */
}
,[SHA_256_CTX_8_INIT] =
{ .tag = JET
, .jet = simplicity_sha_256_ctx_8_init
, .cmr = {{0x635f6405u, 0x848685c0u, 0x11febd41u, 0xfaac874bu, 0xbbf5b24du, 0x5fb12fedu, 0xbcb6cbffu, 0x95a0f366u}}
, .sourceIx = ty_u
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 123 /* milli weight units */
}
,[SHA_256_IV] =
{ .tag = JET
, .jet = simplicity_sha_256_iv
, .cmr = {{0x12e45937u, 0x51c9463bu, 0x562503c1u, 0x40d78b3bu, 0x757a1f4fu, 0x16321d28u, 0x62d32543u, 0x8538971bu}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 92 /* milli weight units */
}
,[SIG_ALL_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_sig_all_hash
, .cmr = {{0x0978b9e5u, 0x0b9e8e09u, 0x8b27f2b8u, 0xb59de54fu, 0x62ba7c13u, 0x33df3bedu, 0x221e2662u, 0x6805bc55u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 120 /* milli weight units */
}
,[SOME_1] =
{ .tag = JET
, .jet = simplicity_some_1
, .cmr = {{0x15ca4e4bu, 0x82c2f91bu, 0x9a792992u, 0xcdc1b292u, 0xab86a2d2u, 0x939c9a64u, 0xb50be60bu, 0xda6ab4cau}}
, .sourceIx = ty_b
, .targetIx = ty_b
, .cost = 60 /* milli weight units */
}
,[SOME_16] =
{ .tag = JET
, .jet = simplicity_some_16
, .cmr = {{0xa9dfbbeau, 0xb59df72au, 0x45fc3fc7u, 0xac581ec8u, 0xda713f2fu, 0x8103f787u, 0xaa1cee4eu, 0x0ba64866u}}
, .sourceIx = ty_w16
, .targetIx = ty_b
, .cost = 52 /* milli weight units */
}
,[SOME_32] =
{ .tag = JET
, .jet = simplicity_some_32
, .cmr = {{0x4633a397u, 0x742ef482u, 0xbe2fa3fbu, 0x6410ec79u, 0xc3738365u, 0x69fbbcb1u, 0xf948ec32u, 0x487378b7u}}
, .sourceIx = ty_w32
, .targetIx = ty_b
, .cost = 49 /* milli weight units */
}
,[SOME_64] =
{ .tag = JET
, .jet = simplicity_some_64
, .cmr = {{0x1dc245acu, 0x6f5b422bu, 0xd1886ef5u, 0x144c4dc7u, 0x2c967315u, 0x5966076cu, 0xd839681du, 0x9ec7f8f5u}}
, .sourceIx = ty_w64
, .targetIx = ty_b
, .cost = 62 /* milli weight units */
}
,[SOME_8] =
{ .tag = JET
, .jet = simplicity_some_8
, .cmr = {{0x33afb9c6u, 0x454e590eu, 0xc13ed75eu, 0x1b7d9c3au, 0x3de6752bu, 0xcc7c1d4cu, 0xb363fa51u, 0x828bcb74u}}
, .sourceIx = ty_w8
, .targetIx = ty_b
, .cost = 57 /* milli weight units */
}
,[SUBTRACT_16] =
{ .tag = JET
, .jet = simplicity_subtract_16
, .cmr = {{0x4e06ec31u, 0x376222e2u, 0x5e27d015u, 0x9dc1c071u, 0x4a44ca6au, 0xacf9505cu, 0xaad280e9u, 0x73fb5cabu}}
, .sourceIx = ty_w32
, .targetIx = ty_pbw16
, .cost = 93 /* milli weight units */
}
,[SUBTRACT_32] =
{ .tag = JET
, .jet = simplicity_subtract_32
, .cmr = {{0xb9c0f36eu, 0x7522a8d9u, 0x49050d51u, 0x6a05ce20u, 0x3a1f9a9eu, 0x372fd263u, 0xde38b0e9u, 0x03134198u}}
, .sourceIx = ty_w64
, .targetIx = ty_pbw32
, .cost = 87 /* milli weight units */
}
,[SUBTRACT_64] =
{ .tag = JET
, .jet = simplicity_subtract_64
, .cmr = {{0x1cdb5c74u, 0xadd102f5u, 0x0f938ed8u, 0x86f496e5u, 0xbab2755cu, 0x3c484e88u, 0x87903d2fu, 0x6a57f3aau}}
, .sourceIx = ty_w128
, .targetIx = ty_pbw64
, .cost = 125 /* milli weight units */
}
,[SUBTRACT_8] =
{ .tag = JET
, .jet = simplicity_subtract_8
, .cmr = {{0x4f2117a0u, 0xe81059ffu, 0x0cd64d84u, 0x886542e5u, 0x75ea8d6eu, 0xc03108fdu, 0x0b508b39u, 0x208cd0efu}}
, .sourceIx = ty_w16
, .targetIx = ty_pbw8
, .cost = 96 /* milli weight units */
}
,[SWU] =
{ .tag = JET
, .jet = simplicity_swu
, .cmr = {{0x00f51f4fu, 0x4bece790u, 0x03ecad48u, 0x1a125af7u, 0x176e4de9u, 0x8c339242u, 0x5cb91466u, 0x26c13b3bu}}
, .sourceIx = ty_w256
, .targetIx = ty_w512
, .cost = 32780 /* milli weight units */
}
,[TAP_ENV_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_tap_env_hash
, .cmr = {{0x19d9944cu, 0x4d457c70u, 0xbabc45ccu, 0xcbd573b3u, 0x9a51d0c9u, 0x9115b412u, 0x783b4900u, 0x82fd0e58u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 120 /* milli weight units */
}
,[TAPDATA_INIT] =
{ .tag = JET
, .jet = simplicity_tapdata_init
, .cmr = {{0xa4d022efu, 0x5cf467bcu, 0xa0325e46u, 0x3fcace7cu, 0xbdd64ff8u, 0xf71c5c7fu, 0x63e60784u, 0xaa0ac486u}}
, .sourceIx = ty_u
, .targetIx = ty_ppmw256pmw128pmw64pmw32pmw16mw8pw64w256
, .cost = 1233 /* milli weight units */
}
,[TAPLEAF_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_tapleaf_hash
, .cmr = {{0x0c0716feu, 0x5d978ea8u, 0xe0c75adcu, 0x8210d660u, 0x062e3da0u, 0x6f1a6661u, 0x317927d3u, 0xb84b5073u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 116 /* milli weight units */
}
,[TAPLEAF_VERSION] =
{ .tag = JET
, .jet = simplicity_bitcoin_tapleaf_version
, .cmr = {{0xe2ecb1cbu, 0x0ed4ed93u, 0x483545fdu, 0x8a62f8aau, 0x10175349u, 0xffcc5ad3u, 0xde7f3484u, 0xea1f103fu}}
, .sourceIx = ty_u
, .targetIx = ty_w8
, .cost = 66 /* milli weight units */
}
,[TAPPATH] =
{ .tag = JET
, .jet = simplicity_bitcoin_tappath
, .cmr = {{0x99e8211eu, 0x8c1be6d9u, 0xca98d3d4u, 0x3d914256u, 0x7e06a840u, 0x22393303u, 0xfab0b57du, 0x394074e8u}}
, .sourceIx = ty_w8
, .targetIx = ty_mw256
, .cost = 76 /* milli weight units */
}
,[TAPPATH_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_tappath_hash
, .cmr = {{0x0211546du, 0x0778e787u, 0x141ece65u, 0xdf6cd1dbu, 0x31388fc1u, 0x421968c8u, 0xcfd8d759u, 0x26db47b3u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 123 /* milli weight units */
}
,[TOTAL_INPUT_VALUE] =
{ .tag = JET
, .jet = simplicity_bitcoin_total_input_value
, .cmr = {{0x81287a15u, 0x89ddc217u, 0x9926b706u, 0x5e9b2677u, 0xb7fb099bu, 0x95f947a7u, 0xdd590cddu, 0x4ccf4a56u}}
, .sourceIx = ty_u
, .targetIx = ty_w64
, .cost = 69 /* milli weight units */
}
,[TOTAL_OUTPUT_VALUE] =
{ .tag = JET
, .jet = simplicity_bitcoin_total_output_value
, .cmr = {{0xba032f3eu, 0x62f8fcb0u, 0x4b0429a2u, 0x53b5ec57u, 0xe4c87ae2u, 0xe951e145u, 0xd7650e7fu, 0x0c63e555u}}
, .sourceIx = ty_u
, .targetIx = ty_w64
, .cost = 71 /* milli weight units */
}
,[TRANSACTION_ID] =
{ .tag = JET
, .jet = simplicity_bitcoin_transaction_id
, .cmr = {{0x5c49ea98u, 0x6b328be2u, 0xa4e0b315u, 0xb6b3fef2u, 0x3c1f6856u, 0xbbc3b056u, 0xc99cf59fu, 0xbd546e65u}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 122 /* milli weight units */
}
,[TX_HASH] =
{ .tag = JET
, .jet = simplicity_bitcoin_tx_hash
, .cmr = {{0x54e53c99u, 0x93abd55du, 0x1f8523d2u, 0xbb217b32u, 0xe6fe861fu, 0x84c986b7u, 0xee8bdc68u, 0x8106874au}}
, .sourceIx = ty_u
, .targetIx = ty_w256
, .cost = 119 /* milli weight units */
}
,[TX_IS_FINAL] =
{ .tag = JET
, .jet = simplicity_bitcoin_tx_is_final
, .cmr = {{0x7b0e4f4cu, 0xa8e5af61u, 0xa1d3454eu, 0x11ef9ab6u, 0x88706121u, 0x1c0090ebu, 0xa9553da2u, 0xe45d8473u}}
, .sourceIx = ty_u
, .targetIx = ty_b
, .cost = 62 /* milli weight units */
}
,[TX_LOCK_DISTANCE] =
{ .tag = JET
, .jet = simplicity_bitcoin_tx_lock_distance
, .cmr = {{0xb6fbaac2u, 0x10a306beu, 0x8b58d0d7u, 0xb1563f62u, 0x2336d2aeu, 0xb56c393du, 0x276445a9u, 0xa22cc4a7u}}
, .sourceIx = ty_u
, .targetIx = ty_w16
, .cost = 72 /* milli weight units */
}
,[TX_LOCK_DURATION] =
{ .tag = JET
, .jet = simplicity_bitcoin_tx_lock_duration
, .cmr = {{0x53572818u, 0xe7e5b98fu, 0x968c9da7u, 0xdf5090d9u, 0x826f9bcfu, 0x84b63639u, 0x5eea321bu, 0x6909ece9u}}
, .sourceIx = ty_u
, .targetIx = ty_w16
, .cost = 66 /* milli weight units */
}
,[TX_LOCK_HEIGHT] =
{ .tag = JET
, .jet = simplicity_bitcoin_tx_lock_height
, .cmr = {{0x449f61dfu, 0x1a7bad8du, 0x9e0a9667u, 0x14227e57u, 0x1007f93cu, 0x517b805du, 0x616510e8u, 0xff62172bu}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 72 /* milli weight units */
}
,[TX_LOCK_TIME] =
{ .tag = JET
, .jet = simplicity_bitcoin_tx_lock_time
, .cmr = {{0x31df363fu, 0x17b2cfc9u, 0x7a1f9372u, 0xc14a3258u, 0x64d7cb13u, 0xaa8d5215u, 0xfb253d33u, 0x10917762u}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 72 /* milli weight units */
}
,[VERIFY] =
{ .tag = JET
, .jet = simplicity_verify
, .cmr = {{0xcdca2a05u, 0xe52cefa5u, 0x9dc7a5b0u, 0xdae22098u, 0xfb896e39u, 0x13bfdd44u, 0x6b594e1fu, 0x9250783eu}}
, .sourceIx = ty_b
, .targetIx = ty_u
, .cost = 44 /* milli weight units */
}
,[VERSION] =
{ .tag = JET
, .jet = simplicity_bitcoin_version
, .cmr = {{0x83735864u, 0x00b6790bu, 0x46ab0410u, 0x523cf01eu, 0xb74d10fau, 0xf48a3accu, 0x86c4c51du, 0x06a52c49u}}
, .sourceIx = ty_u
, .targetIx = ty_w32
, .cost = 78 /* milli weight units */
}
,[XOR_1] =
{ .tag = JET
, .jet = simplicity_xor_1
, .cmr = {{0x8c4e4e6eu, 0xbf4630b2u, 0x9b5a57eau, 0x79f0c9afu, 0x6bff54c4u, 0xd2d769bfu, 0x51594774u, 0xa52b99c9u}}
, .sourceIx = ty_w2
, .targetIx = ty_b
, .cost = 60 /* milli weight units */
}
,[XOR_16] =
{ .tag = JET
, .jet = simplicity_xor_16
, .cmr = {{0xd9f0af3fu, 0xe3fd247cu, 0x1df34a25u, 0x2713b2e9u, 0x33a945a5u, 0x6719487fu, 0x8ed7f563u, 0xea861ab5u}}
, .sourceIx = ty_w32
, .targetIx = ty_w16
, .cost = 73 /* milli weight units */
}
,[XOR_32] =
{ .tag = JET
, .jet = simplicity_xor_32
, .cmr = {{0xd5ae2712u, 0xedeaf676u, 0x520fa3bau, 0x0f40bf4au, 0x1657437eu, 0xffbd9986u, 0xd06ae81bu, 0x29a4f98cu}}
, .sourceIx = ty_w64
, .targetIx = ty_w32
, .cost = 77 /* milli weight units */
}
,[XOR_64] =
{ .tag = JET
, .jet = simplicity_xor_64
, .cmr = {{0xc4df1ccfu, 0x333edebdu, 0xd40dea9au, 0x0e6cbb83u, 0x0631e83au, 0x94bb779fu, 0xe6007bc6u, 0xcb53a544u}}
, .sourceIx = ty_w128
, .targetIx = ty_w64
, .cost = 68 /* milli weight units */
}
,[XOR_8] =
{ .tag = JET
, .jet = simplicity_xor_8
, .cmr = {{0x4ab14a81u, 0x4a39528au, 0x80fdb430u, 0x589ba450u, 0x104b9c72u, 0x09aa2fe2u, 0x85cd60c0u, 0x9043114au}}
, .sourceIx = ty_w16
, .targetIx = ty_w8
, .cost = 80 /* milli weight units */
}
,[XOR_XOR_1] =
{ .tag = JET
, .jet = simplicity_xor_xor_1
, .cmr = {{0x18b9446au, 0x4166a3feu, 0xe2bcb254u, 0x5bb90118u, 0xdcf0e8f8u, 0x86a1076du, 0x4c386006u, 0x0cde1a51u}}
, .sourceIx = ty_pbw2
, .targetIx = ty_b
, .cost = 50 /* milli weight units */
}
,[XOR_XOR_16] =
{ .tag = JET
, .jet = simplicity_xor_xor_16
, .cmr = {{0x946cde87u, 0x2e30e650u, 0x9daff405u, 0xf0e0fefeu, 0x275547b4u, 0x0eb20384u, 0xafe9a863u, 0x60fc80efu}}
, .sourceIx = ty_pw16w32
, .targetIx = ty_w16
, .cost = 82 /* milli weight units */
}
,[XOR_XOR_32] =
{ .tag = JET
, .jet = simplicity_xor_xor_32
, .cmr = {{0x6527df67u, 0xa50d148du, 0xb4fc8feeu, 0xc7845564u, 0x99a8c7f0u, 0xfa7d28e6u, 0x278e997fu, 0x4959be39u}}
, .sourceIx = ty_pw32w64
, .targetIx = ty_w32
, .cost = 82 /* milli weight units */
}
,[XOR_XOR_64] =
{ .tag = JET
, .jet = simplicity_xor_xor_64
, .cmr = {{0xf162f9e6u, 0x5663a69au, 0xc5f92a5eu, 0xb52c0332u, 0x392edd1eu, 0xd1ba355eu, 0x6f19406eu, 0xabe3f6edu}}
, .sourceIx = ty_pw64w128
, .targetIx = ty_w64
, .cost = 80 /* milli weight units */
}
,[XOR_XOR_8] =
{ .tag = JET
, .jet = simplicity_xor_xor_8
, .cmr = {{0xe06d694cu, 0x5b407ddau, 0xd7aa1f88u, 0x0716bcb7u, 0x0acdba75u, 0x85ca4009u, 0x9a0a0a61u, 0xf3ad2db5u}}
, .sourceIx = ty_pw8w16
, .targetIx = ty_w8
, .cost = 86 /* milli weight units */
}
================================================
FILE: C/bitcoin/txEnv.c
================================================
#include "txEnv.h"
/* Construct a txEnv structure from its components.
* This fu
gitextract__1j3kvgc/ ├── .github/ │ └── workflows/ │ └── ci.yml ├── .gitignore ├── C/ │ ├── Makefile │ ├── bitcoin/ │ │ ├── bitcoinJets.c │ │ ├── bitcoinJets.h │ │ ├── decodeBitcoinJets.inc │ │ ├── env.c │ │ ├── ops.c │ │ ├── ops.h │ │ ├── primitive.c │ │ ├── primitive.h │ │ ├── primitiveEnumJet.inc │ │ ├── primitiveEnumTy.inc │ │ ├── primitiveInitTy.inc │ │ ├── primitiveJetNode.inc │ │ ├── txEnv.c │ │ └── txEnv.h │ ├── bitstream.c │ ├── bitstream.h │ ├── bitstring.h │ ├── bounded.h │ ├── ctx8Pruned.c │ ├── ctx8Pruned.h │ ├── ctx8Unpruned.c │ ├── ctx8Unpruned.h │ ├── dag.c │ ├── dag.h │ ├── decodeCoreJets.inc │ ├── deserialize.c │ ├── deserialize.h │ ├── elements/ │ │ ├── checkSigHashAllTx1.c │ │ ├── checkSigHashAllTx1.h │ │ ├── cmr.c │ │ ├── decodeElementsJets.inc │ │ ├── elementsJets.c │ │ ├── elementsJets.h │ │ ├── env.c │ │ ├── exec.c │ │ ├── ops.c │ │ ├── ops.h │ │ ├── primitive.c │ │ ├── primitive.h │ │ ├── primitiveEnumJet.inc │ │ ├── primitiveEnumTy.inc │ │ ├── primitiveInitTy.inc │ │ ├── primitiveJetNode.inc │ │ ├── txEnv.c │ │ └── txEnv.h │ ├── elements-sources.mk │ ├── eval.c │ ├── eval.h │ ├── frame.c │ ├── frame.h │ ├── hashBlock.c │ ├── hashBlock.h │ ├── include/ │ │ └── simplicity/ │ │ ├── bitcoin/ │ │ │ └── env.h │ │ ├── elements/ │ │ │ ├── cmr.h │ │ │ ├── env.h │ │ │ └── exec.h │ │ └── errorCodes.h │ ├── jets-secp256k1.c │ ├── jets.c │ ├── jets.h │ ├── limitations.h │ ├── precomputed.h │ ├── regression4.c │ ├── regression4.h │ ├── rsort.c │ ├── rsort.h │ ├── schnorr0.c │ ├── schnorr0.h │ ├── schnorr6.c │ ├── schnorr6.h │ ├── secp256k1/ │ │ ├── README.md │ │ ├── assumptions.h │ │ ├── eckey.h │ │ ├── eckey_impl.h │ │ ├── ecmult.h │ │ ├── ecmult_impl.h │ │ ├── extrakeys.h │ │ ├── extrakeys_impl.h │ │ ├── field.h │ │ ├── field_5x52.h │ │ ├── field_5x52_asm_impl.h │ │ ├── field_5x52_impl.h │ │ ├── field_5x52_int128_impl.h │ │ ├── field_impl.h │ │ ├── generator.h │ │ ├── generator_impl.h │ │ ├── group.h │ │ ├── group_impl.h │ │ ├── int128.h │ │ ├── int128_impl.h │ │ ├── int128_native.h │ │ ├── int128_native_impl.h │ │ ├── int128_struct.h │ │ ├── int128_struct_impl.h │ │ ├── modinv64.h │ │ ├── modinv64_impl.h │ │ ├── precomputed_ecmult.h │ │ ├── scalar.h │ │ ├── scalar_4x64.h │ │ ├── scalar_4x64_impl.h │ │ ├── scalar_impl.h │ │ ├── schnorrsig.h │ │ ├── schnorrsig_impl.h │ │ ├── secp256k1.h │ │ ├── secp256k1_impl.h │ │ └── util.h │ ├── sha256.c │ ├── sha256.h │ ├── sha256_x86.inc │ ├── simplicity_alloc.h │ ├── simplicity_assert.h │ ├── taptweak.h │ ├── test.c │ ├── type.c │ ├── type.h │ ├── typeInference.c │ ├── typeInference.h │ ├── typeSkipTest.c │ ├── typeSkipTest.h │ └── uword.h ├── Coq/ │ ├── C/ │ │ ├── divstep.v │ │ ├── extraMath.v │ │ ├── jets_secp256k1.v │ │ ├── modinv.v │ │ ├── progressC.v │ │ └── secp256k1/ │ │ ├── spec_int128.v │ │ ├── spec_modinv64.v │ │ ├── verif_int128_impl.v │ │ └── verif_modinv64_impl.v │ ├── Simplicity/ │ │ ├── Alg.v │ │ ├── Bit.v │ │ ├── BitMachine.v │ │ ├── Core.v │ │ ├── Delegation.v │ │ ├── Digest.v │ │ ├── MerkleRoot.v │ │ ├── Primitive/ │ │ │ └── Bitcoin.v │ │ ├── Primitive.v │ │ ├── SHA256.v │ │ ├── StaticAnalysis.v │ │ ├── Translate.v │ │ ├── Ty.v │ │ ├── Util/ │ │ │ ├── Arith.v │ │ │ ├── List.v │ │ │ ├── Monad/ │ │ │ │ └── Reader.v │ │ │ ├── Monad.v │ │ │ ├── Option.v │ │ │ ├── PackedClass.v │ │ │ └── Thrist.v │ │ └── Word.v │ └── _CoqProject ├── Haskell/ │ ├── Bitcoin/ │ │ └── Simplicity/ │ │ └── Bitcoin/ │ │ ├── DataTypes.hs │ │ └── Primitive.hs │ ├── Core/ │ │ └── Simplicity/ │ │ ├── BitMachine/ │ │ │ ├── Authentic.hs │ │ │ ├── StaticAnalysis/ │ │ │ │ ├── Cost.hs │ │ │ │ └── TCO.hs │ │ │ ├── StaticAnalysis.hs │ │ │ ├── Translate/ │ │ │ │ └── TCO.hs │ │ │ ├── Translate.hs │ │ │ └── Ty.hs │ │ ├── BitMachine.hs │ │ ├── Bitcoin.hs │ │ ├── CoreJets.hs │ │ ├── Delegator/ │ │ │ └── Impl.hs │ │ ├── Delegator.hs │ │ ├── Digest/ │ │ │ └── Pure/ │ │ │ └── SHA.hs │ │ ├── Digest.hs │ │ ├── FFI/ │ │ │ ├── Frame.hs │ │ │ └── Jets.hs │ │ ├── Functor.hs │ │ ├── LibSecp256k1/ │ │ │ ├── Schnorr.hs │ │ │ └── Spec.hs │ │ ├── MerkleRoot/ │ │ │ └── Impl.hs │ │ ├── MerkleRoot.hs │ │ ├── Programs/ │ │ │ ├── Arith.hs │ │ │ ├── Bit.hs │ │ │ ├── Bitcoin/ │ │ │ │ └── Lib.hs │ │ │ ├── Bitcoin.hs │ │ │ ├── CheckSig/ │ │ │ │ └── Lib.hs │ │ │ ├── CheckSig.hs │ │ │ ├── Elements/ │ │ │ │ └── Lib.hs │ │ │ ├── Elements.hs │ │ │ ├── Generic.hs │ │ │ ├── LibSecp256k1/ │ │ │ │ └── Lib.hs │ │ │ ├── LibSecp256k1.hs │ │ │ ├── Loop.hs │ │ │ ├── Sha256/ │ │ │ │ └── Lib.hs │ │ │ ├── Sha256.hs │ │ │ ├── TimeLock.hs │ │ │ └── Word.hs │ │ ├── Serialization.hs │ │ ├── Tags.hs │ │ ├── Tensor.hs │ │ ├── Term/ │ │ │ └── Core.hs │ │ ├── Tree.hs │ │ ├── Ty/ │ │ │ ├── Bit.hs │ │ │ ├── LibSecp256k1.hs │ │ │ ├── Sha256.hs │ │ │ └── Word.hs │ │ ├── Ty.hs │ │ ├── Weight.hs │ │ └── Word.hs │ ├── Elements/ │ │ └── Simplicity/ │ │ └── Elements/ │ │ ├── DataTypes.hs │ │ └── Primitive.hs │ ├── Indef/ │ │ └── Simplicity/ │ │ ├── Dag.hs │ │ ├── Inference.hs │ │ ├── JetType.hs │ │ ├── Primitive.hsig │ │ ├── Semantics.hs │ │ ├── Serialization/ │ │ │ ├── BitString.hs │ │ │ └── ByteString.hs │ │ ├── StaticAnalysis/ │ │ │ └── Cost.hs │ │ └── Term.hs │ ├── Simplicity/ │ │ ├── Bitcoin/ │ │ │ ├── Benchmarks.hs │ │ │ ├── FFI/ │ │ │ │ ├── Env.hs │ │ │ │ └── Jets.hs │ │ │ ├── Jets.hs │ │ │ └── Programs/ │ │ │ ├── SigHash/ │ │ │ │ └── Lib.hs │ │ │ ├── SigHash.hs │ │ │ ├── TimeLock.hs │ │ │ ├── Transaction/ │ │ │ │ └── Lib.hs │ │ │ └── Transaction.hs │ │ └── Elements/ │ │ ├── Benchmarks.hs │ │ ├── FFI/ │ │ │ ├── Env.hs │ │ │ └── Jets.hs │ │ ├── Jets.hs │ │ └── Programs/ │ │ ├── Issuance/ │ │ │ └── Lib.hs │ │ ├── Issuance.hs │ │ ├── SigHash/ │ │ │ └── Lib.hs │ │ ├── SigHash.hs │ │ ├── TimeLock.hs │ │ ├── Transaction/ │ │ │ └── Lib.hs │ │ └── Transaction.hs │ ├── Tests/ │ │ ├── Simplicity/ │ │ │ ├── Arbitrary.hs │ │ │ ├── Bip0340.hs │ │ │ ├── BitMachine/ │ │ │ │ ├── StaticAnalysis/ │ │ │ │ │ └── Tests.hs │ │ │ │ └── Tests.hs │ │ │ ├── Bitcoin/ │ │ │ │ ├── Arbitrary.hs │ │ │ │ ├── FFI/ │ │ │ │ │ ├── Primitive.hs │ │ │ │ │ └── Tests.hs │ │ │ │ ├── Serialization/ │ │ │ │ │ └── Tests.hs │ │ │ │ ├── TestEval.hs │ │ │ │ └── Tests.hs │ │ │ ├── Elements/ │ │ │ │ ├── Arbitrary.hs │ │ │ │ ├── FFI/ │ │ │ │ │ ├── Primitive.hs │ │ │ │ │ └── Tests.hs │ │ │ │ ├── Regression.hs │ │ │ │ ├── Serialization/ │ │ │ │ │ └── Tests.hs │ │ │ │ ├── TestEval.hs │ │ │ │ └── Tests.hs │ │ │ ├── FFI/ │ │ │ │ ├── Bitstream.hs │ │ │ │ ├── Dag.hs │ │ │ │ └── Tests.hs │ │ │ ├── Programs/ │ │ │ │ ├── Example.hs │ │ │ │ └── Tests.hs │ │ │ ├── Serialization/ │ │ │ │ └── Tests.hs │ │ │ ├── TestCoreEval.hs │ │ │ └── Ty/ │ │ │ ├── Arbitrary.hs │ │ │ └── Tests.hs │ │ └── Tests.hs │ └── cbits/ │ ├── bitcoin/ │ │ ├── env.c │ │ └── jets.c │ ├── bitstream.c │ ├── coreJets.c │ ├── dag.c │ ├── elements/ │ │ ├── env.c │ │ └── jets.c │ ├── frame.c │ └── wrappers.h ├── Haskell-Examples/ │ └── TestnetTransaction.hs ├── Haskell-Generate/ │ ├── GenDecodeJet.hs │ ├── GenPrecomputed.hs │ ├── GenPrimitive.hs │ ├── GenRustJets.hs │ ├── GenTests.hs │ └── NameWrangler.hs ├── LICENSE ├── README.md ├── Setup.hs ├── Simplicity-Primitive.html ├── Simplicity-TR.tm ├── Simplicity.C.nix ├── Simplicity.Coq.nix ├── Simplicity.Haskell.nix ├── Simplicity.bib ├── Simplicity.cabal ├── alectryon/ │ ├── alectryon.css │ ├── alectryon.js │ ├── divstep.v.html │ ├── pygments.css │ ├── spec_int128.v.html │ ├── spec_modinv64.v.html │ ├── verif_int128_impl.v.html │ └── verif_modinv64_impl.v.html ├── compcert-opensource.nix ├── compcert-opensource.patch ├── default.nix ├── inheritance.Coq.dot ├── manual-index.html ├── safegcd-bounds.nix ├── shell.nix ├── spelling.ignore.txt ├── unification.patch └── vst.nix
SYMBOL INDEX (836 symbols across 74 files)
FILE: C/bitcoin/bitcoinJets.c
function readHash (line 13) | static void readHash(sha256_midstate* h, frameItem *src) {
function writeHash (line 22) | static void writeHash(frameItem* dst, const sha256_midstate* h) {
function prevOutpoint (line 31) | static void prevOutpoint(frameItem* dst, const outpoint* op) {
function uint_fast32_t (line 36) | static uint_fast32_t lockHeight(const bitcoinTransaction* tx) {
function uint_fast32_t (line 40) | static uint_fast32_t lockTime(const bitcoinTransaction* tx) {
function uint_fast16_t (line 44) | static uint_fast16_t lockDistance(const bitcoinTransaction* tx, uint_fas...
function uint_fast16_t (line 55) | static uint_fast16_t lockDuration(const bitcoinTransaction* tx, uint_fas...
function simplicity_bitcoin_version (line 67) | bool simplicity_bitcoin_version(frameItem* dst, frameItem src, const txE...
function simplicity_bitcoin_lock_time (line 74) | bool simplicity_bitcoin_lock_time(frameItem* dst, frameItem src, const t...
function simplicity_bitcoin_input_prev_outpoint (line 81) | bool simplicity_bitcoin_input_prev_outpoint(frameItem* dst, frameItem sr...
function simplicity_bitcoin_input_value (line 92) | bool simplicity_bitcoin_input_value(frameItem* dst, frameItem src, const...
function simplicity_bitcoin_input_script_hash (line 103) | bool simplicity_bitcoin_input_script_hash(frameItem* dst, frameItem src,...
function simplicity_bitcoin_input_sequence (line 114) | bool simplicity_bitcoin_input_sequence(frameItem* dst, frameItem src, co...
function simplicity_bitcoin_input_annex_hash (line 125) | bool simplicity_bitcoin_input_annex_hash(frameItem* dst, frameItem src, ...
function simplicity_bitcoin_input_script_sig_hash (line 140) | bool simplicity_bitcoin_input_script_sig_hash(frameItem* dst, frameItem ...
function simplicity_bitcoin_output_value (line 151) | bool simplicity_bitcoin_output_value(frameItem* dst, frameItem src, cons...
function simplicity_bitcoin_output_script_hash (line 162) | bool simplicity_bitcoin_output_script_hash(frameItem* dst, frameItem src...
function simplicity_bitcoin_fee (line 173) | bool simplicity_bitcoin_fee(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_bitcoin_total_input_value (line 180) | bool simplicity_bitcoin_total_input_value(frameItem* dst, frameItem src,...
function simplicity_bitcoin_total_output_value (line 187) | bool simplicity_bitcoin_total_output_value(frameItem* dst, frameItem src...
function simplicity_bitcoin_script_cmr (line 194) | bool simplicity_bitcoin_script_cmr(frameItem* dst, frameItem src, const ...
function simplicity_bitcoin_transaction_id (line 201) | bool simplicity_bitcoin_transaction_id(frameItem* dst, frameItem src, co...
function simplicity_bitcoin_current_index (line 208) | bool simplicity_bitcoin_current_index(frameItem* dst, frameItem src, con...
function simplicity_bitcoin_current_prev_outpoint (line 215) | bool simplicity_bitcoin_current_prev_outpoint(frameItem* dst, frameItem ...
function simplicity_bitcoin_current_value (line 223) | bool simplicity_bitcoin_current_value(frameItem* dst, frameItem src, con...
function simplicity_bitcoin_current_script_hash (line 231) | bool simplicity_bitcoin_current_script_hash(frameItem* dst, frameItem sr...
function simplicity_bitcoin_current_sequence (line 239) | bool simplicity_bitcoin_current_sequence(frameItem* dst, frameItem src, ...
function simplicity_bitcoin_current_script_sig_hash (line 247) | bool simplicity_bitcoin_current_script_sig_hash(frameItem* dst, frameIte...
function simplicity_bitcoin_current_annex_hash (line 255) | bool simplicity_bitcoin_current_annex_hash(frameItem* dst, frameItem src...
function simplicity_bitcoin_tapleaf_version (line 267) | bool simplicity_bitcoin_tapleaf_version(frameItem* dst, frameItem src, c...
function simplicity_bitcoin_tappath (line 274) | bool simplicity_bitcoin_tappath(frameItem* dst, frameItem src, const txE...
function simplicity_bitcoin_internal_key (line 285) | bool simplicity_bitcoin_internal_key(frameItem* dst, frameItem src, cons...
function simplicity_bitcoin_num_inputs (line 292) | bool simplicity_bitcoin_num_inputs(frameItem* dst, frameItem src, const ...
function simplicity_bitcoin_num_outputs (line 299) | bool simplicity_bitcoin_num_outputs(frameItem* dst, frameItem src, const...
function simplicity_bitcoin_tx_is_final (line 306) | bool simplicity_bitcoin_tx_is_final(frameItem* dst, frameItem src, const...
function simplicity_bitcoin_tx_lock_height (line 313) | bool simplicity_bitcoin_tx_lock_height(frameItem* dst, frameItem src, co...
function simplicity_bitcoin_tx_lock_time (line 320) | bool simplicity_bitcoin_tx_lock_time(frameItem* dst, frameItem src, cons...
function simplicity_bitcoin_tx_lock_distance (line 327) | bool simplicity_bitcoin_tx_lock_distance(frameItem* dst, frameItem src, ...
function simplicity_bitcoin_tx_lock_duration (line 335) | bool simplicity_bitcoin_tx_lock_duration(frameItem* dst, frameItem src, ...
function simplicity_bitcoin_check_lock_height (line 343) | bool simplicity_bitcoin_check_lock_height(frameItem* dst, frameItem src,...
function simplicity_bitcoin_check_lock_time (line 350) | bool simplicity_bitcoin_check_lock_time(frameItem* dst, frameItem src, c...
function simplicity_bitcoin_check_lock_distance (line 357) | bool simplicity_bitcoin_check_lock_distance(frameItem* dst, frameItem sr...
function simplicity_bitcoin_check_lock_duration (line 365) | bool simplicity_bitcoin_check_lock_duration(frameItem* dst, frameItem sr...
function simplicity_bitcoin_build_tapleaf_simplicity (line 373) | bool simplicity_bitcoin_build_tapleaf_simplicity(frameItem* dst, frameIt...
function simplicity_bitcoin_build_tapbranch (line 383) | bool simplicity_bitcoin_build_tapbranch(frameItem* dst, frameItem src, c...
function simplicity_bitcoin_build_taptweak (line 395) | bool simplicity_bitcoin_build_taptweak(frameItem* dst, frameItem src, co...
function simplicity_bitcoin_outpoint_hash (line 402) | bool simplicity_bitcoin_outpoint_hash(frameItem* dst, frameItem src, con...
function simplicity_bitcoin_annex_hash (line 419) | bool simplicity_bitcoin_annex_hash(frameItem* dst, frameItem src, const ...
function simplicity_bitcoin_output_values_hash (line 443) | bool simplicity_bitcoin_output_values_hash(frameItem* dst, frameItem src...
function simplicity_bitcoin_output_scripts_hash (line 450) | bool simplicity_bitcoin_output_scripts_hash(frameItem* dst, frameItem sr...
function simplicity_bitcoin_outputs_hash (line 457) | bool simplicity_bitcoin_outputs_hash(frameItem* dst, frameItem src, cons...
function simplicity_bitcoin_output_hash (line 464) | bool simplicity_bitcoin_output_hash(frameItem* dst, frameItem src, const...
function simplicity_bitcoin_input_outpoints_hash (line 481) | bool simplicity_bitcoin_input_outpoints_hash(frameItem* dst, frameItem s...
function simplicity_bitcoin_input_values_hash (line 488) | bool simplicity_bitcoin_input_values_hash(frameItem* dst, frameItem src,...
function simplicity_bitcoin_input_scripts_hash (line 495) | bool simplicity_bitcoin_input_scripts_hash(frameItem* dst, frameItem src...
function simplicity_bitcoin_input_utxos_hash (line 502) | bool simplicity_bitcoin_input_utxos_hash(frameItem* dst, frameItem src, ...
function simplicity_bitcoin_input_utxo_hash (line 509) | bool simplicity_bitcoin_input_utxo_hash(frameItem* dst, frameItem src, c...
function simplicity_bitcoin_input_sequences_hash (line 526) | bool simplicity_bitcoin_input_sequences_hash(frameItem* dst, frameItem s...
function simplicity_bitcoin_input_annexes_hash (line 533) | bool simplicity_bitcoin_input_annexes_hash(frameItem* dst, frameItem src...
function simplicity_bitcoin_input_script_sigs_hash (line 540) | bool simplicity_bitcoin_input_script_sigs_hash(frameItem* dst, frameItem...
function simplicity_bitcoin_inputs_hash (line 547) | bool simplicity_bitcoin_inputs_hash(frameItem* dst, frameItem src, const...
function simplicity_bitcoin_input_hash (line 554) | bool simplicity_bitcoin_input_hash(frameItem* dst, frameItem src, const ...
function simplicity_bitcoin_tx_hash (line 578) | bool simplicity_bitcoin_tx_hash(frameItem* dst, frameItem src, const txE...
function simplicity_bitcoin_tapleaf_hash (line 585) | bool simplicity_bitcoin_tapleaf_hash(frameItem* dst, frameItem src, cons...
function simplicity_bitcoin_tappath_hash (line 592) | bool simplicity_bitcoin_tappath_hash(frameItem* dst, frameItem src, cons...
function simplicity_bitcoin_tap_env_hash (line 599) | bool simplicity_bitcoin_tap_env_hash(frameItem* dst, frameItem src, cons...
function simplicity_bitcoin_sig_all_hash (line 606) | bool simplicity_bitcoin_sig_all_hash(frameItem* dst, frameItem src, cons...
FILE: C/bitcoin/env.c
function hashBuffer (line 19) | static void hashBuffer(sha256_midstate* result, const rawBitcoinBuffer* ...
function copyOutput (line 30) | static void copyOutput(sigOutput* result, const rawBitcoinOutput* output) {
function copyInput (line 40) | static void copyInput(sigInput* result, const rawBitcoinInput* input) {
function bitcoinTransaction (line 57) | extern bitcoinTransaction* simplicity_bitcoin_mallocTransaction(const ra...
function simplicity_bitcoin_freeTransaction (line 181) | extern void simplicity_bitcoin_freeTransaction(bitcoinTransaction* tx) {
function bitcoinTapEnv (line 190) | extern bitcoinTapEnv* simplicity_bitcoin_mallocTapEnv(const rawBitcoinTa...
function simplicity_bitcoin_freeTapEnv (line 258) | extern void simplicity_bitcoin_freeTapEnv(bitcoinTapEnv* env) {
FILE: C/bitcoin/ops.c
function sha256_midstate (line 9) | sha256_midstate simplicity_bitcoin_make_tapleaf(unsigned char version, c...
function sha256_midstate (line 34) | sha256_midstate simplicity_bitcoin_make_tapbranch(const sha256_midstate*...
FILE: C/bitcoin/primitive.c
type TypeNamesForJets (line 11) | enum TypeNamesForJets {
function simplicity_bitcoin_mallocBoundVars (line 34) | size_t simplicity_bitcoin_mallocBoundVars(unification_var** bound_var, s...
type jetName (line 52) | typedef enum jetName
function simplicity_err (line 68) | static simplicity_err decodePrimitive(jetName* result, bitstream* stream) {
function dag_node (line 83) | static dag_node jetNode(jetName name) {
function simplicity_err (line 101) | simplicity_err simplicity_bitcoin_decodeJet(dag_node* node, bitstream* s...
FILE: C/bitcoin/txEnv.c
function txEnv (line 10) | txEnv simplicity_bitcoin_build_txEnv(const bitcoinTransaction* tx, const...
FILE: C/bitcoin/txEnv.h
type outpoint (line 13) | typedef struct outpoint {
type sigOutput (line 21) | typedef struct sigOutput {
type sigInput (line 29) | typedef struct sigInput {
type bitcoinTransaction (line 41) | typedef struct bitcoinTransaction {
type bitcoinTapEnv (line 71) | typedef struct bitcoinTapEnv {
type txEnv (line 88) | typedef struct txEnv {
FILE: C/bitstream.c
function simplicity_err (line 13) | simplicity_err simplicity_closeBitstream(bitstream* stream) {
function simplicity_readNBits (line 33) | int32_t simplicity_readNBits(int n, bitstream* stream) {
function decodeUpto1Bit (line 62) | static int32_t decodeUpto1Bit(int32_t* result, bitstream* stream) {
function decodeUpto3 (line 83) | static int32_t decodeUpto3(bitstream* stream) {
function decodeUpto3Bits (line 102) | static int32_t decodeUpto3Bits(int32_t* result, bitstream* stream) {
function decodeUpto15 (line 127) | static int32_t decodeUpto15(bitstream* stream) {
function decodeUpto15Bits (line 146) | static int32_t decodeUpto15Bits(int32_t* result, bitstream* stream) {
function decodeUpto65535 (line 171) | static int32_t decodeUpto65535(bitstream* stream) {
function simplicity_decodeUptoMaxInt (line 187) | int32_t simplicity_decodeUptoMaxInt(bitstream* stream) {
function simplicity_err (line 214) | simplicity_err simplicity_readBitstring(bitstring* result, size_t n, bit...
FILE: C/bitstream.h
type bitstream (line 19) | typedef struct bitstream {
function bitstream (line 28) | static inline bitstream initializeBitstream(const unsigned char* arr, si...
function read1Bit (line 55) | static inline int32_t read1Bit(bitstream* stream) {
FILE: C/bitstring.h
type bitstring (line 20) | typedef struct bitstring {
function getBit (line 31) | static inline bool getBit(const bitstring *s, size_t n) {
function uint_fast8_t (line 42) | static inline uint_fast8_t getByte(const bitstring *s, size_t n) {
FILE: C/bounded.h
type uint_least32_t (line 7) | typedef uint_least32_t ubounded;
function ubounded (line 10) | static inline ubounded bounded_max(ubounded x, ubounded y) {
function ubounded (line 15) | static inline ubounded bounded_add(ubounded x, ubounded y) {
function bounded_inc (line 22) | static inline void bounded_inc(ubounded* x) {
function ubounded (line 29) | static inline ubounded pad(bool right, ubounded a, ubounded b) {
FILE: C/dag.c
function sha256_midstate (line 16) | static sha256_midstate cmrIV(tag_t tag) {
function sha256_midstate (line 45) | static sha256_midstate imrIV(tag_t tag) {
function sha256_midstate (line 56) | static sha256_midstate amrIV(tag_t tag) {
function sha256_midstate (line 84) | static sha256_midstate mkJetCMR(uint32_t *ih, uint_fast64_t weight) {
function sha256_midstate (line 99) | sha256_midstate simplicity_computeWordCMR(const bitstring* value, size_t...
function simplicity_computeCommitmentMerkleRoot (line 158) | void simplicity_computeCommitmentMerkleRoot(dag_node* dag, const uint_fa...
function computeIdentityHashRoots (line 202) | static void computeIdentityHashRoots(sha256_midstate* ihr, const dag_nod...
function simplicity_computeAnnotatedMerkleRoot (line 273) | void simplicity_computeAnnotatedMerkleRoot(analyses* analysis, const dag...
function simplicity_err (line 380) | simplicity_err simplicity_verifyCanonicalOrder(dag_node* dag, const uint...
function simplicity_err (line 484) | simplicity_err simplicity_fillWitnessData(dag_node* dag, type* type_dag,...
function simplicity_err (line 573) | simplicity_err simplicity_verifyNoDuplicateIdentityHashes(sha256_midstat...
FILE: C/dag.h
type tag_t (line 18) | typedef enum tag_t
type combinator_counters (line 38) | typedef struct combinator_counters {
function enumerator (line 45) | static inline void enumerator(combinator_counters* census, tag_t tag) {
function numChildren (line 72) | static inline size_t numChildren(tag_t tag) {
type dag_node (line 114) | typedef struct dag_node {
function IDEN_A (line 139) | static inline size_t IDEN_A(const dag_node* dag, const type* type_dag, s...
function UNIT_A (line 145) | static inline size_t UNIT_A(const dag_node* dag, const type* type_dag, s...
function COMP_A (line 151) | static inline size_t COMP_A(const dag_node* dag, const type* type_dag, s...
function COMP_B (line 157) | static inline size_t COMP_B(const dag_node* dag, const type* type_dag, s...
function COMP_C (line 163) | static inline size_t COMP_C(const dag_node* dag, const type* type_dag, s...
function CASE_A (line 169) | static inline size_t CASE_A(const dag_node* dag, const type* type_dag, s...
function CASE_B (line 176) | static inline size_t CASE_B(const dag_node* dag, const type* type_dag, s...
function CASE_C (line 183) | static inline size_t CASE_C(const dag_node* dag, const type* type_dag, s...
function CASE_D (line 189) | static inline size_t CASE_D(const dag_node* dag, const type* type_dag, s...
function PAIR_A (line 195) | static inline size_t PAIR_A(const dag_node* dag, const type* type_dag, s...
function PAIR_B (line 201) | static inline size_t PAIR_B(const dag_node* dag, const type* type_dag, s...
function PAIR_C (line 207) | static inline size_t PAIR_C(const dag_node* dag, const type* type_dag, s...
function DISCONNECT_A (line 213) | static inline size_t DISCONNECT_A(const dag_node* dag, const type* type_...
function DISCONNECT_B (line 219) | static inline size_t DISCONNECT_B(const dag_node* dag, const type* type_...
function DISCONNECT_C (line 225) | static inline size_t DISCONNECT_C(const dag_node* dag, const type* type_...
function DISCONNECT_D (line 231) | static inline size_t DISCONNECT_D(const dag_node* dag, const type* type_...
function DISCONNECT_W256A (line 237) | static inline size_t DISCONNECT_W256A(const dag_node* dag, const type* t...
function DISCONNECT_BC (line 243) | static inline size_t DISCONNECT_BC(const dag_node* dag, const type* type...
function INJ_A (line 249) | static inline size_t INJ_A(const dag_node* dag, const type* type_dag, si...
function INJ_B (line 255) | static inline size_t INJ_B(const dag_node* dag, const type* type_dag, si...
function INJ_C (line 261) | static inline size_t INJ_C(const dag_node* dag, const type* type_dag, si...
function PROJ_A (line 267) | static inline size_t PROJ_A(const dag_node* dag, const type* type_dag, s...
function PROJ_B (line 273) | static inline size_t PROJ_B(const dag_node* dag, const type* type_dag, s...
function PROJ_C (line 279) | static inline size_t PROJ_C(const dag_node* dag, const type* type_dag, s...
function WITNESS_A (line 285) | static inline size_t WITNESS_A(const dag_node* dag, const type* type_dag...
function WITNESS_B (line 291) | static inline size_t WITNESS_B(const dag_node* dag, const type* type_dag...
type analyses (line 323) | typedef struct analyses {
FILE: C/deserialize.c
function simplicity_err (line 16) | static simplicity_err getWord32Array(uint32_t* result, const size_t len,...
function simplicity_err (line 36) | static simplicity_err getHash(sha256_midstate* result, bitstream* stream) {
function simplicity_err (line 57) | static simplicity_err decodeNode(dag_node* dag, simplicity_callback_deco...
function simplicity_err (line 155) | static simplicity_err decodeDag(dag_node* dag, simplicity_callback_decod...
function int_fast32_t (line 188) | int_fast32_t simplicity_decodeMallocDag(dag_node** dag, simplicity_callb...
FILE: C/deserialize.h
type simplicity_err (line 19) | typedef simplicity_err (*simplicity_callback_decodeJet)(dag_node* node, ...
FILE: C/elements/cmr.c
function simplicity_elements_computeCmr (line 22) | bool simplicity_elements_computeCmr( simplicity_err* error, unsigned cha...
FILE: C/elements/elementsJets.c
function readHash (line 13) | static void readHash(sha256_midstate* h, frameItem *src) {
function writeHash (line 22) | static void writeHash(frameItem* dst, const sha256_midstate* h) {
function prevOutpoint (line 31) | static void prevOutpoint(frameItem* dst, const outpoint* op) {
function asset (line 41) | static void asset(frameItem* dst, const confidential* asset) {
function amt (line 55) | static void amt(frameItem* dst, const confAmount* amt) {
function nonce (line 70) | static void nonce(frameItem* dst, const confidential* nonce) {
function reissuanceBlinding (line 88) | static void reissuanceBlinding(frameItem* dst, const assetIssuance* issu...
function newIssuanceContract (line 101) | static void newIssuanceContract(frameItem* dst, const assetIssuance* iss...
function reissuanceEntropy (line 114) | static void reissuanceEntropy(frameItem* dst, const assetIssuance* issua...
function issuanceAssetAmt (line 127) | static void issuanceAssetAmt(frameItem* dst, const assetIssuance* issuan...
function issuanceTokenAmt (line 140) | static void issuanceTokenAmt(frameItem* dst, const assetIssuance* issuan...
function uint_fast32_t (line 148) | static uint_fast32_t lockHeight(const elementsTransaction* tx) {
function uint_fast32_t (line 152) | static uint_fast32_t lockTime(const elementsTransaction* tx) {
function uint_fast16_t (line 156) | static uint_fast16_t obsolete_lockDistance(const elementsTransaction* tx) {
function uint_fast16_t (line 160) | static uint_fast16_t obsolete_lockDuration(const elementsTransaction* tx) {
function isFee (line 164) | static bool isFee(const sigOutput* output) {
function uint_fast64_t (line 176) | static uint_fast64_t lookup_fee(const sha256_midstate* assetid, const si...
function simplicity_version (line 192) | bool simplicity_version(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_lock_time (line 199) | bool simplicity_lock_time(frameItem* dst, frameItem src, const txEnv* en...
function simplicity_input_pegin (line 206) | bool simplicity_input_pegin(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_input_prev_outpoint (line 221) | bool simplicity_input_prev_outpoint(frameItem* dst, frameItem src, const...
function simplicity_input_asset (line 232) | bool simplicity_input_asset(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_input_amount (line 243) | bool simplicity_input_amount(frameItem* dst, frameItem src, const txEnv*...
function simplicity_input_script_hash (line 255) | bool simplicity_input_script_hash(frameItem* dst, frameItem src, const t...
function simplicity_input_sequence (line 266) | bool simplicity_input_sequence(frameItem* dst, frameItem src, const txEn...
function simplicity_reissuance_blinding (line 277) | bool simplicity_reissuance_blinding(frameItem* dst, frameItem src, const...
function simplicity_new_issuance_contract (line 288) | bool simplicity_new_issuance_contract(frameItem* dst, frameItem src, con...
function simplicity_reissuance_entropy (line 299) | bool simplicity_reissuance_entropy(frameItem* dst, frameItem src, const ...
function simplicity_issuance_asset_amount (line 310) | bool simplicity_issuance_asset_amount(frameItem* dst, frameItem src, con...
function simplicity_issuance_token_amount (line 321) | bool simplicity_issuance_token_amount(frameItem* dst, frameItem src, con...
function simplicity_issuance_asset_proof (line 332) | bool simplicity_issuance_asset_proof(frameItem* dst, frameItem src, cons...
function simplicity_issuance_token_proof (line 343) | bool simplicity_issuance_token_proof(frameItem* dst, frameItem src, cons...
function simplicity_input_annex_hash (line 354) | bool simplicity_input_annex_hash(frameItem* dst, frameItem src, const tx...
function simplicity_input_script_sig_hash (line 369) | bool simplicity_input_script_sig_hash(frameItem* dst, frameItem src, con...
function simplicity_output_asset (line 380) | bool simplicity_output_asset(frameItem* dst, frameItem src, const txEnv*...
function simplicity_output_amount (line 391) | bool simplicity_output_amount(frameItem* dst, frameItem src, const txEnv...
function simplicity_output_nonce (line 403) | bool simplicity_output_nonce(frameItem* dst, frameItem src, const txEnv*...
function simplicity_output_script_hash (line 414) | bool simplicity_output_script_hash(frameItem* dst, frameItem src, const ...
function simplicity_output_null_datum (line 425) | bool simplicity_output_null_datum(frameItem* dst, frameItem src, const t...
function simplicity_output_is_fee (line 478) | bool simplicity_output_is_fee(frameItem* dst, frameItem src, const txEnv...
function simplicity_output_surjection_proof (line 489) | bool simplicity_output_surjection_proof(frameItem* dst, frameItem src, c...
function simplicity_output_range_proof (line 500) | bool simplicity_output_range_proof(frameItem* dst, frameItem src, const ...
function simplicity_total_fee (line 511) | bool simplicity_total_fee(frameItem* dst, frameItem src, const txEnv* en...
function simplicity_genesis_block_hash (line 519) | bool simplicity_genesis_block_hash(frameItem* dst, frameItem src, const ...
function simplicity_script_cmr (line 526) | bool simplicity_script_cmr(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_transaction_id (line 533) | bool simplicity_transaction_id(frameItem* dst, frameItem src, const txEn...
function simplicity_current_index (line 540) | bool simplicity_current_index(frameItem* dst, frameItem src, const txEnv...
function simplicity_current_pegin (line 547) | bool simplicity_current_pegin(frameItem* dst, frameItem src, const txEnv...
function simplicity_current_prev_outpoint (line 559) | bool simplicity_current_prev_outpoint(frameItem* dst, frameItem src, con...
function simplicity_current_asset (line 567) | bool simplicity_current_asset(frameItem* dst, frameItem src, const txEnv...
function simplicity_current_amount (line 575) | bool simplicity_current_amount(frameItem* dst, frameItem src, const txEn...
function simplicity_current_script_hash (line 584) | bool simplicity_current_script_hash(frameItem* dst, frameItem src, const...
function simplicity_current_sequence (line 592) | bool simplicity_current_sequence(frameItem* dst, frameItem src, const tx...
function simplicity_current_reissuance_blinding (line 600) | bool simplicity_current_reissuance_blinding(frameItem* dst, frameItem sr...
function simplicity_current_new_issuance_contract (line 608) | bool simplicity_current_new_issuance_contract(frameItem* dst, frameItem ...
function simplicity_current_reissuance_entropy (line 616) | bool simplicity_current_reissuance_entropy(frameItem* dst, frameItem src...
function simplicity_current_issuance_asset_amount (line 624) | bool simplicity_current_issuance_asset_amount(frameItem* dst, frameItem ...
function simplicity_current_issuance_token_amount (line 632) | bool simplicity_current_issuance_token_amount(frameItem* dst, frameItem ...
function simplicity_current_issuance_asset_proof (line 640) | bool simplicity_current_issuance_asset_proof(frameItem* dst, frameItem s...
function simplicity_current_issuance_token_proof (line 648) | bool simplicity_current_issuance_token_proof(frameItem* dst, frameItem s...
function simplicity_current_script_sig_hash (line 656) | bool simplicity_current_script_sig_hash(frameItem* dst, frameItem src, c...
function simplicity_current_annex_hash (line 664) | bool simplicity_current_annex_hash(frameItem* dst, frameItem src, const ...
function simplicity_tapleaf_version (line 676) | bool simplicity_tapleaf_version(frameItem* dst, frameItem src, const txE...
function simplicity_tappath (line 683) | bool simplicity_tappath(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_internal_key (line 694) | bool simplicity_internal_key(frameItem* dst, frameItem src, const txEnv*...
function simplicity_num_inputs (line 701) | bool simplicity_num_inputs(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_num_outputs (line 708) | bool simplicity_num_outputs(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_tx_is_final (line 715) | bool simplicity_tx_is_final(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_tx_lock_height (line 722) | bool simplicity_tx_lock_height(frameItem* dst, frameItem src, const txEn...
function simplicity_tx_lock_time (line 729) | bool simplicity_tx_lock_time(frameItem* dst, frameItem src, const txEnv*...
function simplicity_broken_do_not_use_tx_lock_distance (line 736) | bool simplicity_broken_do_not_use_tx_lock_distance(frameItem* dst, frame...
function simplicity_broken_do_not_use_tx_lock_duration (line 743) | bool simplicity_broken_do_not_use_tx_lock_duration(frameItem* dst, frame...
function simplicity_check_lock_height (line 750) | bool simplicity_check_lock_height(frameItem* dst, frameItem src, const t...
function simplicity_check_lock_time (line 757) | bool simplicity_check_lock_time(frameItem* dst, frameItem src, const txE...
function simplicity_broken_do_not_use_check_lock_distance (line 764) | bool simplicity_broken_do_not_use_check_lock_distance(frameItem* dst, fr...
function simplicity_broken_do_not_use_check_lock_duration (line 771) | bool simplicity_broken_do_not_use_check_lock_duration(frameItem* dst, fr...
function simplicity_calculate_issuance_entropy (line 778) | bool simplicity_calculate_issuance_entropy(frameItem* dst, frameItem src...
function simplicity_calculate_asset (line 794) | bool simplicity_calculate_asset(frameItem* dst, frameItem src, const txE...
function simplicity_calculate_explicit_token (line 807) | bool simplicity_calculate_explicit_token(frameItem* dst, frameItem src, ...
function simplicity_calculate_confidential_token (line 820) | bool simplicity_calculate_confidential_token(frameItem* dst, frameItem s...
function simplicity_lbtc_asset (line 833) | bool simplicity_lbtc_asset(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_build_tapleaf_simplicity (line 845) | bool simplicity_build_tapleaf_simplicity(frameItem* dst, frameItem src, ...
function simplicity_build_tapbranch (line 855) | bool simplicity_build_tapbranch(frameItem* dst, frameItem src, const txE...
function simplicity_build_taptweak (line 867) | bool simplicity_build_taptweak(frameItem* dst, frameItem src, const txEn...
function simplicity_outpoint_hash (line 874) | bool simplicity_outpoint_hash(frameItem* dst, frameItem src, const txEnv...
function simplicity_asset_amount_hash (line 903) | bool simplicity_asset_amount_hash(frameItem* dst, frameItem src, const t...
function simplicity_nonce_hash (line 951) | bool simplicity_nonce_hash(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_annex_hash (line 986) | bool simplicity_annex_hash(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_issuance (line 1010) | bool simplicity_issuance(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_issuance_entropy (line 1026) | bool simplicity_issuance_entropy(frameItem* dst, frameItem src, const tx...
function simplicity_issuance_asset (line 1042) | bool simplicity_issuance_asset(frameItem* dst, frameItem src, const txEn...
function simplicity_issuance_token (line 1058) | bool simplicity_issuance_token(frameItem* dst, frameItem src, const txEn...
function simplicity_output_amounts_hash (line 1074) | bool simplicity_output_amounts_hash(frameItem* dst, frameItem src, const...
function simplicity_output_nonces_hash (line 1081) | bool simplicity_output_nonces_hash(frameItem* dst, frameItem src, const ...
function simplicity_output_scripts_hash (line 1088) | bool simplicity_output_scripts_hash(frameItem* dst, frameItem src, const...
function simplicity_output_range_proofs_hash (line 1095) | bool simplicity_output_range_proofs_hash(frameItem* dst, frameItem src, ...
function simplicity_output_surjection_proofs_hash (line 1102) | bool simplicity_output_surjection_proofs_hash(frameItem* dst, frameItem ...
function simplicity_outputs_hash (line 1109) | bool simplicity_outputs_hash(frameItem* dst, frameItem src, const txEnv*...
function simplicity_output_hash (line 1116) | bool simplicity_output_hash(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_input_outpoints_hash (line 1136) | bool simplicity_input_outpoints_hash(frameItem* dst, frameItem src, cons...
function simplicity_input_amounts_hash (line 1143) | bool simplicity_input_amounts_hash(frameItem* dst, frameItem src, const ...
function simplicity_input_scripts_hash (line 1150) | bool simplicity_input_scripts_hash(frameItem* dst, frameItem src, const ...
function simplicity_input_utxos_hash (line 1157) | bool simplicity_input_utxos_hash(frameItem* dst, frameItem src, const tx...
function simplicity_input_utxo_hash (line 1164) | bool simplicity_input_utxo_hash(frameItem* dst, frameItem src, const txE...
function simplicity_input_sequences_hash (line 1182) | bool simplicity_input_sequences_hash(frameItem* dst, frameItem src, cons...
function simplicity_input_annexes_hash (line 1189) | bool simplicity_input_annexes_hash(frameItem* dst, frameItem src, const ...
function simplicity_input_script_sigs_hash (line 1196) | bool simplicity_input_script_sigs_hash(frameItem* dst, frameItem src, co...
function simplicity_inputs_hash (line 1203) | bool simplicity_inputs_hash(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_input_hash (line 1210) | bool simplicity_input_hash(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_issuance_asset_amounts_hash (line 1240) | bool simplicity_issuance_asset_amounts_hash(frameItem* dst, frameItem sr...
function simplicity_issuance_token_amounts_hash (line 1247) | bool simplicity_issuance_token_amounts_hash(frameItem* dst, frameItem sr...
function simplicity_issuance_range_proofs_hash (line 1254) | bool simplicity_issuance_range_proofs_hash(frameItem* dst, frameItem src...
function simplicity_issuance_blinding_entropy_hash (line 1261) | bool simplicity_issuance_blinding_entropy_hash(frameItem* dst, frameItem...
function simplicity_issuances_hash (line 1268) | bool simplicity_issuances_hash(frameItem* dst, frameItem src, const txEn...
function simplicity_issuance_hash (line 1275) | bool simplicity_issuance_hash(frameItem* dst, frameItem src, const txEnv...
function simplicity_tx_hash (line 1316) | bool simplicity_tx_hash(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_tapleaf_hash (line 1323) | bool simplicity_tapleaf_hash(frameItem* dst, frameItem src, const txEnv*...
function simplicity_tappath_hash (line 1330) | bool simplicity_tappath_hash(frameItem* dst, frameItem src, const txEnv*...
function simplicity_tap_env_hash (line 1337) | bool simplicity_tap_env_hash(frameItem* dst, frameItem src, const txEnv*...
function simplicity_sig_all_hash (line 1344) | bool simplicity_sig_all_hash(frameItem* dst, frameItem src, const txEnv*...
FILE: C/elements/env.c
function hashBuffer (line 20) | static void hashBuffer(sha256_midstate* result, const rawElementsBuffer*...
function copyRawConfidential (line 31) | static void copyRawConfidential(confidential* conf, const unsigned char*...
function copyRawAmt (line 48) | static void copyRawAmt(confAmount* amt, const unsigned char* rawAmt) {
function copyInput (line 68) | static void copyInput(sigInput* result, const rawElementsInput* input) {
function isFee (line 107) | static bool isFee(const rawElementsOutput* output) {
function uint_fast32_t (line 113) | static uint_fast32_t countFeeOutputs(const rawElementsTransaction* rawTx) {
function uint_fast32_t (line 129) | static uint_fast32_t countNullDataCodes(const rawElementsBuffer* scriptP...
function uint_fast64_t (line 164) | static uint_fast64_t countTotalNullDataCodes(const rawElementsTransactio...
function parseNullData (line 189) | static void parseNullData(parsedNullData* result, opcode** allocation, s...
function copyOutput (line 248) | static void copyOutput(sigOutput* result, opcode** allocation, size_t* a...
function uint_fast32_t (line 283) | static uint_fast32_t sumFees(sigOutput** feeOutputs, uint_fast32_t numFe...
function elementsTransaction (line 314) | extern elementsTransaction* simplicity_elements_mallocTransaction(const ...
function simplicity_elements_freeTransaction (line 574) | extern void simplicity_elements_freeTransaction(elementsTransaction* tx) {
function elementsTapEnv (line 583) | extern elementsTapEnv* simplicity_elements_mallocTapEnv(const rawElement...
function simplicity_elements_freeTapEnv (line 651) | extern void simplicity_elements_freeTapEnv(elementsTapEnv* env) {
FILE: C/elements/exec.c
function simplicity_elements_execSimplicity (line 45) | extern bool simplicity_elements_execSimplicity( simplicity_err* error, u...
FILE: C/elements/ops.c
function simplicity_sha256_confidential (line 12) | void simplicity_sha256_confidential(unsigned char evenPrefix, unsigned c...
function simplicity_sha256_confAsset (line 27) | void simplicity_sha256_confAsset(sha256_context* ctx, const confidential...
function simplicity_sha256_confNonce (line 36) | void simplicity_sha256_confNonce(sha256_context* ctx, const confidential...
function simplicity_sha256_confAmt (line 45) | void simplicity_sha256_confAmt(sha256_context* ctx, const confAmount* am...
function sha256_midstate (line 66) | sha256_midstate simplicity_generateIssuanceEntropy(const outpoint* op, c...
function sha256_midstate (line 99) | sha256_midstate simplicity_calculateAsset(const sha256_midstate* entropy) {
function sha256_midstate (line 115) | sha256_midstate simplicity_calculateToken(const sha256_midstate* entropy...
function sha256_midstate (line 133) | sha256_midstate simplicity_make_tapleaf(unsigned char version, const sha...
function sha256_midstate (line 158) | sha256_midstate simplicity_make_tapbranch(const sha256_midstate* a, cons...
FILE: C/elements/primitive.c
type TypeNamesForJets (line 9) | enum TypeNamesForJets {
function simplicity_elements_mallocBoundVars (line 32) | size_t simplicity_elements_mallocBoundVars(unification_var** bound_var, ...
type jetName (line 50) | typedef enum jetName
function simplicity_err (line 66) | static simplicity_err decodePrimitive(jetName* result, bitstream* stream) {
function dag_node (line 81) | static dag_node jetNode(jetName name) {
function simplicity_err (line 99) | simplicity_err simplicity_elements_decodeJet(dag_node* node, bitstream* ...
FILE: C/elements/txEnv.c
function txEnv (line 11) | txEnv simplicity_elements_build_txEnv(const elementsTransaction* tx, con...
FILE: C/elements/txEnv.h
type outpoint (line 14) | typedef struct outpoint {
type confPrefix (line 23) | typedef enum confPrefix {
function is_confidential (line 31) | static inline bool is_confidential(confPrefix prefix) {
type confidential (line 41) | typedef struct confidential {
type confAmount (line 52) | typedef struct confAmount {
type opcodeType (line 64) | typedef enum opcodeType {
type opcode (line 95) | typedef struct opcode {
type parsedNullData (line 107) | typedef struct parsedNullData {
type sigOutput (line 118) | typedef struct sigOutput {
type utxo (line 135) | typedef struct utxo {
type issuanceType (line 144) | typedef enum issuanceType {
type assetIssuance (line 158) | typedef struct assetIssuance {
type sigInput (line 182) | typedef struct sigInput {
type elementsTransaction (line 197) | typedef struct elementsTransaction {
type elementsTapEnv (line 238) | typedef struct elementsTapEnv {
type txEnv (line 256) | typedef struct txEnv {
FILE: C/eval.c
function forward (line 124) | static void forward(frameItem* frame, size_t n) {
function backward (line 132) | static void backward(frameItem* frame, size_t n) {
function skip (line 141) | static void skip(frameItem* frame, size_t n) {
function writeValue (line 157) | static void writeValue(frameItem* dst, const bitstring* compactValue, si...
type evalState (line 222) | typedef struct evalState {
type call (line 230) | typedef struct call {
function get_tco_flag (line 241) | static inline bool get_tco_flag(const call *stack) {
function set_tco_flag (line 245) | static inline void set_tco_flag(call *stack, bool flag) {
function get_case_last_flag (line 253) | static inline bool get_case_last_flag(const call *stack) {
function set_case_last_flag (line 257) | static inline void set_case_last_flag(call *stack, bool flag) {
function simplicity_err (line 286) | static simplicity_err runTCO(evalState state, call* stack, const dag_nod...
function simplicity_err (line 534) | static simplicity_err antiDos(flags_type checks, const call* stack, cons...
type boundsAnalysis (line 560) | typedef struct boundsAnalysis {
function simplicity_err (line 588) | simplicity_err simplicity_analyseBounds( ubounded *cellsBound, ubounded ...
function simplicity_err (line 776) | simplicity_err simplicity_evalTCOExpression( flags_type anti_dos_checks,...
FILE: C/eval.h
type flags_type (line 9) | typedef unsigned char flags_type;
function simplicity_err (line 95) | static inline simplicity_err evalTCOProgram(const dag_node* dag, type* t...
FILE: C/frame.c
function simplicity_read_buffer8 (line 104) | void simplicity_read_buffer8(unsigned char* buf, size_t* len, frameItem*...
function simplicity_write_buffer8 (line 129) | void simplicity_write_buffer8(frameItem* dst, const unsigned char* buf, ...
function simplicity_read_sha256_context (line 152) | bool simplicity_read_sha256_context(sha256_context* ctx, frameItem* src) {
function simplicity_write_sha256_context (line 175) | bool simplicity_write_sha256_context(frameItem* dst, const sha256_contex...
function copyBitsHelper (line 189) | static void copyBitsHelper(const frameItem* dst, const frameItem *src, s...
function simplicity_copyBits (line 263) | void simplicity_copyBits(frameItem* dst, const frameItem* src, size_t n) {
FILE: C/frame.h
type frameItem (line 20) | typedef struct frameItem {
function frameItem (line 31) | static inline frameItem initReadFrame(size_t n, UWORD* from) {
function frameItem (line 47) | static inline frameItem initWriteFrame(size_t n, UWORD* from) {
function peekBit (line 55) | static inline bool peekBit(const frameItem* frame) {
function readBit (line 63) | static inline bool readBit(frameItem* frame) {
function writeBit (line 80) | static inline bool writeBit(frameItem* frame, bool bit) {
function forwardBits (line 96) | static inline void forwardBits(frameItem* frame, size_t n) {
function skipBits (line 104) | static inline void skipBits(frameItem* frame, size_t n) {
function read8s (line 133) | static inline void read8s(unsigned char* x, size_t n, frameItem* frame) {
function write8s (line 137) | static inline void write8s(frameItem* frame, const unsigned char* x, siz...
function read32s (line 141) | static inline void read32s(uint32_t* x, size_t n, frameItem* frame) {
function write32s (line 145) | static inline void write32s(frameItem* frame, const uint32_t* x, size_t ...
FILE: C/include/simplicity/bitcoin/env.h
type rawBitcoinBuffer (line 17) | typedef struct rawBitcoinBuffer {
type rawBitcoinOutput (line 24) | typedef struct rawBitcoinOutput {
type rawBitcoinInput (line 34) | typedef struct rawInput {
type rawBitcoinTransaction (line 49) | typedef struct rawBitcoinTransaction {
type bitcoinTransaction (line 60) | typedef struct bitcoinTransaction bitcoinTransaction;
type rawBitcoinTapEnv (line 79) | typedef struct rawBitcoinTapEnv {
type bitcoinTapEnv (line 86) | typedef struct bitcoinTapEnv bitcoinTapEnv;
FILE: C/include/simplicity/elements/env.h
type rawElementsBuffer (line 17) | typedef struct rawElementsBuffer {
type rawElementsOutput (line 28) | typedef struct rawElementsOutput {
type rawElementsInput (line 49) | typedef struct rawElementsInput {
type rawElementsTransaction (line 77) | typedef struct rawElementsTransaction {
type elementsTransaction (line 88) | typedef struct elementsTransaction elementsTransaction;
type rawElementsTapEnv (line 107) | typedef struct rawElementsTapEnv {
type elementsTapEnv (line 114) | typedef struct elementsTapEnv elementsTapEnv;
FILE: C/include/simplicity/errorCodes.h
type simplicity_err (line 12) | typedef enum {
function IS_PERMANENT (line 43) | static inline bool IS_PERMANENT(simplicity_err err) {
function IS_OK (line 48) | static inline bool IS_OK(simplicity_err err) {
FILE: C/jets-secp256k1.c
function simplicity_gej_is_valid_var (line 17) | static bool simplicity_gej_is_valid_var(const secp256k1_gej *a) {
function read_fe (line 32) | static inline void read_fe(secp256k1_fe* r, frameItem* src) {
function write_fe (line 45) | static inline void write_fe(frameItem* dst, secp256k1_fe* r) {
function skip_fe (line 57) | static inline void skip_fe(frameItem* dst) {
function read_ge (line 66) | static inline void read_ge(secp256k1_ge* r, frameItem* src) {
function write_ge (line 77) | static inline void write_ge(frameItem* dst, secp256k1_ge* r) {
function skip_ge (line 86) | static inline void skip_ge(frameItem* dst) {
function read_gej (line 96) | static inline void read_gej(secp256k1_gej* r, frameItem* src) {
function write_gej (line 110) | static inline void write_gej(frameItem* dst, secp256k1_gej* r) {
function read_scalar (line 121) | static inline void read_scalar(secp256k1_scalar* r, frameItem* src) {
function write_scalar (line 133) | static inline void write_scalar(frameItem* dst, const secp256k1_scalar* ...
function simplicity_fe_normalize (line 140) | bool simplicity_fe_normalize(frameItem* dst, frameItem src, const txEnv*...
function simplicity_fe_negate (line 149) | bool simplicity_fe_negate(frameItem* dst, frameItem src, const txEnv* en...
function simplicity_fe_add (line 159) | bool simplicity_fe_add(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_fe_square (line 170) | bool simplicity_fe_square(frameItem* dst, frameItem src, const txEnv* en...
function simplicity_fe_multiply (line 180) | bool simplicity_fe_multiply(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_fe_multiply_beta (line 191) | bool simplicity_fe_multiply_beta(frameItem* dst, frameItem src, const tx...
function simplicity_fe_invert (line 201) | bool simplicity_fe_invert(frameItem* dst, frameItem src, const txEnv* en...
function simplicity_fe_square_root (line 211) | bool simplicity_fe_square_root(frameItem* dst, frameItem src, const txEn...
function simplicity_fe_is_zero (line 225) | bool simplicity_fe_is_zero(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_fe_is_odd (line 234) | bool simplicity_fe_is_odd(frameItem* dst, frameItem src, const txEnv* en...
function simplicity_scalar_normalize (line 243) | bool simplicity_scalar_normalize(frameItem* dst, frameItem src, const tx...
function simplicity_scalar_negate (line 252) | bool simplicity_scalar_negate(frameItem* dst, frameItem src, const txEnv...
function simplicity_scalar_add (line 262) | bool simplicity_scalar_add(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_scalar_square (line 273) | bool simplicity_scalar_square(frameItem* dst, frameItem src, const txEnv...
function simplicity_scalar_multiply (line 283) | bool simplicity_scalar_multiply(frameItem* dst, frameItem src, const txE...
function simplicity_scalar_multiply_lambda (line 294) | bool simplicity_scalar_multiply_lambda(frameItem* dst, frameItem src, co...
function simplicity_scalar_invert (line 304) | bool simplicity_scalar_invert(frameItem* dst, frameItem src, const txEnv...
function simplicity_scalar_is_zero (line 314) | bool simplicity_scalar_is_zero(frameItem* dst, frameItem src, const txEn...
function simplicity_gej_infinity (line 323) | bool simplicity_gej_infinity(frameItem* dst, frameItem src, const txEnv*...
function simplicity_gej_rescale (line 333) | bool simplicity_gej_rescale(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_gej_normalize (line 345) | bool simplicity_gej_normalize(frameItem* dst, frameItem src, const txEnv...
function simplicity_gej_negate (line 360) | bool simplicity_gej_negate(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_ge_negate (line 370) | bool simplicity_ge_negate(frameItem* dst, frameItem src, const txEnv* en...
function simplicity_gej_double (line 380) | bool simplicity_gej_double(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_gej_add (line 390) | bool simplicity_gej_add(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_gej_ge_add_ex (line 401) | bool simplicity_gej_ge_add_ex(frameItem* dst, frameItem src, const txEnv...
function simplicity_gej_ge_add (line 416) | bool simplicity_gej_ge_add(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_gej_is_infinity (line 428) | bool simplicity_gej_is_infinity(frameItem* dst, frameItem src, const txE...
function simplicity_gej_equiv (line 437) | bool simplicity_gej_equiv(frameItem* dst, frameItem src, const txEnv* en...
function simplicity_gej_ge_equiv (line 447) | bool simplicity_gej_ge_equiv(frameItem* dst, frameItem src, const txEnv*...
function simplicity_gej_x_equiv (line 458) | bool simplicity_gej_x_equiv(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_gej_y_is_odd (line 469) | bool simplicity_gej_y_is_odd(frameItem* dst, frameItem src, const txEnv*...
function simplicity_gej_is_on_curve (line 485) | bool simplicity_gej_is_on_curve(frameItem* dst, frameItem src, const txE...
function simplicity_ge_is_on_curve (line 494) | bool simplicity_ge_is_on_curve(frameItem* dst, frameItem src, const txEn...
function simplicity_off_curve_scale (line 503) | bool simplicity_off_curve_scale(frameItem* dst, frameItem src, const txE...
function simplicity_scale (line 517) | bool simplicity_scale(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_generate (line 535) | bool simplicity_generate(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_off_curve_linear_combination_1 (line 549) | bool simplicity_off_curve_linear_combination_1(frameItem* dst, frameItem...
function simplicity_linear_combination_1 (line 563) | bool simplicity_linear_combination_1(frameItem* dst, frameItem src, cons...
function simplicity_linear_verify_1 (line 581) | bool simplicity_linear_verify_1(frameItem* dst, frameItem src, const txE...
function simplicity_decompress (line 605) | bool simplicity_decompress(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_point_verify_1 (line 621) | bool simplicity_point_verify_1(frameItem* dst, frameItem src, const txEn...
function simplicity_bip_0340_verify (line 649) | bool simplicity_bip_0340_verify(frameItem* dst, frameItem src, const txE...
function simplicity_check_sig_verify (line 668) | bool simplicity_check_sig_verify(frameItem* dst, frameItem src, const tx...
function simplicity_swu (line 694) | bool simplicity_swu(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_hash_to_curve (line 705) | bool simplicity_hash_to_curve(frameItem* dst, frameItem src, const txEnv...
function simplicity_generic_taptweak (line 725) | bool simplicity_generic_taptweak(frameItem* dst, frameItem *src, const u...
FILE: C/jets.c
function write128 (line 12) | static void write128(frameItem* frame, const secp256k1_uint128* x) {
function simplicity_verify (line 18) | bool simplicity_verify(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_low_1 (line 25) | bool simplicity_low_1(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_high_1 (line 46) | bool simplicity_high_1(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_complement_1 (line 67) | bool simplicity_complement_1(frameItem* dst, frameItem src, const txEnv*...
function simplicity_and_1 (line 88) | bool simplicity_and_1(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_or_1 (line 111) | bool simplicity_or_1(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_xor_1 (line 134) | bool simplicity_xor_1(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_maj_1 (line 157) | bool simplicity_maj_1(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_xor_xor_1 (line 182) | bool simplicity_xor_xor_1(frameItem* dst, frameItem src, const txEnv* en...
function simplicity_ch_1 (line 207) | bool simplicity_ch_1(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_some_1 (line 232) | bool simplicity_some_1(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_eq_1 (line 266) | bool simplicity_eq_1(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_eq_256 (line 289) | bool simplicity_eq_256(frameItem* dst, frameItem src, const txEnv* env) {
function simplicity_multiply_64 (line 852) | bool simplicity_multiply_64(frameItem* dst, frameItem src, const txEnv* ...
function simplicity_full_multiply_64 (line 876) | bool simplicity_full_multiply_64(frameItem* dst, frameItem src, const tx...
function div_mod_96_64 (line 1109) | static void div_mod_96_64(uint_fast32_t *q, uint_fast64_t *r,
function simplicity_div_mod_128_64 (line 1155) | bool simplicity_div_mod_128_64(frameItem* dst, frameItem src, const txEn...
function simplicity_sha_256_iv (line 1206) | bool simplicity_sha_256_iv(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_sha_256_block (line 1218) | bool simplicity_sha_256_block(frameItem* dst, frameItem src, const txEnv...
function simplicity_sha_256_ctx_8_init (line 1233) | bool simplicity_sha_256_ctx_8_init(frameItem* dst, frameItem src, const ...
function sha_256_ctx_8_add_n (line 1249) | static bool sha_256_ctx_8_add_n(frameItem* dst, frameItem *src, size_t n) {
function simplicity_sha_256_ctx_8_add_1 (line 1265) | bool simplicity_sha_256_ctx_8_add_1(frameItem* dst, frameItem src, const...
function simplicity_sha_256_ctx_8_add_2 (line 1274) | bool simplicity_sha_256_ctx_8_add_2(frameItem* dst, frameItem src, const...
function simplicity_sha_256_ctx_8_add_4 (line 1283) | bool simplicity_sha_256_ctx_8_add_4(frameItem* dst, frameItem src, const...
function simplicity_sha_256_ctx_8_add_8 (line 1292) | bool simplicity_sha_256_ctx_8_add_8(frameItem* dst, frameItem src, const...
function simplicity_sha_256_ctx_8_add_16 (line 1301) | bool simplicity_sha_256_ctx_8_add_16(frameItem* dst, frameItem src, cons...
function simplicity_sha_256_ctx_8_add_32 (line 1310) | bool simplicity_sha_256_ctx_8_add_32(frameItem* dst, frameItem src, cons...
function simplicity_sha_256_ctx_8_add_64 (line 1319) | bool simplicity_sha_256_ctx_8_add_64(frameItem* dst, frameItem src, cons...
function simplicity_sha_256_ctx_8_add_128 (line 1328) | bool simplicity_sha_256_ctx_8_add_128(frameItem* dst, frameItem src, con...
function simplicity_sha_256_ctx_8_add_256 (line 1337) | bool simplicity_sha_256_ctx_8_add_256(frameItem* dst, frameItem src, con...
function simplicity_sha_256_ctx_8_add_512 (line 1346) | bool simplicity_sha_256_ctx_8_add_512(frameItem* dst, frameItem src, con...
function simplicity_sha_256_ctx_8_add_buffer_511 (line 1355) | bool simplicity_sha_256_ctx_8_add_buffer_511(frameItem* dst, frameItem s...
function simplicity_sha_256_ctx_8_finalize (line 1373) | bool simplicity_sha_256_ctx_8_finalize(frameItem* dst, frameItem src, co...
function simplicity_parse_lock (line 1386) | bool simplicity_parse_lock(frameItem* dst, frameItem src, const txEnv* e...
function simplicity_parse_sequence (line 1395) | bool simplicity_parse_sequence(frameItem* dst, frameItem src, const txEn...
function simplicity_tapdata_init (line 1408) | bool simplicity_tapdata_init(frameItem* dst, frameItem src, const txEnv*...
FILE: C/jets.h
type txEnv (line 10) | typedef struct txEnv txEnv;
FILE: C/rsort.c
function readIndex (line 22) | static unsigned char readIndex(const sha256_midstate* a, unsigned int i) {
function freq (line 36) | static bool freq(uint32_t* result, const sha256_midstate * const * a, ui...
function cumulative (line 55) | static void cumulative(uint32_t* restrict bucketEdge, const uint32_t* re...
function swap (line 69) | static void swap(const sha256_midstate** a, const sha256_midstate** b) {
function sort_buckets (line 87) | static void sort_buckets(const sha256_midstate** a, uint32_t* restrict b...
function rsort_ex (line 124) | static void rsort_ex(const sha256_midstate** a, uint_fast32_t len, const...
function simplicity_rsort (line 249) | bool simplicity_rsort(const sha256_midstate** a, uint_fast32_t len) {
function simplicity_hasDuplicates (line 265) | int simplicity_hasDuplicates(const sha256_midstate* a, uint_fast32_t len) {
FILE: C/secp256k1/assumptions.h
type secp256k1_assumption_checker (line 22) | struct secp256k1_assumption_checker {
FILE: C/secp256k1/eckey_impl.h
function secp256k1_eckey_pubkey_parse (line 18) | static int secp256k1_eckey_pubkey_parse(secp256k1_ge *elem, const unsign...
function secp256k1_eckey_pubkey_serialize (line 38) | static int secp256k1_eckey_pubkey_serialize(secp256k1_ge *elem, unsigned...
function secp256k1_eckey_privkey_tweak_add (line 56) | static int secp256k1_eckey_privkey_tweak_add(secp256k1_scalar *key, cons...
function secp256k1_eckey_pubkey_tweak_add (line 62) | static int secp256k1_eckey_pubkey_tweak_add(secp256k1_ge *key, const sec...
function secp256k1_eckey_privkey_tweak_mul (line 77) | static int secp256k1_eckey_privkey_tweak_mul(secp256k1_scalar *key, cons...
function secp256k1_eckey_pubkey_tweak_mul (line 85) | static int secp256k1_eckey_pubkey_tweak_mul(secp256k1_ge *key, const sec...
FILE: C/secp256k1/ecmult_impl.h
function secp256k1_ecmult_odd_multiples_table (line 73) | static void secp256k1_ecmult_odd_multiples_table(int n, secp256k1_ge *pr...
function SECP256K1_INLINE (line 122) | SECP256K1_INLINE static void secp256k1_ecmult_table_get_ge(secp256k1_ge ...
function SECP256K1_INLINE (line 132) | SECP256K1_INLINE static void secp256k1_ecmult_table_get_ge_lambda(secp25...
function SECP256K1_INLINE (line 142) | SECP256K1_INLINE static void secp256k1_ecmult_table_get_ge_storage(secp2...
function secp256k1_ecmult_wnaf (line 159) | static int secp256k1_ecmult_wnaf(int *wnaf, int len, const secp256k1_sca...
type secp256k1_strauss_point_state (line 217) | struct secp256k1_strauss_point_state {
type secp256k1_strauss_state (line 224) | struct secp256k1_strauss_state {
function secp256k1_ecmult_strauss_wnaf (line 231) | static void secp256k1_ecmult_strauss_wnaf(const struct secp256k1_strauss...
function secp256k1_ecmult (line 344) | static void secp256k1_ecmult(secp256k1_gej *r, const secp256k1_gej *a, c...
function secp256k1_strauss_scratch_size (line 357) | static size_t secp256k1_strauss_scratch_size(size_t n_points) {
function secp256k1_ecmult_strauss_batch (line 362) | static int secp256k1_ecmult_strauss_batch(const secp256k1_callback* erro...
function secp256k1_ecmult_strauss_batch_single (line 402) | static int secp256k1_ecmult_strauss_batch_single(const secp256k1_callbac...
function secp256k1_strauss_max_points (line 406) | static size_t secp256k1_strauss_max_points(const secp256k1_callback* err...
function secp256k1_wnaf_fixed (line 417) | static int secp256k1_wnaf_fixed(int *wnaf, const secp256k1_scalar *s, in...
type secp256k1_pippenger_point_state (line 479) | struct secp256k1_pippenger_point_state {
type secp256k1_pippenger_state (line 484) | struct secp256k1_pippenger_state {
function secp256k1_ecmult_pippenger_wnaf (line 496) | static int secp256k1_ecmult_pippenger_wnaf(secp256k1_gej *buckets, int b...
function secp256k1_pippenger_bucket_window (line 577) | static int secp256k1_pippenger_bucket_window(size_t n) {
function secp256k1_pippenger_bucket_window_inv (line 606) | static size_t secp256k1_pippenger_bucket_window_inv(int bucket_window) {
function SECP256K1_INLINE (line 625) | SECP256K1_INLINE static void secp256k1_ecmult_endo_split(secp256k1_scala...
function secp256k1_pippenger_scratch_size (line 644) | static size_t secp256k1_pippenger_scratch_size(size_t n_points, int buck...
function secp256k1_ecmult_pippenger_batch (line 650) | static int secp256k1_ecmult_pippenger_batch(const secp256k1_callback* er...
function secp256k1_ecmult_pippenger_batch_single (line 727) | static int secp256k1_ecmult_pippenger_batch_single(const secp256k1_callb...
function secp256k1_pippenger_max_points (line 736) | static size_t secp256k1_pippenger_max_points(const secp256k1_callback* e...
function secp256k1_ecmult_multi_simple_var (line 772) | static int secp256k1_ecmult_multi_simple_var(secp256k1_gej *r, const sec...
function secp256k1_ecmult_multi_batch_size_helper (line 799) | static int secp256k1_ecmult_multi_batch_size_helper(size_t *n_batches, s...
function secp256k1_ecmult_multi_var (line 818) | static int secp256k1_ecmult_multi_var(const secp256k1_callback* error_ca...
FILE: C/secp256k1/extrakeys.h
type secp256k1_xonly_pubkey (line 18) | typedef struct {
FILE: C/secp256k1/extrakeys_impl.h
function SECP256K1_INLINE (line 13) | static SECP256K1_INLINE int secp256k1_xonly_pubkey_load(secp256k1_ge *ge...
function SECP256K1_INLINE (line 17) | static SECP256K1_INLINE void secp256k1_xonly_pubkey_save(secp256k1_xonly...
function secp256k1_xonly_pubkey_parse (line 21) | static int secp256k1_xonly_pubkey_parse(secp256k1_xonly_pubkey *pubkey, ...
function secp256k1_xonly_pubkey_serialize (line 42) | static int secp256k1_xonly_pubkey_serialize(unsigned char *output32, con...
function secp256k1_extrakeys_ge_even_y (line 59) | static int secp256k1_extrakeys_ge_even_y(secp256k1_ge *r) {
function secp256k1_xonly_pubkey_from_pubkey (line 70) | static int secp256k1_xonly_pubkey_from_pubkey(secp256k1_xonly_pubkey *xo...
function secp256k1_xonly_pubkey_tweak_add (line 88) | static int secp256k1_xonly_pubkey_tweak_add(secp256k1_pubkey *output_pub...
FILE: C/secp256k1/field_5x52.h
type secp256k1_fe (line 12) | typedef struct {
type secp256k1_fe_storage (line 38) | typedef struct {
FILE: C/secp256k1/field_5x52_asm_impl.h
function SECP256K1_INLINE (line 17) | SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const u...
function SECP256K1_INLINE (line 287) | SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const u...
FILE: C/secp256k1/field_5x52_impl.h
function secp256k1_fe_verify (line 36) | static void secp256k1_fe_verify(const secp256k1_fe *a) {
function secp256k1_fe_get_bounds (line 58) | static void secp256k1_fe_get_bounds(secp256k1_fe *r, int m) {
function secp256k1_fe_normalize (line 73) | static void secp256k1_fe_normalize(secp256k1_fe *r) {
function secp256k1_fe_normalize_weak (line 117) | static void secp256k1_fe_normalize_weak(secp256k1_fe *r) {
function secp256k1_fe_normalize_var (line 141) | static void secp256k1_fe_normalize_var(secp256k1_fe *r) {
function secp256k1_fe_normalizes_to_zero (line 186) | static int secp256k1_fe_normalizes_to_zero(const secp256k1_fe *r) {
function secp256k1_fe_normalizes_to_zero_var (line 210) | static int secp256k1_fe_normalizes_to_zero_var(const secp256k1_fe *r) {
function SECP256K1_INLINE (line 251) | SECP256K1_INLINE static void secp256k1_fe_set_int(secp256k1_fe *r, int a) {
function SECP256K1_INLINE (line 262) | SECP256K1_INLINE static int secp256k1_fe_is_zero(const secp256k1_fe *a) {
function SECP256K1_INLINE (line 271) | SECP256K1_INLINE static int secp256k1_fe_is_odd(const secp256k1_fe *a) {
function SECP256K1_INLINE (line 279) | SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) {
function secp256k1_fe_cmp_var (line 291) | static int secp256k1_fe_cmp_var(const secp256k1_fe *a, const secp256k1_f...
function secp256k1_fe_set_b32 (line 311) | static int secp256k1_fe_set_b32(secp256k1_fe *r, const unsigned char *a) {
function secp256k1_fe_get_b32 (line 361) | static void secp256k1_fe_get_b32(unsigned char *r, const secp256k1_fe *a) {
function SECP256K1_INLINE (line 400) | SECP256K1_INLINE static void secp256k1_fe_negate(secp256k1_fe *r, const ...
function SECP256K1_INLINE (line 420) | SECP256K1_INLINE static void secp256k1_fe_mul_int(secp256k1_fe *r, int a) {
function SECP256K1_INLINE (line 433) | SECP256K1_INLINE static void secp256k1_fe_add_int(secp256k1_fe *r, int a) {
function SECP256K1_INLINE (line 447) | SECP256K1_INLINE static void secp256k1_fe_add(secp256k1_fe *r, const sec...
function secp256k1_fe_mul (line 463) | static void secp256k1_fe_mul(secp256k1_fe *r, const secp256k1_fe *a, con...
function secp256k1_fe_sqr (line 480) | static void secp256k1_fe_sqr(secp256k1_fe *r, const secp256k1_fe *a) {
function SECP256K1_INLINE (line 493) | static SECP256K1_INLINE void secp256k1_fe_cmov(secp256k1_fe *r, const se...
function SECP256K1_INLINE (line 513) | static SECP256K1_INLINE void secp256k1_fe_half(secp256k1_fe *r) {
function SECP256K1_INLINE (line 579) | static SECP256K1_INLINE void secp256k1_fe_storage_cmov(secp256k1_fe_stor...
function secp256k1_fe_to_storage (line 591) | static void secp256k1_fe_to_storage(secp256k1_fe_storage *r, const secp2...
function SECP256K1_INLINE (line 601) | static SECP256K1_INLINE void secp256k1_fe_from_storage(secp256k1_fe *r, ...
function secp256k1_fe_from_signed62 (line 614) | static void secp256k1_fe_from_signed62(secp256k1_fe *r, const secp256k1_...
function secp256k1_fe_to_signed62 (line 640) | static void secp256k1_fe_to_signed62(secp256k1_modinv64_signed62 *r, con...
function secp256k1_fe_inv (line 661) | static void secp256k1_fe_inv(secp256k1_fe *r, const secp256k1_fe *x) {
function secp256k1_fe_inv_var (line 677) | static void secp256k1_fe_inv_var(secp256k1_fe *r, const secp256k1_fe *x) {
function secp256k1_fe_is_square_var (line 693) | static int secp256k1_fe_is_square_var(const secp256k1_fe *x) {
FILE: C/secp256k1/field_5x52_int128_impl.h
function SECP256K1_INLINE (line 22) | SECP256K1_INLINE static void secp256k1_fe_mul_inner(uint64_t *r, const u...
function SECP256K1_INLINE (line 158) | SECP256K1_INLINE static void secp256k1_fe_sqr_inner(uint64_t *r, const u...
FILE: C/secp256k1/field_impl.h
function SECP256K1_INLINE (line 19) | SECP256K1_INLINE static int secp256k1_fe_equal(const secp256k1_fe *a, co...
function SECP256K1_INLINE (line 27) | SECP256K1_INLINE static int secp256k1_fe_equal_var(const secp256k1_fe *a...
function secp256k1_fe_sqrt_var (line 34) | static int secp256k1_fe_sqrt_var(secp256k1_fe *r, const secp256k1_fe *a) {
FILE: C/secp256k1/generator.h
type secp256k1_generator (line 16) | typedef struct {
FILE: C/secp256k1/generator_impl.h
function secp256k1_generator_load (line 40) | static void secp256k1_generator_load(secp256k1_ge* ge, const secp256k1_g...
function secp256k1_generator_save (line 50) | static void secp256k1_generator_save(secp256k1_generator *gen, secp256k1...
function secp256k1_generator_parse (line 59) | int secp256k1_generator_parse(const secp256k1_context* ctx, secp256k1_ge...
function secp256k1_generator_serialize (line 79) | int secp256k1_generator_serialize(const secp256k1_context* ctx, unsigned...
function shallue_van_de_woestijne (line 95) | static void shallue_van_de_woestijne(secp256k1_ge* ge, const secp256k1_f...
function secp256k1_generator_generate_internal (line 205) | static int secp256k1_generator_generate_internal(secp256k1_generator* ge...
function secp256k1_generator_generate (line 256) | int secp256k1_generator_generate(secp256k1_generator* gen, const unsigne...
function secp256k1_generator_generate_blinded (line 263) | int secp256k1_generator_generate_blinded(const secp256k1_context* ctx, s...
function secp256k1_pedersen_commitment_load (line 272) | static void secp256k1_pedersen_commitment_load(secp256k1_ge* ge, const s...
function secp256k1_pedersen_commitment_save (line 281) | static void secp256k1_pedersen_commitment_save(secp256k1_pedersen_commit...
function secp256k1_pedersen_commitment_parse (line 287) | int secp256k1_pedersen_commitment_parse(const secp256k1_context* ctx, se...
function secp256k1_pedersen_commitment_serialize (line 308) | int secp256k1_pedersen_commitment_serialize(const secp256k1_context* ctx...
function secp256k1_pedersen_commit (line 324) | int secp256k1_pedersen_commit(const secp256k1_context* ctx, secp256k1_pe...
function secp256k1_pedersen_blind_sum (line 355) | int secp256k1_pedersen_blind_sum(const secp256k1_context* ctx, unsigned ...
function secp256k1_pedersen_verify_tally (line 383) | int secp256k1_pedersen_verify_tally(const secp256k1_context* ctx, const ...
function secp256k1_pedersen_blind_generator_blind_sum (line 404) | int secp256k1_pedersen_blind_generator_blind_sum(const secp256k1_context...
FILE: C/secp256k1/group.h
type secp256k1_ge (line 16) | typedef struct {
type secp256k1_gej (line 28) | typedef struct {
type secp256k1_ge_storage (line 38) | typedef struct {
FILE: C/secp256k1/group_impl.h
function secp256k1_ge_set_gej_zinv (line 55) | static void secp256k1_ge_set_gej_zinv(secp256k1_ge *r, const secp256k1_g...
function secp256k1_ge_set_xy (line 66) | static void secp256k1_ge_set_xy(secp256k1_ge *r, const secp256k1_fe *x, ...
function secp256k1_ge_is_infinity (line 72) | static int secp256k1_ge_is_infinity(const secp256k1_ge *a) {
function secp256k1_ge_neg (line 76) | static void secp256k1_ge_neg(secp256k1_ge *r, const secp256k1_ge *a) {
function secp256k1_ge_set_gej (line 83) | static void secp256k1_ge_set_gej(secp256k1_ge *r, secp256k1_gej *a) {
function secp256k1_ge_set_gej_var (line 97) | static void secp256k1_ge_set_gej_var(secp256k1_ge *r, secp256k1_gej *a) {
function secp256k1_ge_set_all_gej_var (line 113) | static void secp256k1_ge_set_all_gej_var(secp256k1_ge *r, const secp256k...
function secp256k1_ge_table_set_globalz (line 156) | static void secp256k1_ge_table_set_globalz(size_t len, secp256k1_ge *a, ...
function secp256k1_gej_set_infinity (line 180) | static void secp256k1_gej_set_infinity(secp256k1_gej *r) {
function secp256k1_ge_set_infinity (line 187) | static void secp256k1_ge_set_infinity(secp256k1_ge *r) {
function secp256k1_gej_clear (line 194) | static void secp256k1_gej_clear(secp256k1_gej *r) {
function secp256k1_ge_clear (line 201) | static void secp256k1_ge_clear(secp256k1_ge *r) {
function secp256k1_ge_set_xo_var (line 208) | static int secp256k1_ge_set_xo_var(secp256k1_ge *r, const secp256k1_fe *...
function secp256k1_gej_set_ge (line 226) | static void secp256k1_gej_set_ge(secp256k1_gej *r, const secp256k1_ge *a) {
function secp256k1_gej_eq_var (line 233) | static int secp256k1_gej_eq_var(const secp256k1_gej *a, const secp256k1_...
function secp256k1_gej_eq_ge_var (line 240) | static int secp256k1_gej_eq_ge_var(const secp256k1_gej *a, const secp256...
function secp256k1_gej_eq_x_var (line 247) | static int secp256k1_gej_eq_x_var(const secp256k1_fe *x, const secp256k1...
function secp256k1_gej_neg (line 255) | static void secp256k1_gej_neg(secp256k1_gej *r, const secp256k1_gej *a) {
function secp256k1_gej_is_infinity (line 264) | static int secp256k1_gej_is_infinity(const secp256k1_gej *a) {
function secp256k1_ge_is_valid_var (line 268) | static int secp256k1_ge_is_valid_var(const secp256k1_ge *a) {
function SECP256K1_INLINE (line 281) | static SECP256K1_INLINE void secp256k1_gej_double(secp256k1_gej *r, cons...
function secp256k1_gej_double_var (line 313) | static void secp256k1_gej_double_var(secp256k1_gej *r, const secp256k1_g...
function secp256k1_gej_add_var (line 341) | static void secp256k1_gej_add_var(secp256k1_gej *r, const secp256k1_gej ...
function secp256k1_gej_add_ge_var (line 401) | static void secp256k1_gej_add_ge_var(secp256k1_gej *r, const secp256k1_g...
function secp256k1_gej_add_zinv_var (line 461) | static void secp256k1_gej_add_zinv_var(secp256k1_gej *r, const secp256k1...
function secp256k1_gej_add_ge (line 527) | static void secp256k1_gej_add_ge(secp256k1_gej *r, const secp256k1_gej *...
function secp256k1_gej_rescale (line 660) | static void secp256k1_gej_rescale(secp256k1_gej *r, const secp256k1_fe *...
function secp256k1_ge_to_storage (line 671) | static void secp256k1_ge_to_storage(secp256k1_ge_storage *r, const secp2...
function secp256k1_ge_from_storage (line 682) | static void secp256k1_ge_from_storage(secp256k1_ge *r, const secp256k1_g...
function SECP256K1_INLINE (line 689) | static SECP256K1_INLINE void secp256k1_gej_cmov(secp256k1_gej *r, const ...
function SECP256K1_INLINE (line 697) | static SECP256K1_INLINE void secp256k1_ge_storage_cmov(secp256k1_ge_stor...
function secp256k1_ge_mul_lambda (line 702) | static void secp256k1_ge_mul_lambda(secp256k1_ge *r, const secp256k1_ge ...
function secp256k1_ge_is_in_correct_subgroup (line 708) | static int secp256k1_ge_is_in_correct_subgroup(const secp256k1_ge* ge) {
FILE: C/secp256k1/int128_native.h
type uint128_t (line 16) | typedef uint128_t secp256k1_uint128;
type int128_t (line 17) | typedef int128_t secp256k1_int128;
FILE: C/secp256k1/int128_native_impl.h
function SECP256K1_INLINE (line 6) | static SECP256K1_INLINE void secp256k1_u128_load(secp256k1_uint128 *r, u...
function SECP256K1_INLINE (line 10) | static SECP256K1_INLINE void secp256k1_u128_mul(secp256k1_uint128 *r, ui...
function SECP256K1_INLINE (line 14) | static SECP256K1_INLINE void secp256k1_u128_accum_mul(secp256k1_uint128 ...
function SECP256K1_INLINE (line 18) | static SECP256K1_INLINE void secp256k1_u128_accum_u64(secp256k1_uint128 ...
function SECP256K1_INLINE (line 22) | static SECP256K1_INLINE void secp256k1_u128_rshift(secp256k1_uint128 *r,...
function SECP256K1_INLINE (line 27) | static SECP256K1_INLINE uint64_t secp256k1_u128_to_u64(const secp256k1_u...
function SECP256K1_INLINE (line 31) | static SECP256K1_INLINE uint64_t secp256k1_u128_hi_u64(const secp256k1_u...
function SECP256K1_INLINE (line 35) | static SECP256K1_INLINE void secp256k1_u128_from_u64(secp256k1_uint128 *...
function SECP256K1_INLINE (line 39) | static SECP256K1_INLINE int secp256k1_u128_check_bits(const secp256k1_ui...
function SECP256K1_INLINE (line 44) | static SECP256K1_INLINE void secp256k1_i128_load(secp256k1_int128 *r, in...
function SECP256K1_INLINE (line 48) | static SECP256K1_INLINE void secp256k1_i128_mul(secp256k1_int128 *r, int...
function SECP256K1_INLINE (line 52) | static SECP256K1_INLINE void secp256k1_i128_accum_mul(secp256k1_int128 *...
function SECP256K1_INLINE (line 58) | static SECP256K1_INLINE void secp256k1_i128_det(secp256k1_int128 *r, int...
function SECP256K1_INLINE (line 65) | static SECP256K1_INLINE void secp256k1_i128_rshift(secp256k1_int128 *r, ...
function SECP256K1_INLINE (line 70) | static SECP256K1_INLINE uint64_t secp256k1_i128_to_u64(const secp256k1_i...
function SECP256K1_INLINE (line 74) | static SECP256K1_INLINE int64_t secp256k1_i128_to_i64(const secp256k1_in...
function SECP256K1_INLINE (line 79) | static SECP256K1_INLINE void secp256k1_i128_from_i64(secp256k1_int128 *r...
function SECP256K1_INLINE (line 83) | static SECP256K1_INLINE int secp256k1_i128_eq_var(const secp256k1_int128...
function SECP256K1_INLINE (line 87) | static SECP256K1_INLINE int secp256k1_i128_check_pow2(const secp256k1_in...
FILE: C/secp256k1/int128_struct.h
type secp256k1_uint128 (line 7) | typedef struct secp256k1_uint128 {
type secp256k1_uint128 (line 12) | typedef secp256k1_uint128 secp256k1_int128;
FILE: C/secp256k1/int128_struct_impl.h
function SECP256K1_INLINE (line 15) | static SECP256K1_INLINE uint64_t secp256k1_umul128(uint64_t a, uint64_t ...
function SECP256K1_INLINE (line 20) | static SECP256K1_INLINE int64_t secp256k1_mul128(int64_t a, int64_t b, i...
function SECP256K1_INLINE (line 27) | static SECP256K1_INLINE uint64_t secp256k1_mul128(int64_t a, int64_t b, ...
function SECP256K1_INLINE (line 33) | static SECP256K1_INLINE uint64_t secp256k1_umul128(uint64_t a, uint64_t ...
function SECP256K1_INLINE (line 43) | static SECP256K1_INLINE uint64_t secp256k1_mul128(int64_t a, int64_t b, ...
function SECP256K1_INLINE (line 54) | static SECP256K1_INLINE void secp256k1_u128_load(secp256k1_uint128 *r, u...
function SECP256K1_INLINE (line 59) | static SECP256K1_INLINE void secp256k1_u128_mul(secp256k1_uint128 *r, ui...
function SECP256K1_INLINE (line 63) | static SECP256K1_INLINE void secp256k1_u128_accum_mul(secp256k1_uint128 ...
function SECP256K1_INLINE (line 70) | static SECP256K1_INLINE void secp256k1_u128_accum_u64(secp256k1_uint128 ...
function SECP256K1_INLINE (line 78) | static SECP256K1_INLINE void secp256k1_u128_rshift(secp256k1_uint128 *r,...
function SECP256K1_INLINE (line 89) | static SECP256K1_INLINE uint64_t secp256k1_u128_to_u64(const secp256k1_u...
function SECP256K1_INLINE (line 93) | static SECP256K1_INLINE uint64_t secp256k1_u128_hi_u64(const secp256k1_u...
function SECP256K1_INLINE (line 97) | static SECP256K1_INLINE void secp256k1_u128_from_u64(secp256k1_uint128 *...
function SECP256K1_INLINE (line 102) | static SECP256K1_INLINE int secp256k1_u128_check_bits(const secp256k1_ui...
function SECP256K1_INLINE (line 108) | static SECP256K1_INLINE void secp256k1_i128_load(secp256k1_int128 *r, in...
function SECP256K1_INLINE (line 113) | static SECP256K1_INLINE void secp256k1_i128_mul(secp256k1_int128 *r, int...
function SECP256K1_INLINE (line 119) | static SECP256K1_INLINE void secp256k1_i128_accum_mul(secp256k1_int128 *...
function SECP256K1_INLINE (line 138) | static SECP256K1_INLINE void secp256k1_i128_dissip_mul(secp256k1_int128 ...
function SECP256K1_INLINE (line 156) | static SECP256K1_INLINE void secp256k1_i128_det(secp256k1_int128 *r, int...
function SECP256K1_INLINE (line 164) | static SECP256K1_INLINE void secp256k1_i128_rshift(secp256k1_int128 *r, ...
function SECP256K1_INLINE (line 175) | static SECP256K1_INLINE uint64_t secp256k1_i128_to_u64(const secp256k1_i...
function SECP256K1_INLINE (line 179) | static SECP256K1_INLINE int64_t secp256k1_i128_to_i64(const secp256k1_in...
function SECP256K1_INLINE (line 185) | static SECP256K1_INLINE void secp256k1_i128_from_i64(secp256k1_int128 *r...
function SECP256K1_INLINE (line 190) | static SECP256K1_INLINE int secp256k1_i128_eq_var(const secp256k1_int128...
function SECP256K1_INLINE (line 194) | static SECP256K1_INLINE int secp256k1_i128_check_pow2(const secp256k1_in...
FILE: C/secp256k1/modinv64.h
type secp256k1_modinv64_signed62 (line 19) | typedef struct secp256k1_modinv64_signed62 {
type secp256k1_modinv64_modinfo (line 23) | typedef struct secp256k1_modinv64_modinfo {
function secp256k1_modinv64_signed62_assign (line 31) | static inline void secp256k1_modinv64_signed62_assign(secp256k1_modinv64...
FILE: C/secp256k1/modinv64_impl.h
type secp256k1_modinv64_trans2x2 (line 25) | typedef struct secp256k1_modinv64_trans2x2 {
function secp256k1_modinv64_abs (line 32) | static int64_t secp256k1_modinv64_abs(int64_t v) {
function secp256k1_modinv64_mul_62 (line 41) | static void secp256k1_modinv64_mul_62(secp256k1_modinv64_signed62 *r, co...
function secp256k1_modinv64_mul_cmp_62 (line 57) | static int secp256k1_modinv64_mul_cmp_62(const secp256k1_modinv64_signed...
function secp256k1_modinv64_det_check_pow2 (line 75) | static int secp256k1_modinv64_det_check_pow2(const secp256k1_modinv64_tr...
function secp256k1_modinv64_normalize_62 (line 88) | static void secp256k1_modinv64_normalize_62(secp256k1_modinv64_signed62 ...
function secp256k1_modinv64_divsteps_59 (line 170) | static int64_t secp256k1_modinv64_divsteps_59(int64_t zeta, uint64_t f0,...
function secp256k1_modinv64_divsteps_62_var (line 240) | static int64_t secp256k1_modinv64_divsteps_62_var(int64_t eta, uint64_t ...
function secp256k1_modinv64_posdivsteps_62_var (line 327) | static int64_t secp256k1_modinv64_posdivsteps_62_var(int64_t eta, uint64...
function secp256k1_modinv64_update_de_62 (line 414) | static void secp256k1_modinv64_update_de_62(secp256k1_modinv64_signed62 ...
function secp256k1_modinv64_update_fg_62 (line 506) | static void secp256k1_modinv64_update_fg_62(secp256k1_modinv64_signed62 ...
function secp256k1_modinv64_update_fg_62_var (line 560) | static void secp256k1_modinv64_update_fg_62_var(int len, secp256k1_modin...
function secp256k1_modinv64 (line 596) | static void secp256k1_modinv64(secp256k1_modinv64_signed62 *x, const sec...
function secp256k1_modinv64_var (line 650) | static void secp256k1_modinv64_var(secp256k1_modinv64_signed62 *x, const...
function secp256k1_jacobi64_maybe_var (line 741) | static int secp256k1_jacobi64_maybe_var(const secp256k1_modinv64_signed6...
FILE: C/secp256k1/scalar_4x64.h
type secp256k1_scalar (line 13) | typedef struct {
FILE: C/secp256k1/scalar_4x64_impl.h
function SECP256K1_INLINE (line 30) | SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) {
function SECP256K1_INLINE (line 37) | SECP256K1_INLINE static void secp256k1_scalar_set_int(secp256k1_scalar *...
function secp256k1_scalar_get_bits (line 44) | int secp256k1_scalar_get_bits(const secp256k1_scalar *a, unsigned int of...
function secp256k1_scalar_get_bits_var (line 49) | int secp256k1_scalar_get_bits_var(const secp256k1_scalar *a, unsigned in...
function SECP256K1_INLINE (line 60) | SECP256K1_INLINE static int secp256k1_scalar_check_overflow(const secp25...
function SECP256K1_INLINE (line 72) | SECP256K1_INLINE static int secp256k1_scalar_reduce(secp256k1_scalar *r,...
function secp256k1_scalar_add (line 89) | static int secp256k1_scalar_add(secp256k1_scalar *r, const secp256k1_sca...
function secp256k1_scalar_cadd_bit (line 110) | static void secp256k1_scalar_cadd_bit(secp256k1_scalar *r, unsigned int ...
function secp256k1_scalar_set_b32 (line 131) | static void secp256k1_scalar_set_b32(secp256k1_scalar *r, const unsigned...
function secp256k1_scalar_get_b32 (line 143) | static void secp256k1_scalar_get_b32(unsigned char *bin, const secp256k1...
function SECP256K1_INLINE (line 150) | SECP256K1_INLINE static int secp256k1_scalar_is_zero(const secp256k1_sca...
function secp256k1_scalar_negate (line 154) | static void secp256k1_scalar_negate(secp256k1_scalar *r, const secp256k1...
function SECP256K1_INLINE (line 172) | SECP256K1_INLINE static int secp256k1_scalar_is_one(const secp256k1_scal...
function secp256k1_scalar_is_high (line 176) | static int secp256k1_scalar_is_high(const secp256k1_scalar *a) {
function secp256k1_scalar_cond_negate (line 188) | static int secp256k1_scalar_cond_negate(secp256k1_scalar *r, int flag) {
function secp256k1_scalar_reduce_512 (line 276) | static void secp256k1_scalar_reduce_512(secp256k1_scalar *r, const uint6...
function secp256k1_scalar_mul_512 (line 589) | static void secp256k1_scalar_mul_512(uint64_t l[8], const secp256k1_scal...
function secp256k1_scalar_mul (line 763) | static void secp256k1_scalar_mul(secp256k1_scalar *r, const secp256k1_sc...
function secp256k1_scalar_shr_int (line 770) | static int secp256k1_scalar_shr_int(secp256k1_scalar *r, int n) {
function secp256k1_scalar_split_128 (line 783) | static void secp256k1_scalar_split_128(secp256k1_scalar *r1, secp256k1_s...
function SECP256K1_INLINE (line 795) | SECP256K1_INLINE static int secp256k1_scalar_eq(const secp256k1_scalar *...
function SECP256K1_INLINE (line 800) | SECP256K1_INLINE static void secp256k1_scalar_mul_shift_var(secp256k1_sc...
function SECP256K1_INLINE (line 818) | static SECP256K1_INLINE void secp256k1_scalar_cmov(secp256k1_scalar *r, ...
function secp256k1_scalar_from_signed62 (line 830) | static void secp256k1_scalar_from_signed62(secp256k1_scalar *r, const se...
function secp256k1_scalar_to_signed62 (line 852) | static void secp256k1_scalar_to_signed62(secp256k1_modinv64_signed62 *r,...
function secp256k1_scalar_inverse (line 873) | static void secp256k1_scalar_inverse(secp256k1_scalar *r, const secp256k...
function secp256k1_scalar_inverse_var (line 888) | static void secp256k1_scalar_inverse_var(secp256k1_scalar *r, const secp...
function SECP256K1_INLINE (line 903) | SECP256K1_INLINE static int secp256k1_scalar_is_even(const secp256k1_sca...
FILE: C/secp256k1/scalar_impl.h
function secp256k1_scalar_set_b32_seckey (line 27) | static int secp256k1_scalar_set_b32_seckey(secp256k1_scalar *r, const un...
function secp256k1_scalar_split_lambda (line 96) | static void secp256k1_scalar_split_lambda(secp256k1_scalar * SECP256K1_R...
function secp256k1_scalar_split_lambda_verify (line 237) | static void secp256k1_scalar_split_lambda_verify(const secp256k1_scalar ...
FILE: C/secp256k1/schnorrsig_impl.h
function sha256_context (line 16) | static sha256_context secp256k1_schnorrsig_sha256_tagged(uint32_t* outpu...
function secp256k1_schnorrsig_challenge (line 28) | static void secp256k1_schnorrsig_challenge(secp256k1_scalar* e, const un...
function secp256k1_schnorrsig_verify (line 46) | static int secp256k1_schnorrsig_verify(const unsigned char *sig64, const...
FILE: C/secp256k1/secp256k1.h
type secp256k1_pubkey (line 32) | typedef struct {
FILE: C/secp256k1/secp256k1_impl.h
function secp256k1_pubkey_load (line 34) | static int secp256k1_pubkey_load(secp256k1_ge* ge, const secp256k1_pubke...
function secp256k1_pubkey_save (line 53) | static void secp256k1_pubkey_save(secp256k1_pubkey* pubkey, secp256k1_ge...
function secp256k1_ec_pubkey_tweak_add_helper (line 67) | static int secp256k1_ec_pubkey_tweak_add_helper(secp256k1_ge *p, const u...
FILE: C/secp256k1/util.h
function SECP256K1_INLINE (line 76) | static SECP256K1_INLINE int secp256k1_memcmp_var(const void *s1, const v...
function SECP256K1_INLINE (line 129) | static SECP256K1_INLINE int secp256k1_ctz64_var_debruijn(uint64_t x) {
function SECP256K1_INLINE (line 140) | static SECP256K1_INLINE int secp256k1_ctz64_var(uint64_t x) {
FILE: C/sha256.c
function Ch (line 16) | static inline uint32_t Ch(uint32_t x, uint32_t y, uint32_t z) { return z...
function Maj (line 17) | static inline uint32_t Maj(uint32_t x, uint32_t y, uint32_t z) { return ...
function Sigma0 (line 18) | static inline uint32_t Sigma0(uint32_t x) { return (x >> 2 | 1U * x << 3...
function Sigma1 (line 19) | static inline uint32_t Sigma1(uint32_t x) { return (x >> 6 | 1U * x << 2...
function sigma0 (line 20) | static inline uint32_t sigma0(uint32_t x) { return (x >> 7 | 1U * x << 2...
function sigma1 (line 21) | static inline uint32_t sigma1(uint32_t x) { return (x >> 17 | 1U * x << ...
function Round (line 29) | static inline void Round(uint32_t a, uint32_t b, uint32_t c, uint32_t* d...
function sha256_compression_portable (line 41) | static void sha256_compression_portable(uint32_t* s, const uint32_t* chu...
function simplicity_sha256_compression_is_optimized (line 129) | bool simplicity_sha256_compression_is_optimized(void) {
function sha256_end (line 140) | static void sha256_end(uint32_t* h, uint32_t* block, const uint_fast64_t...
function simplicity_sha256_bitstring (line 157) | void simplicity_sha256_bitstring(uint32_t* h, const bitstring* s) {
FILE: C/sha256.h
type sha256_midstate (line 11) | typedef struct sha256_midstate {
function uint_fast64_t (line 19) | static inline uint_fast64_t ReadBE64(const unsigned char* b) {
function ReadBE32 (line 34) | static inline uint32_t ReadBE32(const unsigned char* b) {
function WriteBE64 (line 45) | static inline void WriteBE64(unsigned char* ptr, uint_fast64_t x) {
function WriteBE32 (line 60) | static inline void WriteBE32(unsigned char* ptr, uint_fast32_t x) {
function WriteLE32 (line 71) | static inline void WriteLE32(unsigned char* ptr, uint_fast32_t x) {
function sha256_fromMidstate (line 83) | static inline void sha256_fromMidstate(unsigned char* hash, const uint32...
function sha256_toMidstate (line 99) | static inline void sha256_toMidstate(uint32_t* midstate, const unsigned ...
function sha256_iv (line 114) | static inline void sha256_iv(uint32_t* iv) {
function sha256_compression_uchar (line 150) | static void sha256_compression_uchar(uint32_t* s, const unsigned char* c...
type sha256_context (line 182) | typedef struct sha256_context {
function sha256_context (line 200) | static inline sha256_context sha256_init(uint32_t* output) {
function sha256_context (line 212) | static inline sha256_context sha256_tagged_init(uint32_t* output, const ...
function sha256_uchars (line 223) | static inline bool sha256_uchars(sha256_context* ctx, const unsigned cha...
function sha256_uchar (line 248) | static inline bool sha256_uchar(sha256_context* ctx, unsigned char x) {
function sha256_u64be (line 259) | static inline bool sha256_u64be(sha256_context* ctx, uint_fast64_t x) {
function sha256_u32le (line 273) | static inline bool sha256_u32le(sha256_context* ctx, uint_fast32_t x) {
function sha256_u32be (line 287) | static inline bool sha256_u32be(sha256_context* ctx, uint_fast32_t x) {
function sha256_finalize (line 300) | static inline bool sha256_finalize(sha256_context* ctx) {
function sha256_hash (line 313) | static inline void sha256_hash(sha256_context* ctx, const sha256_midstat...
function sha256_cmp_be (line 324) | static inline int sha256_cmp_be(const sha256_midstate* a, const sha256_m...
FILE: C/test.c
function fprint_cmr (line 44) | static void fprint_cmr(FILE* stream, const uint32_t* cmr) {
function test_decodeUptoMaxInt (line 50) | static void test_decodeUptoMaxInt(void) {
function test_hashBlock (line 74) | static void test_hashBlock(void) {
function test_program (line 189) | static void test_program(char* name, const unsigned char* program, size_...
function test_occursCheck (line 325) | static void test_occursCheck(void) {
function test_elements (line 354) | static void test_elements(void) {
function sha256_midstate (line 514) | static sha256_midstate hashint(uint_fast32_t n) {
function sha256_midstate (line 523) | static sha256_midstate rsort_no_duplicates(uint_fast32_t i) {
function sha256_midstate (line 527) | static sha256_midstate rsort_all_duplicates(uint_fast32_t i) {
function sha256_midstate (line 532) | static sha256_midstate rsort_one_duplicate(uint_fast32_t i) {
function sha256_midstate (line 537) | static sha256_midstate rsort_diagonal(uint_fast32_t i) {
function test_hasDuplicates (line 546) | static void test_hasDuplicates(const char* name, int expected, sha256_mi...
function regression_tests (line 569) | static void regression_tests(void) {
function iden8mebi_test (line 618) | static void iden8mebi_test(void) {
function exactBudget_test (line 640) | static void exactBudget_test(void) {
function main (line 718) | int main(int argc, char **argv) {
FILE: C/type.c
function sha256_midstate (line 11) | static sha256_midstate tmrIV(typeName kind) {
function simplicity_computeTypeAnalyses (line 35) | void simplicity_computeTypeAnalyses(type* type_dag, const size_t len) {
FILE: C/type.h
type typeName (line 10) | typedef enum typeName
type type (line 20) | typedef struct type {
function typeSkip (line 78) | static inline size_t typeSkip(size_t i, const type* type_dag) {
function setTypeBack (line 91) | static inline void setTypeBack(size_t i, type* type_dag, size_t value) {
FILE: C/typeInference.c
type unification_arrow (line 13) | typedef struct unification_arrow {
function unification_var (line 25) | static unification_var* findRoot(unification_var* alpha) {
function applyBinding_cont (line 68) | static bool applyBinding_cont(unification_var* alpha, binding* bound, un...
function unification_var (line 124) | static unification_var* unify_cont(unification_cont* cont, size_t* bindi...
function applyBinding (line 197) | static bool applyBinding(unification_var* alpha, binding* bound, size_t*...
function unification_var (line 217) | static unification_var* unify(unification_var* alpha, unification_var* b...
function max_extra_vars (line 227) | static size_t max_extra_vars(const combinator_counters* census) {
function simplicity_err (line 267) | static simplicity_err typeInference( unification_arrow* arrow, const dag...
function isFrozen (line 402) | static bool isFrozen(unification_var* var) {
function getFrozenIx (line 413) | static size_t getFrozenIx(unification_var* var) {
function freeze (line 436) | static bool freeze(size_t* result, type* type_dag, size_t* type_dag_used...
function simplicity_err (line 524) | static simplicity_err freezeTypes(type* type_dag, dag_node* dag, unifica...
function simplicity_err (line 561) | simplicity_err simplicity_mallocTypeInference(type** type_dag, simplicit...
FILE: C/typeInference.h
type unification_cont (line 9) | typedef struct unification_cont unification_cont;
type unification_var (line 10) | typedef struct unification_var unification_var;
type unification_cont (line 15) | struct unification_cont {
type binding (line 39) | typedef union binding {
type unification_var (line 64) | struct unification_var {
FILE: C/uword.h
function UWORD (line 44) | static inline UWORD LSBclear(UWORD x, size_t n) {
function UWORD (line 51) | static inline UWORD LSBkeep(UWORD x, size_t n) {
FILE: Haskell/cbits/bitcoin/env.c
function c_set_rawBitcoinBuffer (line 12) | void c_set_rawBitcoinBuffer(rawBitcoinBuffer* result, const char* buf, u...
function c_set_rawBitcoinOutput (line 16) | void c_set_rawBitcoinOutput(rawBitcoinOutput* result, unsigned long valu...
function c_set_rawBitcoinInput (line 22) | void c_set_rawBitcoinInput(rawBitcoinInput* result, const rawBitcoinBuff...
function c_set_rawBitcoinTransaction (line 35) | void c_set_rawBitcoinTransaction(rawBitcoinTransaction* result, const un...
function c_set_rawBitcoinTapEnv (line 47) | void c_set_rawBitcoinTapEnv(rawBitcoinTapEnv* result, const char* contro...
function c_bitcoin_set_txEnv (line 51) | void c_bitcoin_set_txEnv(txEnv* result, const bitcoinTransaction* tx, co...
FILE: Haskell/cbits/bitstream.c
function c_initializeBitstream (line 5) | void c_initializeBitstream(bitstream *result, const unsigned char* arr, ...
FILE: Haskell/cbits/dag.c
function c_compute_word_cmr (line 7) | void c_compute_word_cmr(unsigned char *cmr, bitstream* stream, size_t of...
function c_dag_node_get_cmr (line 16) | void c_dag_node_get_cmr(unsigned char *cmr, const dag_node* node) {
FILE: Haskell/cbits/elements/env.c
function c_set_rawElementsBuffer (line 12) | void c_set_rawElementsBuffer(rawElementsBuffer* result, const char* buf,...
function c_set_rawElementsOutput (line 16) | void c_set_rawElementsOutput(rawElementsOutput* result, const char* asse...
function c_set_rawElementsInput (line 26) | void c_set_rawElementsInput(rawElementsInput* result, const rawElementsB...
function c_set_rawElementsTransaction (line 49) | void c_set_rawElementsTransaction(rawElementsTransaction* result, const ...
function c_set_rawElementsTapEnv (line 61) | void c_set_rawElementsTapEnv(rawElementsTapEnv* result, const char* cont...
function c_set_txEnv (line 65) | void c_set_txEnv(txEnv* result, const elementsTransaction* tx, const ele...
FILE: Haskell/cbits/frame.c
function c_initReadFrame (line 6) | void c_initReadFrame(frameItem* frame, size_t n, UWORD* from) {
function c_initWriteFrame (line 10) | void c_initWriteFrame(frameItem* frame, size_t n, UWORD* from) {
function c_readBit (line 14) | bool c_readBit(frameItem* frame) {
function c_writeBit (line 18) | void c_writeBit(frameItem* frame, bool bit) {
function c_forwardBits (line 22) | void c_forwardBits(frameItem* frame, size_t n) {
function c_skipBits (line 26) | void c_skipBits(frameItem* frame, size_t n) {
FILE: alectryon/alectryon.js
function anchor (line 4) | function anchor(sentence) { return "#" + sentence.id; }
function current_sentence (line 6) | function current_sentence() { return slideshow.sentences[slideshow.pos]; }
function unhighlight (line 8) | function unhighlight() {
function highlight (line 14) | function highlight(sentence) {
function scroll (line 18) | function scroll(sentence) {
function highlighted (line 54) | function highlighted(pos) {
function navigate (line 58) | function navigate(pos, inhibitScroll) {
function onkeydown (line 75) | function onkeydown(e) {
function start (line 95) | function start() {
function toggleHighlight (line 99) | function toggleHighlight(idx) {
function handleClick (line 106) | function handleClick(evt) {
function init (line 120) | function init() {
function className (line 141) | function className(style) {
function setStyle (line 145) | function setStyle(style) {
function init (line 152) | function init() {
Copy disabled (too large)
Download .json
Condensed preview — 307 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (15,739K chars).
[
{
"path": ".github/workflows/ci.yml",
"chars": 938,
"preview": "name: CI\n\non: [push, pull_request]\n\njobs:\n codespell:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/check"
},
{
"path": ".gitignore",
"chars": 339,
"preview": "# Tech report\nSimplicity-TR.pdf\n*.eps\n# Haskell\n/Haskell/*.pdf\ndist-newstyle\ncabal.project.local\n# Nix\nresult\nresult-doc"
},
{
"path": "C/Makefile",
"chars": 1859,
"preview": "CORE_OBJS := bitstream.o dag.o deserialize.o eval.o frame.o jets.o jets-secp256k1.o rsort.o sha256.o type.o typeInferenc"
},
{
"path": "C/bitcoin/bitcoinJets.c",
"chars": 19654,
"preview": "#include \"bitcoinJets.h\"\n\n#include \"ops.h\"\n#include \"txEnv.h\"\n#include \"../taptweak.h\"\n#include \"../simplicity_assert.h\""
},
{
"path": "C/bitcoin/bitcoinJets.h",
"chars": 5656,
"preview": "/* This module defines primitives and jets that are specific to the Bitcoin application for Simplicity.\n */\n#ifndef SIMP"
},
{
"path": "C/bitcoin/decodeBitcoinJets.inc",
"chars": 4919,
"preview": "/* This file has been automatically generated. */\n\n{\n int32_t code;\n code = simplicity_decodeUptoMaxInt(stream);\n if "
},
{
"path": "C/bitcoin/env.c",
"chars": 9925,
"preview": "#include <simplicity/bitcoin/env.h>\n\n#include <stdalign.h>\n#include <stddef.h>\n#include <string.h>\n#include \"txEnv.h\"\n#i"
},
{
"path": "C/bitcoin/ops.c",
"chars": 1688,
"preview": "#include \"ops.h\"\n\n/* Compute Bitcoins's tapleaf hash from a tapleaf version and a 256-bit script value.\n * A reimplement"
},
{
"path": "C/bitcoin/ops.h",
"chars": 817,
"preview": "/* This module defines operations used in the construction the environment ('txEnv') and some jets.\n */\n#ifndef SIMPLICI"
},
{
"path": "C/bitcoin/primitive.c",
"chars": 4719,
"preview": "/* This module implements the 'primitive.h' interface for the Bitcoin application of Simplicity.\n */\n#include \"primitive"
},
{
"path": "C/bitcoin/primitive.h",
"chars": 2047,
"preview": "/* Implements the primitive.h interface for the Bitcoin Simplicity application.\n */\n#ifndef SIMPLICITY_BITCOIN_PRIMITIVE"
},
{
"path": "C/bitcoin/primitiveEnumJet.inc",
"chars": 6533,
"preview": "/* This file has been automatically generated. */\nADD_16,\nADD_32,\nADD_64,\nADD_8,\nALL_16,\nALL_32,\nALL_64,\nALL_8,\nAND_1,\nA"
},
{
"path": "C/bitcoin/primitiveEnumTy.inc",
"chars": 2418,
"preview": "/* This file has been automatically generated. */\nty_u = 0,\nty_b = 1,\nty_w2 = 2,\nty_w4 = 3,\nty_w8 = 4,\nty_w16 = 5,\nty_w3"
},
{
"path": "C/bitcoin/primitiveInitTy.inc",
"chars": 20916,
"preview": "/* This file has been automatically generated. */\n(*bound_var)[ty_u] = (unification_var){ .isBound = true, .bound = { .k"
},
{
"path": "C/bitcoin/primitiveJetNode.inc",
"chars": 115437,
"preview": "/* This file has been automatically generated. */\n[ADD_16] =\n{ .tag = JET\n, .jet = simplicity_add_16\n, .cmr = {{0x49425a"
},
{
"path": "C/bitcoin/txEnv.c",
"chars": 664,
"preview": "#include \"txEnv.h\"\n\n/* Construct a txEnv structure from its components.\n * This function will precompute any cached valu"
},
{
"path": "C/bitcoin/txEnv.h",
"chars": 3364,
"preview": "/* This module defines the environment ('txEnv') for Simplicity evaluation for Bitcoin.\n * It includes the transaction d"
},
{
"path": "C/bitstream.c",
"chars": 9441,
"preview": "#include \"bitstream.h\"\n\n#include <limits.h>\n#include \"simplicity_assert.h\"\n\n/* Closes a bitstream by consuming all remai"
},
{
"path": "C/bitstream.h",
"chars": 3085,
"preview": "/* This module provides functions for initializing and reading from a stream of bits from a 'FILE'. */\n#ifndef SIMPLICIT"
},
{
"path": "C/bitstring.h",
"chars": 1922,
"preview": "/* This modules defines a structure representing bit strings. */\n#ifndef SIMPLICITY_BITSTRING_H\n#define SIMPLICITY_BITST"
},
{
"path": "C/bounded.h",
"chars": 867,
"preview": "#ifndef SIMPLICITY_BOUNDED_H\n#define SIMPLICITY_BOUNDED_H\n\n#include <stdbool.h>\n#include <stdint.h>\n\ntypedef uint_least3"
},
{
"path": "C/ctx8Pruned.c",
"chars": 31920,
"preview": "#include \"ctx8Pruned.h\"\n\n/* A length-prefixed encoding of the following Simplicity program:\n * (scribe (toWord256 0x"
},
{
"path": "C/ctx8Pruned.h",
"chars": 1111,
"preview": "#ifndef SIMPLICITY_CTX8PRUNED_H\n#define SIMPLICITY_CTX8PRUNED_H\n\n#include <stddef.h>\n#include <stdint.h>\n#include \"bound"
},
{
"path": "C/ctx8Unpruned.c",
"chars": 30695,
"preview": "#include \"ctx8Unpruned.h\"\n\n/* A length-prefixed encoding of the following Simplicity program:\n * (scribe (toWord256 "
},
{
"path": "C/ctx8Unpruned.h",
"chars": 1139,
"preview": "#ifndef SIMPLICITY_CTX8UNPRUNED_H\n#define SIMPLICITY_CTX8UNPRUNED_H\n\n#include <stddef.h>\n#include <stdint.h>\n#include \"b"
},
{
"path": "C/dag.c",
"chars": 24474,
"preview": "#include \"dag.h\"\n\n#include <stdbool.h>\n#include \"bounded.h\"\n#include \"precomputed.h\"\n#include \"rsort.h\"\n#include \"sha256"
},
{
"path": "C/dag.h",
"chars": 14324,
"preview": "/* This module defines the structure for Simplicity DAGs, and functions for some analysis of that structure,\n * such as "
},
{
"path": "C/decodeCoreJets.inc",
"chars": 48039,
"preview": "/* This file has been automatically generated. */\n\n{\n int32_t code;\n code = simplicity_decodeUptoMaxInt(stream);\n if "
},
{
"path": "C/deserialize.c",
"chars": 9470,
"preview": "#include \"deserialize.h\"\n\n#include <limits.h>\n#include \"limitations.h\"\n#include \"simplicity_alloc.h\"\n#include \"simplicit"
},
{
"path": "C/deserialize.h",
"chars": 2524,
"preview": "/* This module provides functions for deserializing Simplicity's bit-wise prefix coding. */\n#ifndef SIMPLICITY_DESERIALI"
},
{
"path": "C/elements/checkSigHashAllTx1.c",
"chars": 2441,
"preview": "#include \"checkSigHashAllTx1.h\"\n\n/* A length-prefixed encoding of the following Simplicity program:\n * Simplicity.Pr"
},
{
"path": "C/elements/checkSigHashAllTx1.h",
"chars": 1551,
"preview": "#ifndef SIMPLICITY_ELEMENTS_CHECKSIGHASHALLTX1_H\n#define SIMPLICITY_ELEMENTS_CHECKSIGHASHALLTX1_H\n\n#include <stddef.h>\n#"
},
{
"path": "C/elements/cmr.c",
"chars": 1695,
"preview": "#include <simplicity/elements/cmr.h>\n\n#include \"../deserialize.h\"\n#include \"../limitations.h\"\n#include \"../simplicity_al"
},
{
"path": "C/elements/decodeElementsJets.inc",
"chars": 8450,
"preview": "/* This file has been automatically generated. */\n\n{\n int32_t code;\n code = simplicity_decodeUptoMaxInt(stream);\n if "
},
{
"path": "C/elements/elementsJets.c",
"chars": 45128,
"preview": "#include \"elementsJets.h\"\n\n#include \"ops.h\"\n#include \"txEnv.h\"\n#include \"../taptweak.h\"\n#include \"../simplicity_assert.h"
},
{
"path": "C/elements/elementsJets.h",
"chars": 8998,
"preview": "/* This module defines primitives and jets that are specific to the Elements application for Simplicity.\n */\n#ifndef SIM"
},
{
"path": "C/elements/env.c",
"chars": 30016,
"preview": "#include <simplicity/elements/env.h>\n\n#include <stdalign.h>\n#include <stddef.h>\n#include <string.h>\n#include \"txEnv.h\"\n#"
},
{
"path": "C/elements/exec.c",
"chars": 6745,
"preview": "#include <simplicity/elements/exec.h>\n\n#include <stdalign.h>\n#include <string.h>\n#include \"primitive.h\"\n#include \"txEnv."
},
{
"path": "C/elements/ops.c",
"chars": 5734,
"preview": "#include \"ops.h\"\n\n/* Add an 'confidential' value to be consumed by an ongoing SHA-256 evaluation.\n * If the 'confidentia"
},
{
"path": "C/elements/ops.h",
"chars": 3001,
"preview": "/* This module defines operations used in the construction the environment ('txEnv') and some jets.\n */\n#ifndef SIMPLICI"
},
{
"path": "C/elements/primitive.c",
"chars": 4630,
"preview": "#include \"primitive.h\"\n\n#include \"elementsJets.h\"\n#include \"../limitations.h\"\n#include \"../simplicity_alloc.h\"\n#include "
},
{
"path": "C/elements/primitive.h",
"chars": 2051,
"preview": "/* Implements the required callbacks for the Elements Simplicity application.\n */\n#ifndef SIMPLICITY_ELEMENTS_PRIMITIVE_"
},
{
"path": "C/elements/primitiveEnumJet.inc",
"chars": 7554,
"preview": "/* This file has been automatically generated. */\nADD_16,\nADD_32,\nADD_64,\nADD_8,\nALL_16,\nALL_32,\nALL_64,\nALL_8,\nAND_1,\nA"
},
{
"path": "C/elements/primitiveEnumTy.inc",
"chars": 2829,
"preview": "/* This file has been automatically generated. */\nty_u = 0,\nty_b = 1,\nty_w2 = 2,\nty_w4 = 3,\nty_w8 = 4,\nty_w16 = 5,\nty_w3"
},
{
"path": "C/elements/primitiveInitTy.inc",
"chars": 24108,
"preview": "/* This file has been automatically generated. */\n(*bound_var)[ty_u] = (unification_var){ .isBound = true, .bound = { .k"
},
{
"path": "C/elements/primitiveJetNode.inc",
"chars": 127514,
"preview": "/* This file has been automatically generated. */\n[ADD_16] =\n{ .tag = JET\n, .jet = simplicity_add_16\n, .cmr = {{0x26ae09"
},
{
"path": "C/elements/txEnv.c",
"chars": 855,
"preview": "#include \"txEnv.h\"\n\n/* Construct a txEnv structure from its components.\n * This function will precompute any cached valu"
},
{
"path": "C/elements/txEnv.h",
"chars": 9446,
"preview": "/* This module defines the environment ('txEnv') for Simplicity evaluation for Elements.\n * It includes the transaction "
},
{
"path": "C/elements-sources.mk",
"chars": 6160,
"preview": "# - All Variables ending in _HEADERS or _SOURCES confuse automake, so the\n# _INT postfix is applied.\n# - The %reldir"
},
{
"path": "C/eval.c",
"chars": 44605,
"preview": "#include \"eval.h\"\n\n#include <string.h>\n#include \"bounded.h\"\n#include \"limitations.h\"\n#include \"simplicity_alloc.h\"\n#incl"
},
{
"path": "C/eval.h",
"chars": 6665,
"preview": "/* This module provides functions for evaluating Simplicity programs and expressions.\n */\n#ifndef SIMPLICITY_EVAL_H\n#def"
},
{
"path": "C/frame.c",
"chars": 17205,
"preview": "#include \"frame.h\"\n\n#define READ_(bits,size) \\\n/* Given a read frame,"
},
{
"path": "C/frame.h",
"chars": 8707,
"preview": "/* This module provides functions writing initial data to and reading results from the frame used during evaluation\n * o"
},
{
"path": "C/hashBlock.c",
"chars": 20965,
"preview": "#include \"hashBlock.h\"\n\n/* A length-prefixed encoding of the following Simplicity program:\n * hashBlock\n */\nconst un"
},
{
"path": "C/hashBlock.h",
"chars": 874,
"preview": "#ifndef SIMPLICITY_HASHBLOCK_H\n#define SIMPLICITY_HASHBLOCK_H\n\n#include <stddef.h>\n#include <stdint.h>\n#include \"bounded"
},
{
"path": "C/include/simplicity/bitcoin/env.h",
"chars": 3568,
"preview": "#ifndef SIMPLICITY_BITCOIN_ENV_H\n#define SIMPLICITY_BITCOIN_ENV_H\n\n#include <stdbool.h>\n#include <stdint.h>\n\n/* This sec"
},
{
"path": "C/include/simplicity/elements/cmr.h",
"chars": 986,
"preview": "#ifndef SIMPLICITY_ELEMENTS_CMR_H\n#define SIMPLICITY_ELEMENTS_CMR_H\n\n#include <stdbool.h>\n#include <stddef.h>\n#include <"
},
{
"path": "C/include/simplicity/elements/env.h",
"chars": 5034,
"preview": "#ifndef SIMPLICITY_ELEMENTS_ENV_H\n#define SIMPLICITY_ELEMENTS_ENV_H\n\n#include <stdbool.h>\n#include <stdint.h>\n\n/* This s"
},
{
"path": "C/include/simplicity/elements/exec.h",
"chars": 2916,
"preview": "#ifndef SIMPLICITY_ELEMENTS_EXEC_H\n#define SIMPLICITY_ELEMENTS_EXEC_H\n\n#include <stdbool.h>\n#include <stdint.h>\n#include"
},
{
"path": "C/include/simplicity/errorCodes.h",
"chars": 4183,
"preview": "/* This module defines some constants used for error codes when processing Simplicity.\n * Errors can either indicate a t"
},
{
"path": "C/jets-secp256k1.c",
"chars": 20036,
"preview": "#include \"jets.h\"\n#include \"taptweak.h\"\n\n#include \"precomputed.h\"\n#include \"sha256.h\"\n#include \"secp256k1/secp256k1_impl"
},
{
"path": "C/jets.c",
"chars": 66903,
"preview": "#include \"jets.h\"\n#include \"secp256k1/secp256k1.h\"\n#include \"secp256k1/util.h\"\n#ifdef SECP256K1_WIDEMUL_INT128\n# include"
},
{
"path": "C/jets.h",
"chars": 30741,
"preview": "/* This module defines jets that simulate various Simplicity expressions.\n * Their specifications are given by the speci"
},
{
"path": "C/limitations.h",
"chars": 611,
"preview": "#ifndef SIMPLICITY_LIMITATIONS_H\n#define SIMPLICITY_LIMITATIONS_H\n\n#include <stdint.h>\n\n#define DAG_LEN_MAX 8000000U\n#de"
},
{
"path": "C/precomputed.h",
"chars": 40767,
"preview": "/* This file has been automatically generated by GenPecomputed.hs */\n#ifndef SIMPLICITY_PRECOMPUTED_H\n#define SIMPLICITY"
},
{
"path": "C/regression4.c",
"chars": 1118932,
"preview": "#include \"regression4.h\"\n\n/* A length-prefixed encoding of the following Simplicity program:\n * uWitness OneV : f 15"
},
{
"path": "C/regression4.h",
"chars": 501,
"preview": "#ifndef SIMPLICITY_REGRESSION4_H\n#define SIMPLICITY_REGRESSION4_H\n\n#include <stddef.h>\n#include <stdint.h>\n#include \"bou"
},
{
"path": "C/rsort.c",
"chars": 12961,
"preview": "#include \"rsort.h\"\n\n#include <string.h>\n\n#include \"simplicity_assert.h\"\n#include \"simplicity_alloc.h\"\n\nstatic_assert(UCH"
},
{
"path": "C/rsort.h",
"chars": 1247,
"preview": "#ifndef SIMPLICITY_RSORT_H\n#define SIMPLICITY_RSORT_H\n\n#include <limits.h>\n#include <stdbool.h>\n#include <stdint.h>\n\n#in"
},
{
"path": "C/schnorr0.c",
"chars": 2265,
"preview": "#include \"schnorr0.h\"\n\n/* A length-prefixed encoding of the following Simplicity program:\n * (scribe (toWord256 0xF9"
},
{
"path": "C/schnorr0.h",
"chars": 1204,
"preview": "#ifndef SIMPLICITY_SCHNORR0_H\n#define SIMPLICITY_SCHNORR0_H\n\n#include <stddef.h>\n#include <stdint.h>\n#include \"bounded.h"
},
{
"path": "C/schnorr6.c",
"chars": 2338,
"preview": "#include \"schnorr6.h\"\n\n/* A length-prefixed encoding of the following Simplicity program:\n * (scribe (toWord256 0xDF"
},
{
"path": "C/schnorr6.h",
"chars": 1277,
"preview": "#ifndef SIMPLICITY_SCHNORR6_H\n#define SIMPLICITY_SCHNORR6_H\n\n#include <stddef.h>\n#include <stdint.h>\n#include \"bounded.h"
},
{
"path": "C/secp256k1/README.md",
"chars": 5245,
"preview": "This directory contains a modified copy of the libsecp256k1 at `bdf39000b9c6a0818e7149ccb500873d079e6e85` from <https://"
},
{
"path": "C/secp256k1/assumptions.h",
"chars": 4435,
"preview": "/***********************************************************************\n * Copyright (c) 2020 Pieter Wuille "
},
{
"path": "C/secp256k1/eckey.h",
"chars": 1189,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/eckey_impl.h",
"chars": 3410,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/ecmult.h",
"chars": 1790,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014, 2017 Pieter Wuille"
},
{
"path": "C/secp256k1/ecmult_impl.h",
"chars": 34274,
"preview": "/******************************************************************************\n * Copyright (c) 2013, 2014, 2017 Pieter"
},
{
"path": "C/secp256k1/extrakeys.h",
"chars": 3969,
"preview": "#ifndef SECP256K1_EXTRAKEYS_H\n#define SECP256K1_EXTRAKEYS_H\n\n#include \"secp256k1.h\"\n\n/** Opaque data structure that hold"
},
{
"path": "C/secp256k1/extrakeys_impl.h",
"chars": 3260,
"preview": "/***********************************************************************\n * Copyright (c) 2020 Jonas Nick "
},
{
"path": "C/secp256k1/field.h",
"chars": 7257,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/field_5x52.h",
"chars": 2030,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/field_5x52_asm_impl.h",
"chars": 13167,
"preview": "/***********************************************************************\n * Copyright (c) 2013-2014 Diederik Huys, Piete"
},
{
"path": "C/secp256k1/field_5x52_impl.h",
"chars": 23265,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/field_5x52_int128_impl.h",
"chars": 11437,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/field_impl.h",
"chars": 3850,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/generator.h",
"chars": 1321,
"preview": "#ifndef SECP256K1_GENERATOR_H\n# define SECP256K1_GENERATOR_H\n\n# include \"secp256k1.h\"\n\n#include <stdint.h>\n\n/** Opaque d"
},
{
"path": "C/secp256k1/generator_impl.h",
"chars": 17164,
"preview": "/**********************************************************************\n * Copyright (c) 2016 Andrew Poelstra & Pieter W"
},
{
"path": "C/secp256k1/group.h",
"chars": 9437,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/group_impl.h",
"chars": 26541,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/int128.h",
"chars": 3622,
"preview": "#ifndef SECP256K1_INT128_H\n#define SECP256K1_INT128_H\n\n#include \"util.h\"\n\n#if defined(SECP256K1_WIDEMUL_INT128)\n# if de"
},
{
"path": "C/secp256k1/int128_impl.h",
"chars": 376,
"preview": "#ifndef SECP256K1_INT128_IMPL_H\n#define SECP256K1_INT128_IMPL_H\n\n#include \"util.h\"\n\n#include \"int128.h\"\n\n#if defined(SEC"
},
{
"path": "C/secp256k1/int128_native.h",
"chars": 581,
"preview": "#ifndef SECP256K1_INT128_NATIVE_H\n#define SECP256K1_INT128_NATIVE_H\n\n#include <stdint.h>\n#include \"util.h\"\n\n#if !defined"
},
{
"path": "C/secp256k1/int128_native_impl.h",
"chars": 2891,
"preview": "#ifndef SECP256K1_INT128_NATIVE_IMPL_H\n#define SECP256K1_INT128_NATIVE_IMPL_H\n\n#include \"int128.h\"\n\nstatic SECP256K1_INL"
},
{
"path": "C/secp256k1/int128_struct.h",
"chars": 247,
"preview": "#ifndef SECP256K1_INT128_STRUCT_H\n#define SECP256K1_INT128_STRUCT_H\n\n#include <stdint.h>\n#include \"util.h\"\n\ntypedef stru"
},
{
"path": "C/secp256k1/int128_struct_impl.h",
"chars": 7842,
"preview": "#ifndef SECP256K1_INT128_STRUCT_IMPL_H\n#define SECP256K1_INT128_STRUCT_IMPL_H\n\n#include \"int128.h\"\n\n#if defined(_MSC_VER"
},
{
"path": "C/secp256k1/modinv64.h",
"chars": 2334,
"preview": "/***********************************************************************\n * Copyright (c) 2020 Peter Dettman "
},
{
"path": "C/secp256k1/modinv64_impl.h",
"chars": 38180,
"preview": "/***********************************************************************\n * Copyright (c) 2020 Peter Dettman "
},
{
"path": "C/secp256k1/precomputed_ecmult.h",
"chars": 2409377,
"preview": "#ifndef SECP256K1_PRECOMPUTED_ECMULT_H\n#define SECP256K1_PRECOMPUTED_ECMULT_H\n\n/* This file was automatically generated "
},
{
"path": "C/secp256k1/scalar.h",
"chars": 5091,
"preview": "/***********************************************************************\n * Copyright (c) 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/scalar_4x64.h",
"chars": 801,
"preview": "/***********************************************************************\n * Copyright (c) 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/scalar_4x64_impl.h",
"chars": 30606,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/scalar_impl.h",
"chars": 10225,
"preview": "/***********************************************************************\n * Copyright (c) 2014 Pieter Wuille "
},
{
"path": "C/secp256k1/schnorrsig.h",
"chars": 974,
"preview": "#ifndef SECP256K1_SCHNORRSIG_H\n#define SECP256K1_SCHNORRSIG_H\n\n#include \"secp256k1.h\"\n#include \"extrakeys.h\"\n\n/** This m"
},
{
"path": "C/secp256k1/schnorrsig_impl.h",
"chars": 2931,
"preview": "/***********************************************************************\n * Copyright (c) 2018-2020 Andrew Poelstra, Jon"
},
{
"path": "C/secp256k1/secp256k1.h",
"chars": 2366,
"preview": "#ifndef SECP256K1_H\n#define SECP256K1_H\n\n#include <stddef.h>\n\n/** Unless explicitly stated all pointer arguments must no"
},
{
"path": "C/secp256k1/secp256k1_impl.h",
"chars": 2583,
"preview": "/***********************************************************************\n * Copyright (c) 2013-2015 Pieter Wuille "
},
{
"path": "C/secp256k1/util.h",
"chars": 5388,
"preview": "/***********************************************************************\n * Copyright (c) 2013, 2014 Pieter Wuille "
},
{
"path": "C/sha256.c",
"chars": 11607,
"preview": "/* Parts translated from Bitcoin Core's C++ project:\n * src/crypto/sha256.cpp commit eb7daf4d600eeb631427c018a984a77a34a"
},
{
"path": "C/sha256.h",
"chars": 11364,
"preview": "#ifndef SIMPLICITY_SHA256_H\n#define SIMPLICITY_SHA256_H\n\n#include <stdbool.h>\n#include <stdint.h>\n#include <string.h>\n#i"
},
{
"path": "C/sha256_x86.inc",
"chars": 7572,
"preview": "#if defined(__SHA__) && defined(__SSE4_1__) && (defined(__x86_64__) || defined(__amd64__) || defined(__i386__))\n\n#includ"
},
{
"path": "C/simplicity_alloc.h",
"chars": 372,
"preview": "#ifndef SIMPLICITY_SIMPLICITY_ALLOC_H\n#define SIMPLICITY_SIMPLICITY_ALLOC_H\n\n#include <stdlib.h>\n\n/* Allocate with mallo"
},
{
"path": "C/simplicity_assert.h",
"chars": 1316,
"preview": "#ifndef SIMPLICITY_SIMPLICITY_ASSERT_H\n#define SIMPLICITY_SIMPLICITY_ASSERT_H\n\n#include <assert.h>\n\n/* Disable NDEBUG mo"
},
{
"path": "C/taptweak.h",
"chars": 485,
"preview": "#ifndef SIMPLICITY_TAPTWEAK_H\n#define SIMPLICITY_TAPTWEAK_H\n\n#include \"frame.h\"\n\n/* This is a generic taptweak jet imple"
},
{
"path": "C/test.c",
"chars": 33122,
"preview": "#include <inttypes.h>\n#include <limits.h>\n#include <stdlib.h>\n#include <string.h>\n#include <time.h>\n#include <getopt.h>\n"
},
{
"path": "C/type.c",
"chars": 2600,
"preview": "#include \"type.h\"\n\n#include <stdbool.h>\n\n#include \"precomputed.h\"\n#include \"simplicity_assert.h\"\n\n/* Given a the 'kind' "
},
{
"path": "C/type.h",
"chars": 3800,
"preview": "/* This module defines the structure for Simplicity type DAGs and computes type Merkle roots. */\n#ifndef SIMPLICITY_TYPE"
},
{
"path": "C/typeInference.c",
"chars": 29244,
"preview": "#include \"typeInference.h\"\n\n#include <stdbool.h>\n#include \"bounded.h\"\n#include \"limitations.h\"\n#include \"simplicity_allo"
},
{
"path": "C/typeInference.h",
"chars": 5877,
"preview": "/* This module provides function for running monomorphic type inference over Simplicity DAGs. */\n#ifndef SIMPLICITY_TYPE"
},
{
"path": "C/typeSkipTest.c",
"chars": 2916,
"preview": "#include \"typeSkipTest.h\"\n\n/* A length-prefixed encoding of the following Simplicity program:\n * witness (runIdentit"
},
{
"path": "C/typeSkipTest.h",
"chars": 1693,
"preview": "#ifndef SIMPLICITY_TYPESKIPTEST_H\n#define SIMPLICITY_TYPESKIPTEST_H\n\n#include <stddef.h>\n#include <stdint.h>\n#include \"b"
},
{
"path": "C/uword.h",
"chars": 1969,
"preview": "#ifndef SIMPLICITY_UWORD_H\n#define SIMPLICITY_UWORD_H\n\n#include <limits.h>\n#include <stddef.h>\n#include <stdint.h>\n\n/* N"
},
{
"path": "Coq/C/divstep.v",
"chars": 31853,
"preview": "Require Import ZArith.\nRequire Import ZArith.Znumtheory.\nRequire Import ZArith.Zpow_facts.\nRequire Import Lia.\nRequire I"
},
{
"path": "Coq/C/extraMath.v",
"chars": 13657,
"preview": "Require Import ZArith.\nRequire Import Bool.\nRequire Import Lia.\n\nLocal Open Scope Z.\n\nLemma f_if {A B} (f: A -> B) (b:bo"
},
{
"path": "Coq/C/jets_secp256k1.v",
"chars": 3451397,
"preview": "(* clightgen -normalize -I secp256k1 -U__has_builtin -D USE_FORCE_WIDEMUL_INT128_STRUCT -D VERIFY -D VST -fstruct-passin"
},
{
"path": "Coq/C/modinv.v",
"chars": 9359,
"preview": "Require Import ZArith.\nRequire Import Coq.ZArith.Znumtheory.\nRequire Import Lia.\nRequire Import Coq.Logic.Eqdep_dec.\n\nOp"
},
{
"path": "Coq/C/progressC.v",
"chars": 12115,
"preview": "Require Import VST.floyd.proofauto.\nRequire Import extraMath.\n\nLemma Int64_low_is_nonneg (x : Z) :\n Int64.min_signed <= "
},
{
"path": "Coq/C/secp256k1/spec_int128.v",
"chars": 10260,
"preview": "Require Import VST.floyd.proofauto.\nRequire Import VST.msl.iter_sepcon.\nRequire Import jets_secp256k1.\n\n#[export] Instan"
},
{
"path": "Coq/C/secp256k1/spec_modinv64.v",
"chars": 18844,
"preview": "Require Import VST.floyd.proofauto.\nRequire Import jets_secp256k1.\nRequire Import Coq.Logic.Eqdep_dec.\n\nRequire Import p"
},
{
"path": "Coq/C/secp256k1/verif_int128_impl.v",
"chars": 23103,
"preview": "Require Import VST.floyd.proofauto.\nRequire Import jets_secp256k1.\nRequire Import spec_int128.\nRequire Import VST.msl.it"
},
{
"path": "Coq/C/secp256k1/verif_modinv64_impl.v",
"chars": 153755,
"preview": "Require Import VST.floyd.proofauto.\nRequire Import jets_secp256k1.\nRequire Import spec_int128.\nRequire Import spec_modin"
},
{
"path": "Coq/Simplicity/Alg.v",
"chars": 25145,
"preview": "Require Import Simplicity.Util.Monad.\nRequire Import Simplicity.Util.Option.\nRequire Import Simplicity.Util.PackedClass."
},
{
"path": "Coq/Simplicity/Bit.v",
"chars": 3542,
"preview": "Require Import Simplicity.Ty.\nRequire Import Simplicity.Alg.\n\nSet Implicit Arguments.\n\nLocal Open Scope ty_scope.\nLocal "
},
{
"path": "Coq/Simplicity/BitMachine.v",
"chars": 42284,
"preview": "Require Import PeanoNat.\nRequire Import NArith.\nRequire Import Simplicity.Util.List.\nRequire Import Simplicity.Util.Thri"
},
{
"path": "Coq/Simplicity/Core.v",
"chars": 3242,
"preview": "Require Import Simplicity.Ty.\n\nSet Implicit Arguments.\n\nInductive Term : Ty -> Ty -> Set :=\n| iden : forall {A}, Term A "
},
{
"path": "Coq/Simplicity/Delegation.v",
"chars": 11199,
"preview": "Require Import Simplicity.Util.PackedClass.\nImport Coq.Strings.String.StringSyntax.\n\nRequire Import Simplicity.Alg.\nRequ"
},
{
"path": "Coq/Simplicity/Digest.v",
"chars": 2817,
"preview": "Require Import Logic.Eqdep_dec.\nRequire Import Strings.String.\nRequire Import List.\nRequire BinInt.\nImport Coq.ZArith.Bi"
},
{
"path": "Coq/Simplicity/MerkleRoot.v",
"chars": 4088,
"preview": "Require Import List.\nRequire Import Coq.Strings.String.\nImport Coq.Strings.Ascii.AsciiSyntax.\n\nRequire Import Simplicity"
},
{
"path": "Coq/Simplicity/Primitive/Bitcoin.v",
"chars": 6879,
"preview": "Require Import ZArith.\nRequire Import String.\nRequire Import Simplicity.Util.List.\nRequire Import compcert.lib.Integers."
},
{
"path": "Coq/Simplicity/Primitive.v",
"chars": 15285,
"preview": "Require Import Simplicity.Util.List.\nRequire Import Strings.String.\nRequire Import Simplicity.Util.PackedClass.\nRequire "
},
{
"path": "Coq/Simplicity/SHA256.v",
"chars": 17256,
"preview": "Require Import ZArith.\nRequire Import List.\nRequire Import Lia.\n\nRequire sha.SHA256.\nRequire Import compcert.lib.Integer"
},
{
"path": "Coq/Simplicity/StaticAnalysis.v",
"chars": 12216,
"preview": "Require Import NArith.\nRequire Import Simplicity.Util.List.\n\nRequire Import Simplicity.Alg.\nRequire Import Simplicity.Bi"
},
{
"path": "Coq/Simplicity/Translate.v",
"chars": 13426,
"preview": "Require Import PeanoNat.\nRequire Import Simplicity.Util.List.\nRequire Import Simplicity.Util.Thrist.\n\nRequire Import Sim"
},
{
"path": "Coq/Simplicity/Ty.v",
"chars": 847,
"preview": "Set Primitive Projections.\nSet Implicit Arguments.\n\nDeclare Scope ty_scope.\n\nInductive Ty : Set :=\n| Unit : Ty\n| Sum : "
},
{
"path": "Coq/Simplicity/Util/Arith.v",
"chars": 1119,
"preview": "Require Import ZArith.\n\nSet Implicit Arguments.\n\n(* In order to compute, this needs to be transparent *)\nDefinition natD"
},
{
"path": "Coq/Simplicity/Util/List.v",
"chars": 1620,
"preview": "Require Export Coq.Lists.List.\nRequire Import ZArith.\n\nLemma repeat_S_tail {A} : forall (a : A) n, repeat a n ++ (a :: n"
},
{
"path": "Coq/Simplicity/Util/Monad/Reader.v",
"chars": 3772,
"preview": "Require Import Logic.FunctionalExtensionality.\n\nRequire Import Simplicity.Util.Monad.\nLocal Open Scope monad_scope.\n\nDef"
},
{
"path": "Coq/Simplicity/Util/Monad.v",
"chars": 9835,
"preview": "Require Import Simplicity.Util.PackedClass.\nImport Coq.Strings.String.StringSyntax.\n\nSet Implicit Arguments.\n\nLocal Open"
},
{
"path": "Coq/Simplicity/Util/Option.v",
"chars": 2271,
"preview": "Require Import Simplicity.Util.Monad.\n\nSet Implicit Arguments.\n\nLocal Open Scope monad_scope.\n\nDefinition option_join {A"
},
{
"path": "Coq/Simplicity/Util/PackedClass.v",
"chars": 744,
"preview": "Require Import Coq.Strings.String.\n\n(* Assia Mahboubi, Enrico Tassi. Canonical Structures for the working Coq user. 20"
},
{
"path": "Coq/Simplicity/Util/Thrist.v",
"chars": 1146,
"preview": "Module Thrist.\n\nDeclare Scope thrist_scope.\n\nInductive T {A} (P : A -> A -> Type) (z:A) : A -> Type :=\n| nil : T P z z\n|"
},
{
"path": "Coq/Simplicity/Word.v",
"chars": 77270,
"preview": "Require Import Logic.Eqdep_dec.\nRequire Import List.\nRequire Import ZArith.\nRequire Import Simplicity.Util.Arith.\nRequir"
},
{
"path": "Coq/_CoqProject",
"chars": 707,
"preview": "-Q Simplicity Simplicity\n-R C C\nSimplicity/StaticAnalysis.v\nSimplicity/MerkleRoot.v\nSimplicity/Core.v\nSimplicity/Digest."
},
{
"path": "Haskell/Bitcoin/Simplicity/Bitcoin/DataTypes.hs",
"chars": 12863,
"preview": "-- | This module defines the data structures that make up the signed data in a Bitcoin transaction.\nmodule Simplicity.Bi"
},
{
"path": "Haskell/Bitcoin/Simplicity/Bitcoin/Primitive.hs",
"chars": 6435,
"preview": "{-# LANGUAGE GADTs, ScopedTypeVariables #-}\n-- | This module provides the Simplicity primitives specific for Bitcoin or "
},
{
"path": "Haskell/Core/Simplicity/BitMachine/Authentic.hs",
"chars": 10045,
"preview": "{-# LANGUAGE FlexibleContexts #-}\n-- | This modules implements the Bit Machine according to its specification.\n--\n-- Thi"
},
{
"path": "Haskell/Core/Simplicity/BitMachine/StaticAnalysis/Cost.hs",
"chars": 1996,
"preview": "{-# LANGUAGE GADTs #-}\nmodule Simplicity.BitMachine.StaticAnalysis.Cost\n ( TermWeight(..)\n , overhead\n , milliWeigh\n-"
},
{
"path": "Haskell/Core/Simplicity/BitMachine/StaticAnalysis/TCO.hs",
"chars": 2372,
"preview": "-- | This module has functions for computing static analysis of Bit Machine resources used during execution of tail call"
},
{
"path": "Haskell/Core/Simplicity/BitMachine/StaticAnalysis.hs",
"chars": 1945,
"preview": "-- | This module has functions for computing static analysis of Bit Machine resources used during execution of naive tra"
},
{
"path": "Haskell/Core/Simplicity/BitMachine/Translate/TCO.hs",
"chars": 4636,
"preview": "-- | This module implements tail call optimized translation of Simplicity terms to Bit Machine 'MachineCode'.\nmodule Sim"
},
{
"path": "Haskell/Core/Simplicity/BitMachine/Translate.hs",
"chars": 3281,
"preview": "-- | This module implements naive translation of Simplicity terms to Bit Machine 'MachineCode'.\nmodule Simplicity.BitMac"
},
{
"path": "Haskell/Core/Simplicity/BitMachine/Ty.hs",
"chars": 1754,
"preview": "-- | This module has some functions operating on Simplicity types that are used for evaluating Simplicity on the Bit Mac"
},
{
"path": "Haskell/Core/Simplicity/BitMachine.hs",
"chars": 7735,
"preview": "{-# LANGUAGE DeriveTraversable, GADTs #-}\n-- | This module defines encoding and decoding of values for the Bit Machine a"
},
{
"path": "Haskell/Core/Simplicity/Bitcoin.hs",
"chars": 1031,
"preview": "-- | This module defines utilities used in the processing of Bitcoin-like transaction data.\nmodule Simplicity.Bitcoin\n "
},
{
"path": "Haskell/Core/Simplicity/CoreJets.hs",
"chars": 132297,
"preview": "-- | This modules provides a GADT for a type of \"core\" Simplicity jets, i.e. those jets that don't use application speci"
},
{
"path": "Haskell/Core/Simplicity/Delegator/Impl.hs",
"chars": 2160,
"preview": "-- | This internal module provides a Deleator instance that perform a semantic conversion of the 'disconnect' combinator"
},
{
"path": "Haskell/Core/Simplicity/Delegator.hs",
"chars": 985,
"preview": "-- | This module provides the functional semantics of Simplicity with 'Delegate'.\nmodule Simplicity.Delegator\n ( Delegat"
},
{
"path": "Haskell/Core/Simplicity/Digest/Pure/SHA.hs",
"chars": 48639,
"preview": "{- This is a copy of Galoi's Data.Digets.Pure.SHA module.\n We copy it here in order to export some internal functions."
},
{
"path": "Haskell/Core/Simplicity/Digest.hs",
"chars": 8967,
"preview": "-- | This modules wraps Data.Digest.Pure.SHA in order to simulate direct access to the SHA-256 compression function by p"
},
{
"path": "Haskell/Core/Simplicity/FFI/Frame.hs",
"chars": 4318,
"preview": "{-# LANGUAGE ForeignFunctionInterface, GADTs #-}\nmodule Simplicity.FFI.Frame\n ( unsafeCoreJet, unsafeLocalCoreJet\n , Fra"
},
{
"path": "Haskell/Core/Simplicity/FFI/Jets.hs",
"chars": 77161,
"preview": "-- | This module binds the C implementation of jets for Simplicity for assertions.\n{-# LANGUAGE ForeignFunctionInterface"
},
{
"path": "Haskell/Core/Simplicity/Functor.hs",
"chars": 374,
"preview": "{-# LANGUAGE RankNTypes #-}\n-- | This module provides a product for computing multiple interpretations of Simplicity sim"
},
{
"path": "Haskell/Core/Simplicity/LibSecp256k1/Schnorr.hs",
"chars": 987,
"preview": "-- | This module specifies the types to be used to interface with bindings to a real Schnorr signature module for Secp25"
},
{
"path": "Haskell/Core/Simplicity/LibSecp256k1/Spec.hs",
"chars": 30325,
"preview": "module Simplicity.LibSecp256k1.Spec\n ( -- * Field operations.\n FE, fe, fe_repr, fe_pack, fe_unpack\n , fe_zero, fe_one\n"
},
{
"path": "Haskell/Core/Simplicity/MerkleRoot/Impl.hs",
"chars": 11932,
"preview": "-- | This module provides functions for computing commitment, identity and annotated Merkle roots of Simplicity expressi"
},
{
"path": "Haskell/Core/Simplicity/MerkleRoot.hs",
"chars": 545,
"preview": "-- | This module provides functions for computing commitment, identity and annotated Merkle roots of Simplicity expressi"
},
{
"path": "Haskell/Core/Simplicity/Programs/Arith.hs",
"chars": 16372,
"preview": "{-# LANGUAGE GADTs, ScopedTypeVariables, TypeOperators #-}\n-- | This module defines Simplicity expressions and combinato"
},
{
"path": "Haskell/Core/Simplicity/Programs/Bit.hs",
"chars": 2796,
"preview": "-- | This module defines Simplicity combinators and expressions that operate on bits.\nmodule Simplicity.Programs.Bit\n ( "
},
{
"path": "Haskell/Core/Simplicity/Programs/Bitcoin/Lib.hs",
"chars": 861,
"preview": "{-# LANGUAGE NoMonomorphismRestriction #-}\n-- | This module unpacks the 'Simplicity.Programs.Bitcoin.lib' library instan"
},
{
"path": "Haskell/Core/Simplicity/Programs/Bitcoin.hs",
"chars": 5596,
"preview": "{-# LANGUAGE ScopedTypeVariables, GADTs, RankNTypes, RecordWildCards #-}\n-- | This module defines Simplicity expressions"
},
{
"path": "Haskell/Core/Simplicity/Programs/CheckSig/Lib.hs",
"chars": 746,
"preview": "{-# LANGUAGE NoMonomorphismRestriction #-}\n-- | This module instantiates the \"Simplicity.Programs.CheckSig\" module funct"
},
{
"path": "Haskell/Core/Simplicity/Programs/CheckSig.hs",
"chars": 4024,
"preview": "{-# LANGUAGE RecordWildCards #-}\n-- | The module builds a Simplicity expression that mimics the behaviour of a @CHECKSIG"
},
{
"path": "Haskell/Core/Simplicity/Programs/Elements/Lib.hs",
"chars": 1467,
"preview": "{-# LANGUAGE NoMonomorphismRestriction #-}\n-- | This module unpacks the 'Simplicity.Programs.Elements.lib' library insta"
},
{
"path": "Haskell/Core/Simplicity/Programs/Elements.hs",
"chars": 8954,
"preview": "{-# LANGUAGE ScopedTypeVariables, GADTs, RankNTypes, RecordWildCards #-}\n-- | This module defines Simplicity expressions"
},
{
"path": "Haskell/Core/Simplicity/Programs/Generic.hs",
"chars": 1433,
"preview": "{-# LANGUAGE GADTs #-}\n-- | This module is a collection of Simplicity expressions that are generic over a collection of "
},
{
"path": "Haskell/Core/Simplicity/Programs/LibSecp256k1/Lib.hs",
"chars": 5413,
"preview": "{-# LANGUAGE NoMonomorphismRestriction #-}\n-- | This module unpacks the 'Simplicity.Programs.LibSecp256k1.lib' library i"
},
{
"path": "Haskell/Core/Simplicity/Programs/LibSecp256k1.hs",
"chars": 39947,
"preview": "{-# LANGUAGE ScopedTypeVariables, GADTs, RankNTypes, RecordWildCards #-}\n-- | This module defines a library of Simplicit"
},
{
"path": "Haskell/Core/Simplicity/Programs/Loop.hs",
"chars": 2098,
"preview": "{-# LANGUAGE ScopedTypeVariables #-}\n-- | This module is a stub for supporting looping behaviour in Simplicity via self-"
},
{
"path": "Haskell/Core/Simplicity/Programs/Sha256/Lib.hs",
"chars": 1479,
"preview": "{-# LANGUAGE NoMonomorphismRestriction #-}\n-- | This module unpacks the 'Simplicity.Programs.Sha256.lib' library instanc"
},
{
"path": "Haskell/Core/Simplicity/Programs/Sha256.hs",
"chars": 10275,
"preview": "{-# LANGUAGE GADTs, RankNTypes, RecordWildCards #-}\n-- | This module defines Simplicity expression and types that can be"
},
{
"path": "Haskell/Core/Simplicity/Programs/TimeLock.hs",
"chars": 1114,
"preview": "-- | This module defines Simplicity expressions that implement timelock functions from \"Simplicity.Bitcoin\".\nmodule Simp"
},
{
"path": "Haskell/Core/Simplicity/Programs/Word.hs",
"chars": 17644,
"preview": "{-# LANGUAGE RankNTypes, GADTs, ScopedTypeVariables, TypeOperators #-}\n-- | This module defines Simplicity expressions a"
},
{
"path": "Haskell/Core/Simplicity/Serialization.hs",
"chars": 11827,
"preview": "-- | This modules provides functionality to aid serializiang and deserializing to and from bit streams using difference "
},
{
"path": "Haskell/Core/Simplicity/Tags.hs",
"chars": 1615,
"preview": "module Simplicity.Tags\n ( typeTag\n , commitmentTag\n , identityHashTag, identityTag\n , annotatedTag\n , primTag\n , j"
},
{
"path": "Haskell/Core/Simplicity/Tensor.hs",
"chars": 434,
"preview": "-- | This module provides a product for computing multiple interpretations of Simplicity simultaneously.\n-- Other tensor"
},
{
"path": "Haskell/Core/Simplicity/Term/Core.hs",
"chars": 8704,
"preview": "{-# LANGUAGE NoMonomorphismRestriction #-}\n-- | This module defines the term language for 'Core' Simplicity using\n-- tag"
},
{
"path": "Haskell/Core/Simplicity/Tree.hs",
"chars": 2601,
"preview": "-- | This modules provides custom binary trees ('BinTree') and rose trees ('Catalogue') for use in Simplicity.\nmodule Si"
},
{
"path": "Haskell/Core/Simplicity/Ty/Bit.hs",
"chars": 652,
"preview": "-- | This module defines the 'Bit' type alais used in Simplicity.\nmodule Simplicity.Ty.Bit\n ( Bit, fromBit, toBit\n ) whe"
},
{
"path": "Haskell/Core/Simplicity/Ty/LibSecp256k1.hs",
"chars": 1684,
"preview": "module Simplicity.Ty.LibSecp256k1\n ( FE, GE, GEJ, Scalar, Point\n , PubKey, Sig\n , fromFE, toFE\n , fromGE, toGE\n , fromGE"
}
]
// ... and 107 more files (download for full content)
About this extraction
This page contains the full source code of the ElementsProject/simplicity GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 307 files (47.3 MB), approximately 3.8M tokens, and a symbol index with 836 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.