diff --git a/src/script/interpreter.cpp b/src/script/interpreter.cpp
index 81e1ecccf3..fff02946bc 100644
--- a/src/script/interpreter.cpp
+++ b/src/script/interpreter.cpp
@@ -1,1837 +1,1833 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/interpreter.h>
 
 #include <crypto/ripemd160.h>
 #include <crypto/sha1.h>
 #include <crypto/sha256.h>
 #include <primitives/transaction.h>
 #include <pubkey.h>
 #include <script/bitfield.h>
 #include <script/script.h>
 #include <script/script_flags.h>
 #include <script/sigencoding.h>
 #include <uint256.h>
 #include <util/bitmanip.h>
 
 bool CastToBool(const valtype &vch) {
     for (size_t i = 0; i < vch.size(); i++) {
         if (vch[i] != 0) {
             // Can be negative zero
             if (i == vch.size() - 1 && vch[i] == 0x80) {
                 return false;
             }
             return true;
         }
     }
     return false;
 }
 
 /**
  * Script is a stack machine (like Forth) that evaluates a predicate
  * returning a bool indicating valid or not.  There are no loops.
  */
 #define stacktop(i) (stack.at(stack.size() + (i)))
 #define altstacktop(i) (altstack.at(altstack.size() + (i)))
 static inline void popstack(std::vector<valtype> &stack) {
     if (stack.empty()) {
         throw std::runtime_error("popstack(): stack empty");
     }
     stack.pop_back();
 }
 
 int FindAndDelete(CScript &script, const CScript &b) {
     int nFound = 0;
     if (b.empty()) {
         return nFound;
     }
 
     CScript result;
     CScript::const_iterator pc = script.begin(), pc2 = script.begin(),
                             end = script.end();
     opcodetype opcode;
     do {
         result.insert(result.end(), pc2, pc);
         while (static_cast<size_t>(end - pc) >= b.size() &&
                std::equal(b.begin(), b.end(), pc)) {
             pc = pc + b.size();
             ++nFound;
         }
         pc2 = pc;
     } while (script.GetOp(pc, opcode));
 
     if (nFound > 0) {
         result.insert(result.end(), pc2, end);
         script = std::move(result);
     }
 
     return nFound;
 }
 
 static void CleanupScriptCode(CScript &scriptCode,
                               const std::vector<uint8_t> &vchSig,
                               uint32_t flags) {
     // Drop the signature in scripts when SIGHASH_FORKID is not used.
     SigHashType sigHashType = GetHashType(vchSig);
     if (!(flags & SCRIPT_ENABLE_SIGHASH_FORKID) || !sigHashType.hasForkId()) {
         FindAndDelete(scriptCode, CScript(vchSig));
     }
 }
 
 static bool IsOpcodeDisabled(opcodetype opcode, uint32_t flags) {
     switch (opcode) {
         case OP_INVERT:
         case OP_2MUL:
         case OP_2DIV:
         case OP_MUL:
         case OP_LSHIFT:
         case OP_RSHIFT:
             // Disabled opcodes.
             return true;
 
         default:
             break;
     }
 
     return false;
 }
 
 bool EvalScript(std::vector<valtype> &stack, const CScript &script,
                 uint32_t flags, const BaseSignatureChecker &checker,
                 ScriptExecutionMetrics &metrics, ScriptError *serror) {
     static const CScriptNum bnZero(0);
     static const CScriptNum bnOne(1);
     static const valtype vchFalse(0);
     static const valtype vchTrue(1, 1);
 
     CScript::const_iterator pc = script.begin();
     CScript::const_iterator pend = script.end();
     CScript::const_iterator pbegincodehash = script.begin();
     opcodetype opcode;
     valtype vchPushValue;
     std::vector<bool> vfExec;
     std::vector<valtype> altstack;
     set_error(serror, ScriptError::UNKNOWN);
     if (script.size() > MAX_SCRIPT_SIZE) {
         return set_error(serror, ScriptError::SCRIPT_SIZE);
     }
     int nOpCount = 0;
     bool fRequireMinimal = (flags & SCRIPT_VERIFY_MINIMALDATA) != 0;
 
     try {
         while (pc < pend) {
             bool fExec = !count(vfExec.begin(), vfExec.end(), false);
 
             //
             // Read instruction
             //
             if (!script.GetOp(pc, opcode, vchPushValue)) {
                 return set_error(serror, ScriptError::BAD_OPCODE);
             }
             if (vchPushValue.size() > MAX_SCRIPT_ELEMENT_SIZE) {
                 return set_error(serror, ScriptError::PUSH_SIZE);
             }
 
             // Note how OP_RESERVED does not count towards the opcode limit.
             if (opcode > OP_16 && ++nOpCount > MAX_OPS_PER_SCRIPT) {
                 return set_error(serror, ScriptError::OP_COUNT);
             }
 
             // Some opcodes are disabled.
             if (IsOpcodeDisabled(opcode, flags)) {
                 return set_error(serror, ScriptError::DISABLED_OPCODE);
             }
 
             if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4) {
                 if (fRequireMinimal &&
                     !CheckMinimalPush(vchPushValue, opcode)) {
                     return set_error(serror, ScriptError::MINIMALDATA);
                 }
                 stack.push_back(vchPushValue);
             } else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF)) {
                 switch (opcode) {
                     //
                     // Push value
                     //
                     case OP_1NEGATE:
                     case OP_1:
                     case OP_2:
                     case OP_3:
                     case OP_4:
                     case OP_5:
                     case OP_6:
                     case OP_7:
                     case OP_8:
                     case OP_9:
                     case OP_10:
                     case OP_11:
                     case OP_12:
                     case OP_13:
                     case OP_14:
                     case OP_15:
                     case OP_16: {
                         // ( -- value)
                         CScriptNum bn((int)opcode - (int)(OP_1 - 1));
                         stack.push_back(bn.getvch());
                         // The result of these opcodes should always be the
                         // minimal way to push the data they push, so no need
                         // for a CheckMinimalPush here.
                     } break;
 
                     //
                     // Control
                     //
                     case OP_NOP:
                         break;
 
                     case OP_CHECKLOCKTIMEVERIFY: {
                         if (!(flags & SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY)) {
                             break;
                         }
 
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
 
                         // Note that elsewhere numeric opcodes are limited to
                         // operands in the range -2**31+1 to 2**31-1, however it
                         // is legal for opcodes to produce results exceeding
                         // that range. This limitation is implemented by
                         // CScriptNum's default 4-byte limit.
                         //
                         // If we kept to that limit we'd have a year 2038
                         // problem, even though the nLockTime field in
                         // transactions themselves is uint32 which only becomes
                         // meaningless after the year 2106.
                         //
                         // Thus as a special case we tell CScriptNum to accept
                         // up to 5-byte bignums, which are good until 2**39-1,
                         // well beyond the 2**32-1 limit of the nLockTime field
                         // itself.
                         const CScriptNum nLockTime(stacktop(-1),
                                                    fRequireMinimal, 5);
 
                         // In the rare event that the argument may be < 0 due to
                         // some arithmetic being done first, you can always use
                         // 0 MAX CHECKLOCKTIMEVERIFY.
                         if (nLockTime < 0) {
                             return set_error(serror,
                                              ScriptError::NEGATIVE_LOCKTIME);
                         }
 
                         // Actually compare the specified lock time with the
                         // transaction.
                         if (!checker.CheckLockTime(nLockTime)) {
                             return set_error(serror,
                                              ScriptError::UNSATISFIED_LOCKTIME);
                         }
 
                         break;
                     }
 
                     case OP_CHECKSEQUENCEVERIFY: {
                         if (!(flags & SCRIPT_VERIFY_CHECKSEQUENCEVERIFY)) {
                             break;
                         }
 
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
 
                         // nSequence, like nLockTime, is a 32-bit unsigned
                         // integer field. See the comment in CHECKLOCKTIMEVERIFY
                         // regarding 5-byte numeric operands.
                         const CScriptNum nSequence(stacktop(-1),
                                                    fRequireMinimal, 5);
 
                         // In the rare event that the argument may be < 0 due to
                         // some arithmetic being done first, you can always use
                         // 0 MAX CHECKSEQUENCEVERIFY.
                         if (nSequence < 0) {
                             return set_error(serror,
                                              ScriptError::NEGATIVE_LOCKTIME);
                         }
 
                         // To provide for future soft-fork extensibility, if the
                         // operand has the disabled lock-time flag set,
                         // CHECKSEQUENCEVERIFY behaves as a NOP.
                         if ((nSequence &
                              CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0) {
                             break;
                         }
 
                         // Compare the specified sequence number with the input.
                         if (!checker.CheckSequence(nSequence)) {
                             return set_error(serror,
                                              ScriptError::UNSATISFIED_LOCKTIME);
                         }
 
                         break;
                     }
 
                     case OP_NOP1:
                     case OP_NOP4:
                     case OP_NOP5:
                     case OP_NOP6:
                     case OP_NOP7:
                     case OP_NOP8:
                     case OP_NOP9:
                     case OP_NOP10: {
                         if (flags & SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS) {
                             return set_error(
                                 serror,
                                 ScriptError::DISCOURAGE_UPGRADABLE_NOPS);
                         }
                     } break;
 
                     case OP_IF:
                     case OP_NOTIF: {
                         // <expression> if [statements] [else [statements]]
                         // endif
                         bool fValue = false;
                         if (fExec) {
                             if (stack.size() < 1) {
                                 return set_error(
                                     serror,
                                     ScriptError::UNBALANCED_CONDITIONAL);
                             }
                             valtype &vch = stacktop(-1);
                             if (flags & SCRIPT_VERIFY_MINIMALIF) {
                                 if (vch.size() > 1) {
                                     return set_error(serror,
                                                      ScriptError::MINIMALIF);
                                 }
                                 if (vch.size() == 1 && vch[0] != 1) {
                                     return set_error(serror,
                                                      ScriptError::MINIMALIF);
                                 }
                             }
                             fValue = CastToBool(vch);
                             if (opcode == OP_NOTIF) {
                                 fValue = !fValue;
                             }
                             popstack(stack);
                         }
                         vfExec.push_back(fValue);
                     } break;
 
                     case OP_ELSE: {
                         if (vfExec.empty()) {
                             return set_error(
                                 serror, ScriptError::UNBALANCED_CONDITIONAL);
                         }
                         vfExec.back() = !vfExec.back();
                     } break;
 
                     case OP_ENDIF: {
                         if (vfExec.empty()) {
                             return set_error(
                                 serror, ScriptError::UNBALANCED_CONDITIONAL);
                         }
                         vfExec.pop_back();
                     } break;
 
                     case OP_VERIFY: {
                         // (true -- ) or
                         // (false -- false) and return
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         bool fValue = CastToBool(stacktop(-1));
                         if (fValue) {
                             popstack(stack);
                         } else {
                             return set_error(serror, ScriptError::VERIFY);
                         }
                     } break;
 
                     case OP_RETURN: {
                         return set_error(serror, ScriptError::OP_RETURN);
                     } break;
 
                     //
                     // Stack ops
                     //
                     case OP_TOALTSTACK: {
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         altstack.push_back(stacktop(-1));
                         popstack(stack);
                     } break;
 
                     case OP_FROMALTSTACK: {
                         if (altstack.size() < 1) {
                             return set_error(
                                 serror,
                                 ScriptError::INVALID_ALTSTACK_OPERATION);
                         }
                         stack.push_back(altstacktop(-1));
                         popstack(altstack);
                     } break;
 
                     case OP_2DROP: {
                         // (x1 x2 -- )
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         popstack(stack);
                         popstack(stack);
                     } break;
 
                     case OP_2DUP: {
                         // (x1 x2 -- x1 x2 x1 x2)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype vch1 = stacktop(-2);
                         valtype vch2 = stacktop(-1);
                         stack.push_back(vch1);
                         stack.push_back(vch2);
                     } break;
 
                     case OP_3DUP: {
                         // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
                         if (stack.size() < 3) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype vch1 = stacktop(-3);
                         valtype vch2 = stacktop(-2);
                         valtype vch3 = stacktop(-1);
                         stack.push_back(vch1);
                         stack.push_back(vch2);
                         stack.push_back(vch3);
                     } break;
 
                     case OP_2OVER: {
                         // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
                         if (stack.size() < 4) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype vch1 = stacktop(-4);
                         valtype vch2 = stacktop(-3);
                         stack.push_back(vch1);
                         stack.push_back(vch2);
                     } break;
 
                     case OP_2ROT: {
                         // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
                         if (stack.size() < 6) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype vch1 = stacktop(-6);
                         valtype vch2 = stacktop(-5);
                         stack.erase(stack.end() - 6, stack.end() - 4);
                         stack.push_back(vch1);
                         stack.push_back(vch2);
                     } break;
 
                     case OP_2SWAP: {
                         // (x1 x2 x3 x4 -- x3 x4 x1 x2)
                         if (stack.size() < 4) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         swap(stacktop(-4), stacktop(-2));
                         swap(stacktop(-3), stacktop(-1));
                     } break;
 
                     case OP_IFDUP: {
                         // (x - 0 | x x)
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype vch = stacktop(-1);
                         if (CastToBool(vch)) {
                             stack.push_back(vch);
                         }
                     } break;
 
                     case OP_DEPTH: {
                         // -- stacksize
                         CScriptNum bn(stack.size());
                         stack.push_back(bn.getvch());
                     } break;
 
                     case OP_DROP: {
                         // (x -- )
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         popstack(stack);
                     } break;
 
                     case OP_DUP: {
                         // (x -- x x)
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype vch = stacktop(-1);
                         stack.push_back(vch);
                     } break;
 
                     case OP_NIP: {
                         // (x1 x2 -- x2)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         stack.erase(stack.end() - 2);
                     } break;
 
                     case OP_OVER: {
                         // (x1 x2 -- x1 x2 x1)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype vch = stacktop(-2);
                         stack.push_back(vch);
                     } break;
 
                     case OP_PICK:
                     case OP_ROLL: {
                         // (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
                         // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         int n =
                             CScriptNum(stacktop(-1), fRequireMinimal).getint();
                         popstack(stack);
                         if (n < 0 || n >= (int)stack.size()) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype vch = stacktop(-n - 1);
                         if (opcode == OP_ROLL) {
                             stack.erase(stack.end() - n - 1);
                         }
                         stack.push_back(vch);
                     } break;
 
                     case OP_ROT: {
                         // (x1 x2 x3 -- x2 x3 x1)
                         //  x2 x1 x3  after first swap
                         //  x2 x3 x1  after second swap
                         if (stack.size() < 3) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         swap(stacktop(-3), stacktop(-2));
                         swap(stacktop(-2), stacktop(-1));
                     } break;
 
                     case OP_SWAP: {
                         // (x1 x2 -- x2 x1)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         swap(stacktop(-2), stacktop(-1));
                     } break;
 
                     case OP_TUCK: {
                         // (x1 x2 -- x2 x1 x2)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype vch = stacktop(-1);
                         stack.insert(stack.end() - 2, vch);
                     } break;
 
                     case OP_SIZE: {
                         // (in -- in size)
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         CScriptNum bn(stacktop(-1).size());
                         stack.push_back(bn.getvch());
                     } break;
 
                     //
                     // Bitwise logic
                     //
                     case OP_AND:
                     case OP_OR:
                     case OP_XOR: {
                         // (x1 x2 - out)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype &vch1 = stacktop(-2);
                         valtype &vch2 = stacktop(-1);
 
                         // Inputs must be the same size
                         if (vch1.size() != vch2.size()) {
                             return set_error(serror,
                                              ScriptError::INVALID_OPERAND_SIZE);
                         }
 
                         // To avoid allocating, we modify vch1 in place.
                         switch (opcode) {
                             case OP_AND:
                                 for (size_t i = 0; i < vch1.size(); ++i) {
                                     vch1[i] &= vch2[i];
                                 }
                                 break;
                             case OP_OR:
                                 for (size_t i = 0; i < vch1.size(); ++i) {
                                     vch1[i] |= vch2[i];
                                 }
                                 break;
                             case OP_XOR:
                                 for (size_t i = 0; i < vch1.size(); ++i) {
                                     vch1[i] ^= vch2[i];
                                 }
                                 break;
                             default:
                                 break;
                         }
 
                         // And pop vch2.
                         popstack(stack);
                     } break;
 
                     case OP_EQUAL:
                     case OP_EQUALVERIFY:
                         // case OP_NOTEQUAL: // use OP_NUMNOTEQUAL
                         {
                             // (x1 x2 - bool)
                             if (stack.size() < 2) {
                                 return set_error(
                                     serror,
                                     ScriptError::INVALID_STACK_OPERATION);
                             }
                             valtype &vch1 = stacktop(-2);
                             valtype &vch2 = stacktop(-1);
 
                             bool fEqual = (vch1 == vch2);
                             // OP_NOTEQUAL is disabled because it would be too
                             // easy to say something like n != 1 and have some
                             // wiseguy pass in 1 with extra zero bytes after it
                             // (numerically, 0x01 == 0x0001 == 0x000001)
                             // if (opcode == OP_NOTEQUAL)
                             //    fEqual = !fEqual;
                             popstack(stack);
                             popstack(stack);
                             stack.push_back(fEqual ? vchTrue : vchFalse);
                             if (opcode == OP_EQUALVERIFY) {
                                 if (fEqual) {
                                     popstack(stack);
                                 } else {
                                     return set_error(serror,
                                                      ScriptError::EQUALVERIFY);
                                 }
                             }
                         }
                         break;
 
                     //
                     // Numeric
                     //
                     case OP_1ADD:
                     case OP_1SUB:
                     case OP_NEGATE:
                     case OP_ABS:
                     case OP_NOT:
                     case OP_0NOTEQUAL: {
                         // (in -- out)
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         CScriptNum bn(stacktop(-1), fRequireMinimal);
                         switch (opcode) {
                             case OP_1ADD:
                                 bn += bnOne;
                                 break;
                             case OP_1SUB:
                                 bn -= bnOne;
                                 break;
                             case OP_NEGATE:
                                 bn = -bn;
                                 break;
                             case OP_ABS:
                                 if (bn < bnZero) {
                                     bn = -bn;
                                 }
                                 break;
                             case OP_NOT:
                                 bn = (bn == bnZero);
                                 break;
                             case OP_0NOTEQUAL:
                                 bn = (bn != bnZero);
                                 break;
                             default:
                                 assert(!"invalid opcode");
                                 break;
                         }
                         popstack(stack);
                         stack.push_back(bn.getvch());
                     } break;
 
                     case OP_ADD:
                     case OP_SUB:
                     case OP_DIV:
                     case OP_MOD:
                     case OP_BOOLAND:
                     case OP_BOOLOR:
                     case OP_NUMEQUAL:
                     case OP_NUMEQUALVERIFY:
                     case OP_NUMNOTEQUAL:
                     case OP_LESSTHAN:
                     case OP_GREATERTHAN:
                     case OP_LESSTHANOREQUAL:
                     case OP_GREATERTHANOREQUAL:
                     case OP_MIN:
                     case OP_MAX: {
                         // (x1 x2 -- out)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         CScriptNum bn1(stacktop(-2), fRequireMinimal);
                         CScriptNum bn2(stacktop(-1), fRequireMinimal);
                         CScriptNum bn(0);
                         switch (opcode) {
                             case OP_ADD:
                                 bn = bn1 + bn2;
                                 break;
 
                             case OP_SUB:
                                 bn = bn1 - bn2;
                                 break;
 
                             case OP_DIV:
                                 // denominator must not be 0
                                 if (bn2 == 0) {
                                     return set_error(serror,
                                                      ScriptError::DIV_BY_ZERO);
                                 }
                                 bn = bn1 / bn2;
                                 break;
 
                             case OP_MOD:
                                 // divisor must not be 0
                                 if (bn2 == 0) {
                                     return set_error(serror,
                                                      ScriptError::MOD_BY_ZERO);
                                 }
                                 bn = bn1 % bn2;
                                 break;
 
                             case OP_BOOLAND:
                                 bn = (bn1 != bnZero && bn2 != bnZero);
                                 break;
                             case OP_BOOLOR:
                                 bn = (bn1 != bnZero || bn2 != bnZero);
                                 break;
                             case OP_NUMEQUAL:
                                 bn = (bn1 == bn2);
                                 break;
                             case OP_NUMEQUALVERIFY:
                                 bn = (bn1 == bn2);
                                 break;
                             case OP_NUMNOTEQUAL:
                                 bn = (bn1 != bn2);
                                 break;
                             case OP_LESSTHAN:
                                 bn = (bn1 < bn2);
                                 break;
                             case OP_GREATERTHAN:
                                 bn = (bn1 > bn2);
                                 break;
                             case OP_LESSTHANOREQUAL:
                                 bn = (bn1 <= bn2);
                                 break;
                             case OP_GREATERTHANOREQUAL:
                                 bn = (bn1 >= bn2);
                                 break;
                             case OP_MIN:
                                 bn = (bn1 < bn2 ? bn1 : bn2);
                                 break;
                             case OP_MAX:
                                 bn = (bn1 > bn2 ? bn1 : bn2);
                                 break;
                             default:
                                 assert(!"invalid opcode");
                                 break;
                         }
                         popstack(stack);
                         popstack(stack);
                         stack.push_back(bn.getvch());
 
                         if (opcode == OP_NUMEQUALVERIFY) {
                             if (CastToBool(stacktop(-1))) {
                                 popstack(stack);
                             } else {
                                 return set_error(serror,
                                                  ScriptError::NUMEQUALVERIFY);
                             }
                         }
                     } break;
 
                     case OP_WITHIN: {
                         // (x min max -- out)
                         if (stack.size() < 3) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         CScriptNum bn1(stacktop(-3), fRequireMinimal);
                         CScriptNum bn2(stacktop(-2), fRequireMinimal);
                         CScriptNum bn3(stacktop(-1), fRequireMinimal);
                         bool fValue = (bn2 <= bn1 && bn1 < bn3);
                         popstack(stack);
                         popstack(stack);
                         popstack(stack);
                         stack.push_back(fValue ? vchTrue : vchFalse);
                     } break;
 
                     //
                     // Crypto
                     //
                     case OP_RIPEMD160:
                     case OP_SHA1:
                     case OP_SHA256:
                     case OP_HASH160:
                     case OP_HASH256: {
                         // (in -- hash)
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype &vch = stacktop(-1);
                         valtype vchHash((opcode == OP_RIPEMD160 ||
                                          opcode == OP_SHA1 ||
                                          opcode == OP_HASH160)
                                             ? 20
                                             : 32);
                         if (opcode == OP_RIPEMD160) {
                             CRIPEMD160()
                                 .Write(vch.data(), vch.size())
                                 .Finalize(vchHash.data());
                         } else if (opcode == OP_SHA1) {
                             CSHA1()
                                 .Write(vch.data(), vch.size())
                                 .Finalize(vchHash.data());
                         } else if (opcode == OP_SHA256) {
                             CSHA256()
                                 .Write(vch.data(), vch.size())
                                 .Finalize(vchHash.data());
                         } else if (opcode == OP_HASH160) {
                             CHash160()
                                 .Write(vch.data(), vch.size())
                                 .Finalize(vchHash.data());
                         } else if (opcode == OP_HASH256) {
                             CHash256()
                                 .Write(vch.data(), vch.size())
                                 .Finalize(vchHash.data());
                         }
                         popstack(stack);
                         stack.push_back(vchHash);
                     } break;
 
                     case OP_CODESEPARATOR: {
                         // Hash starts after the code separator
                         pbegincodehash = pc;
                     } break;
 
                     case OP_CHECKSIG:
                     case OP_CHECKSIGVERIFY: {
                         // (sig pubkey -- bool)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype &vchSig = stacktop(-2);
                         valtype &vchPubKey = stacktop(-1);
 
                         if (!CheckTransactionSignatureEncoding(vchSig, flags,
                                                                serror) ||
                             !CheckPubKeyEncoding(vchPubKey, flags, serror)) {
                             // serror is set
                             return false;
                         }
 
                         bool fSuccess = false;
                         if (vchSig.size()) {
                             // Subset of script starting at the most recent
                             // codeseparator
                             CScript scriptCode(pbegincodehash, pend);
 
                             // Remove signature for pre-fork scripts
                             CleanupScriptCode(scriptCode, vchSig, flags);
 
                             fSuccess = checker.CheckSig(vchSig, vchPubKey,
                                                         scriptCode, flags);
                             metrics.nSigChecks += 1;
 
                             if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL)) {
                                 return set_error(serror,
                                                  ScriptError::SIG_NULLFAIL);
                             }
                         }
 
                         popstack(stack);
                         popstack(stack);
                         stack.push_back(fSuccess ? vchTrue : vchFalse);
                         if (opcode == OP_CHECKSIGVERIFY) {
                             if (fSuccess) {
                                 popstack(stack);
                             } else {
                                 return set_error(serror,
                                                  ScriptError::CHECKSIGVERIFY);
                             }
                         }
                     } break;
 
                     case OP_CHECKDATASIG:
                     case OP_CHECKDATASIGVERIFY: {
                         // (sig message pubkey -- bool)
                         if (stack.size() < 3) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
 
                         valtype &vchSig = stacktop(-3);
                         valtype &vchMessage = stacktop(-2);
                         valtype &vchPubKey = stacktop(-1);
 
                         if (!CheckDataSignatureEncoding(vchSig, flags,
                                                         serror) ||
                             !CheckPubKeyEncoding(vchPubKey, flags, serror)) {
                             // serror is set
                             return false;
                         }
 
                         bool fSuccess = false;
                         if (vchSig.size()) {
                             valtype vchHash(32);
                             CSHA256()
                                 .Write(vchMessage.data(), vchMessage.size())
                                 .Finalize(vchHash.data());
                             fSuccess = checker.VerifySignature(
                                 vchSig, CPubKey(vchPubKey), uint256(vchHash));
                             metrics.nSigChecks += 1;
 
                             if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL)) {
                                 return set_error(serror,
                                                  ScriptError::SIG_NULLFAIL);
                             }
                         }
 
                         popstack(stack);
                         popstack(stack);
                         popstack(stack);
                         stack.push_back(fSuccess ? vchTrue : vchFalse);
                         if (opcode == OP_CHECKDATASIGVERIFY) {
                             if (fSuccess) {
                                 popstack(stack);
                             } else {
                                 return set_error(
                                     serror, ScriptError::CHECKDATASIGVERIFY);
                             }
                         }
                     } break;
 
                     case OP_CHECKMULTISIG:
                     case OP_CHECKMULTISIGVERIFY: {
                         // ([dummy] [sig ...] num_of_signatures [pubkey ...]
                         // num_of_pubkeys -- bool)
                         const size_t idxKeyCount = 1;
                         if (stack.size() < idxKeyCount) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         const int nKeysCount =
                             CScriptNum(stacktop(-idxKeyCount), fRequireMinimal)
                                 .getint();
                         if (nKeysCount < 0 ||
                             nKeysCount > MAX_PUBKEYS_PER_MULTISIG) {
                             return set_error(serror, ScriptError::PUBKEY_COUNT);
                         }
                         nOpCount += nKeysCount;
                         if (nOpCount > MAX_OPS_PER_SCRIPT) {
                             return set_error(serror, ScriptError::OP_COUNT);
                         }
 
                         // stack depth of the top pubkey
                         const size_t idxTopKey = idxKeyCount + 1;
 
                         // stack depth of nSigsCount
                         const size_t idxSigCount = idxTopKey + nKeysCount;
                         if (stack.size() < idxSigCount) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         const int nSigsCount =
                             CScriptNum(stacktop(-idxSigCount), fRequireMinimal)
                                 .getint();
                         if (nSigsCount < 0 || nSigsCount > nKeysCount) {
                             return set_error(serror, ScriptError::SIG_COUNT);
                         }
 
                         // stack depth of the top signature
                         const size_t idxTopSig = idxSigCount + 1;
 
                         // stack depth of the dummy element
                         const size_t idxDummy = idxTopSig + nSigsCount;
                         if (stack.size() < idxDummy) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
 
                         // Subset of script starting at the most recent
                         // codeseparator
                         CScript scriptCode(pbegincodehash, pend);
 
                         // Assuming success is usually a bad idea, but the
                         // schnorr path can only succeed.
                         bool fSuccess = true;
 
                         if ((flags & SCRIPT_ENABLE_SCHNORR_MULTISIG) &&
                             stacktop(-idxDummy).size() != 0) {
                             // SCHNORR MULTISIG
                             static_assert(
                                 MAX_PUBKEYS_PER_MULTISIG < 32,
                                 "Schnorr multisig checkbits implementation "
                                 "assumes < 32 pubkeys.");
                             uint32_t checkBits = 0;
 
                             // Dummy element is to be interpreted as a bitfield
                             // that represent which pubkeys should be checked.
                             valtype &vchDummy = stacktop(-idxDummy);
                             if (!DecodeBitfield(vchDummy, nKeysCount, checkBits,
                                                 serror)) {
                                 // serror is set
                                 return false;
                             }
 
                             // The bitfield doesn't set the right number of
                             // signatures.
                             if (countBits(checkBits) != uint32_t(nSigsCount)) {
                                 return set_error(
                                     serror, ScriptError::INVALID_BIT_COUNT);
                             }
 
                             const size_t idxBottomKey =
                                 idxTopKey + nKeysCount - 1;
                             const size_t idxBottomSig =
                                 idxTopSig + nSigsCount - 1;
 
                             int iKey = 0;
                             for (int iSig = 0; iSig < nSigsCount;
                                  iSig++, iKey++) {
                                 if ((checkBits >> iKey) == 0) {
                                     // This is a sanity check and should be
                                     // unrecheable.
                                     return set_error(
                                         serror, ScriptError::INVALID_BIT_RANGE);
                                 }
 
                                 // Find the next suitable key.
                                 while (((checkBits >> iKey) & 0x01) == 0) {
                                     iKey++;
                                 }
 
                                 if (iKey >= nKeysCount) {
                                     // This is a sanity check and should be
                                     // unrecheable.
                                     return set_error(serror,
                                                      ScriptError::PUBKEY_COUNT);
                                 }
 
                                 // Check the signature.
                                 valtype &vchSig =
                                     stacktop(-idxBottomSig + iSig);
                                 valtype &vchPubKey =
                                     stacktop(-idxBottomKey + iKey);
 
                                 // Note that only pubkeys associated with a
                                 // signature are checked for validity.
                                 if (!CheckTransactionSchnorrSignatureEncoding(
                                         vchSig, flags, serror) ||
                                     !CheckPubKeyEncoding(vchPubKey, flags,
                                                          serror)) {
                                     // serror is set
                                     return false;
                                 }
 
                                 // Check signature
                                 if (!checker.CheckSig(vchSig, vchPubKey,
                                                       scriptCode, flags)) {
                                     // This can fail if the signature is empty,
                                     // which also is a NULLFAIL error as the
                                     // bitfield should have been null in this
                                     // situation.
                                     return set_error(serror,
                                                      ScriptError::SIG_NULLFAIL);
                                 }
 
                                 // this is guaranteed to execute exactly
                                 // nSigsCount times (if not script error)
                                 metrics.nSigChecks += 1;
                             }
 
                             if ((checkBits >> iKey) != 0) {
                                 // This is a sanity check and should be
                                 // unrecheable.
                                 return set_error(
                                     serror, ScriptError::INVALID_BIT_COUNT);
                             }
                         } else {
                             // LEGACY MULTISIG (ECDSA / NULL)
 
                             // Remove signature for pre-fork scripts
                             for (int k = 0; k < nSigsCount; k++) {
                                 valtype &vchSig = stacktop(-idxTopSig - k);
                                 CleanupScriptCode(scriptCode, vchSig, flags);
                             }
 
                             int nSigsRemaining = nSigsCount;
                             int nKeysRemaining = nKeysCount;
                             while (fSuccess && nSigsRemaining > 0) {
                                 valtype &vchSig = stacktop(
                                     -idxTopSig - (nSigsCount - nSigsRemaining));
                                 valtype &vchPubKey = stacktop(
                                     -idxTopKey - (nKeysCount - nKeysRemaining));
 
                                 // Note how this makes the exact order of
                                 // pubkey/signature evaluation distinguishable
                                 // by CHECKMULTISIG NOT if the STRICTENC flag is
                                 // set. See the script_(in)valid tests for
                                 // details.
                                 if (!CheckTransactionECDSASignatureEncoding(
                                         vchSig, flags, serror) ||
                                     !CheckPubKeyEncoding(vchPubKey, flags,
                                                          serror)) {
                                     // serror is set
                                     return false;
                                 }
 
                                 // Check signature
                                 bool fOk = checker.CheckSig(vchSig, vchPubKey,
                                                             scriptCode, flags);
 
                                 if (fOk) {
                                     nSigsRemaining--;
                                 }
                                 nKeysRemaining--;
 
                                 // If there are more signatures left than keys
                                 // left, then too many signatures have failed.
                                 // Exit early, without checking any further
                                 // signatures.
                                 if (nSigsRemaining > nKeysRemaining) {
                                     fSuccess = false;
                                 }
                             }
 
                             bool areAllSignaturesNull = true;
                             for (int i = 0; i < nSigsCount; i++) {
                                 if (stacktop(-idxTopSig - i).size()) {
                                     areAllSignaturesNull = false;
                                     break;
                                 }
                             }
 
                             // If the operation failed, we may require that all
                             // signatures must be empty vector
                             if (!fSuccess && (flags & SCRIPT_VERIFY_NULLFAIL) &&
                                 !areAllSignaturesNull) {
                                 return set_error(serror,
                                                  ScriptError::SIG_NULLFAIL);
                             }
 
                             if (!areAllSignaturesNull) {
                                 // This is not identical to the number of actual
                                 // ECDSA verifies, but, it is an upper bound
                                 // that can be easily determined without doing
                                 // CPU-intensive checks.
                                 metrics.nSigChecks += nKeysCount;
                             }
                         }
 
                         // Clean up stack of all arguments
                         for (size_t i = 0; i < idxDummy; i++) {
                             popstack(stack);
                         }
 
                         stack.push_back(fSuccess ? vchTrue : vchFalse);
                         if (opcode == OP_CHECKMULTISIGVERIFY) {
                             if (fSuccess) {
                                 popstack(stack);
                             } else {
                                 return set_error(
                                     serror, ScriptError::CHECKMULTISIGVERIFY);
                             }
                         }
                     } break;
 
                     //
                     // Byte string operations
                     //
                     case OP_CAT: {
                         // (x1 x2 -- out)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
                         valtype &vch1 = stacktop(-2);
                         valtype &vch2 = stacktop(-1);
                         if (vch1.size() + vch2.size() >
                             MAX_SCRIPT_ELEMENT_SIZE) {
                             return set_error(serror, ScriptError::PUSH_SIZE);
                         }
                         vch1.insert(vch1.end(), vch2.begin(), vch2.end());
                         popstack(stack);
                     } break;
 
                     case OP_SPLIT: {
                         // (in position -- x1 x2)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
 
                         const valtype &data = stacktop(-2);
 
                         // Make sure the split point is appropriate.
                         uint64_t position =
                             CScriptNum(stacktop(-1), fRequireMinimal).getint();
                         if (position > data.size()) {
                             return set_error(serror,
                                              ScriptError::INVALID_SPLIT_RANGE);
                         }
 
                         // Prepare the results in their own buffer as `data`
                         // will be invalidated.
                         valtype n1(data.begin(), data.begin() + position);
                         valtype n2(data.begin() + position, data.end());
 
                         // Replace existing stack values by the new values.
                         stacktop(-2) = std::move(n1);
                         stacktop(-1) = std::move(n2);
                     } break;
 
                     case OP_REVERSEBYTES: {
-                        if (!(flags & SCRIPT_ENABLE_OP_REVERSEBYTES)) {
-                            return set_error(serror, ScriptError::BAD_OPCODE);
-                        }
-
                         // (in -- out)
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
 
                         valtype &data = stacktop(-1);
                         std::reverse(data.begin(), data.end());
                     } break;
 
                     //
                     // Conversion operations
                     //
                     case OP_NUM2BIN: {
                         // (in size -- out)
                         if (stack.size() < 2) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
 
                         uint64_t size =
                             CScriptNum(stacktop(-1), fRequireMinimal).getint();
                         if (size > MAX_SCRIPT_ELEMENT_SIZE) {
                             return set_error(serror, ScriptError::PUSH_SIZE);
                         }
 
                         popstack(stack);
                         valtype &rawnum = stacktop(-1);
 
                         // Try to see if we can fit that number in the number of
                         // byte requested.
                         CScriptNum::MinimallyEncode(rawnum);
                         if (rawnum.size() > size) {
                             // We definitively cannot.
                             return set_error(serror,
                                              ScriptError::IMPOSSIBLE_ENCODING);
                         }
 
                         // We already have an element of the right size, we
                         // don't need to do anything.
                         if (rawnum.size() == size) {
                             break;
                         }
 
                         uint8_t signbit = 0x00;
                         if (rawnum.size() > 0) {
                             signbit = rawnum.back() & 0x80;
                             rawnum[rawnum.size() - 1] &= 0x7f;
                         }
 
                         rawnum.reserve(size);
                         while (rawnum.size() < size - 1) {
                             rawnum.push_back(0x00);
                         }
 
                         rawnum.push_back(signbit);
                     } break;
 
                     case OP_BIN2NUM: {
                         // (in -- out)
                         if (stack.size() < 1) {
                             return set_error(
                                 serror, ScriptError::INVALID_STACK_OPERATION);
                         }
 
                         valtype &n = stacktop(-1);
                         CScriptNum::MinimallyEncode(n);
 
                         // The resulting number must be a valid number.
                         if (!CScriptNum::IsMinimallyEncoded(n)) {
                             return set_error(serror,
                                              ScriptError::INVALID_NUMBER_RANGE);
                         }
                     } break;
 
                     default:
                         return set_error(serror, ScriptError::BAD_OPCODE);
                 }
             }
 
             // Size limits
             if (stack.size() + altstack.size() > MAX_STACK_SIZE) {
                 return set_error(serror, ScriptError::STACK_SIZE);
             }
         }
     } catch (...) {
         return set_error(serror, ScriptError::UNKNOWN);
     }
 
     if (!vfExec.empty()) {
         return set_error(serror, ScriptError::UNBALANCED_CONDITIONAL);
     }
 
     return set_success(serror);
 }
 
 namespace {
 
 /**
  * Wrapper that serializes like CTransaction, but with the modifications
  *  required for the signature hash done in-place
  */
 template <class T> class CTransactionSignatureSerializer {
 private:
     //! reference to the spending transaction (the one being serialized)
     const T &txTo;
     //! output script being consumed
     const CScript &scriptCode;
     //! input index of txTo being signed
     const unsigned int nIn;
     //! container for hashtype flags
     const SigHashType sigHashType;
 
 public:
     CTransactionSignatureSerializer(const T &txToIn,
                                     const CScript &scriptCodeIn,
                                     unsigned int nInIn,
                                     SigHashType sigHashTypeIn)
         : txTo(txToIn), scriptCode(scriptCodeIn), nIn(nInIn),
           sigHashType(sigHashTypeIn) {}
 
     /** Serialize the passed scriptCode, skipping OP_CODESEPARATORs */
     template <typename S> void SerializeScriptCode(S &s) const {
         CScript::const_iterator it = scriptCode.begin();
         CScript::const_iterator itBegin = it;
         opcodetype opcode;
         unsigned int nCodeSeparators = 0;
         while (scriptCode.GetOp(it, opcode)) {
             if (opcode == OP_CODESEPARATOR) {
                 nCodeSeparators++;
             }
         }
         ::WriteCompactSize(s, scriptCode.size() - nCodeSeparators);
         it = itBegin;
         while (scriptCode.GetOp(it, opcode)) {
             if (opcode == OP_CODESEPARATOR) {
                 s.write((char *)&itBegin[0], it - itBegin - 1);
                 itBegin = it;
             }
         }
         if (itBegin != scriptCode.end()) {
             s.write((char *)&itBegin[0], it - itBegin);
         }
     }
 
     /** Serialize an input of txTo */
     template <typename S> void SerializeInput(S &s, unsigned int nInput) const {
         // In case of SIGHASH_ANYONECANPAY, only the input being signed is
         // serialized
         if (sigHashType.hasAnyoneCanPay()) {
             nInput = nIn;
         }
         // Serialize the prevout
         ::Serialize(s, txTo.vin[nInput].prevout);
         // Serialize the script
         if (nInput != nIn) {
             // Blank out other inputs' signatures
             ::Serialize(s, CScript());
         } else {
             SerializeScriptCode(s);
         }
         // Serialize the nSequence
         if (nInput != nIn &&
             (sigHashType.getBaseType() == BaseSigHashType::SINGLE ||
              sigHashType.getBaseType() == BaseSigHashType::NONE)) {
             // let the others update at will
             ::Serialize(s, (int)0);
         } else {
             ::Serialize(s, txTo.vin[nInput].nSequence);
         }
     }
 
     /** Serialize an output of txTo */
     template <typename S>
     void SerializeOutput(S &s, unsigned int nOutput) const {
         if (sigHashType.getBaseType() == BaseSigHashType::SINGLE &&
             nOutput != nIn) {
             // Do not lock-in the txout payee at other indices as txin
             ::Serialize(s, CTxOut());
         } else {
             ::Serialize(s, txTo.vout[nOutput]);
         }
     }
 
     /** Serialize txTo */
     template <typename S> void Serialize(S &s) const {
         // Serialize nVersion
         ::Serialize(s, txTo.nVersion);
         // Serialize vin
         unsigned int nInputs =
             sigHashType.hasAnyoneCanPay() ? 1 : txTo.vin.size();
         ::WriteCompactSize(s, nInputs);
         for (unsigned int nInput = 0; nInput < nInputs; nInput++) {
             SerializeInput(s, nInput);
         }
         // Serialize vout
         unsigned int nOutputs =
             (sigHashType.getBaseType() == BaseSigHashType::NONE)
                 ? 0
                 : ((sigHashType.getBaseType() == BaseSigHashType::SINGLE)
                        ? nIn + 1
                        : txTo.vout.size());
         ::WriteCompactSize(s, nOutputs);
         for (unsigned int nOutput = 0; nOutput < nOutputs; nOutput++) {
             SerializeOutput(s, nOutput);
         }
         // Serialize nLockTime
         ::Serialize(s, txTo.nLockTime);
     }
 };
 
 template <class T> uint256 GetPrevoutHash(const T &txTo) {
     CHashWriter ss(SER_GETHASH, 0);
     for (const auto &txin : txTo.vin) {
         ss << txin.prevout;
     }
     return ss.GetHash();
 }
 
 template <class T> uint256 GetSequenceHash(const T &txTo) {
     CHashWriter ss(SER_GETHASH, 0);
     for (const auto &txin : txTo.vin) {
         ss << txin.nSequence;
     }
     return ss.GetHash();
 }
 
 template <class T> uint256 GetOutputsHash(const T &txTo) {
     CHashWriter ss(SER_GETHASH, 0);
     for (const auto &txout : txTo.vout) {
         ss << txout;
     }
     return ss.GetHash();
 }
 
 } // namespace
 
 template <class T>
 PrecomputedTransactionData::PrecomputedTransactionData(const T &txTo) {
     hashPrevouts = GetPrevoutHash(txTo);
     hashSequence = GetSequenceHash(txTo);
     hashOutputs = GetOutputsHash(txTo);
 }
 
 // explicit instantiation
 template PrecomputedTransactionData::PrecomputedTransactionData(
     const CTransaction &txTo);
 template PrecomputedTransactionData::PrecomputedTransactionData(
     const CMutableTransaction &txTo);
 
 template <class T>
 uint256 SignatureHash(const CScript &scriptCode, const T &txTo,
                       unsigned int nIn, SigHashType sigHashType,
                       const Amount amount,
                       const PrecomputedTransactionData *cache, uint32_t flags) {
     assert(nIn < txTo.vin.size());
 
     if (flags & SCRIPT_ENABLE_REPLAY_PROTECTION) {
         // Legacy chain's value for fork id must be of the form 0xffxxxx.
         // By xoring with 0xdead, we ensure that the value will be different
         // from the original one, even if it already starts with 0xff.
         uint32_t newForkValue = sigHashType.getForkValue() ^ 0xdead;
         sigHashType = sigHashType.withForkValue(0xff0000 | newForkValue);
     }
 
     if (sigHashType.hasForkId() && (flags & SCRIPT_ENABLE_SIGHASH_FORKID)) {
         uint256 hashPrevouts;
         uint256 hashSequence;
         uint256 hashOutputs;
 
         if (!sigHashType.hasAnyoneCanPay()) {
             hashPrevouts = cache ? cache->hashPrevouts : GetPrevoutHash(txTo);
         }
 
         if (!sigHashType.hasAnyoneCanPay() &&
             (sigHashType.getBaseType() != BaseSigHashType::SINGLE) &&
             (sigHashType.getBaseType() != BaseSigHashType::NONE)) {
             hashSequence = cache ? cache->hashSequence : GetSequenceHash(txTo);
         }
 
         if ((sigHashType.getBaseType() != BaseSigHashType::SINGLE) &&
             (sigHashType.getBaseType() != BaseSigHashType::NONE)) {
             hashOutputs = cache ? cache->hashOutputs : GetOutputsHash(txTo);
         } else if ((sigHashType.getBaseType() == BaseSigHashType::SINGLE) &&
                    (nIn < txTo.vout.size())) {
             CHashWriter ss(SER_GETHASH, 0);
             ss << txTo.vout[nIn];
             hashOutputs = ss.GetHash();
         }
 
         CHashWriter ss(SER_GETHASH, 0);
         // Version
         ss << txTo.nVersion;
         // Input prevouts/nSequence (none/all, depending on flags)
         ss << hashPrevouts;
         ss << hashSequence;
         // The input being signed (replacing the scriptSig with scriptCode +
         // amount). The prevout may already be contained in hashPrevout, and the
         // nSequence may already be contain in hashSequence.
         ss << txTo.vin[nIn].prevout;
         ss << scriptCode;
         ss << amount;
         ss << txTo.vin[nIn].nSequence;
         // Outputs (none/one/all, depending on flags)
         ss << hashOutputs;
         // Locktime
         ss << txTo.nLockTime;
         // Sighash type
         ss << sigHashType;
 
         return ss.GetHash();
     }
 
     static const uint256 one(uint256S(
         "0000000000000000000000000000000000000000000000000000000000000001"));
 
     // Check for invalid use of SIGHASH_SINGLE
     if ((sigHashType.getBaseType() == BaseSigHashType::SINGLE) &&
         (nIn >= txTo.vout.size())) {
         //  nOut out of range
         return one;
     }
 
     // Wrapper to serialize only the necessary parts of the transaction being
     // signed
     CTransactionSignatureSerializer<T> txTmp(txTo, scriptCode, nIn,
                                              sigHashType);
 
     // Serialize and hash
     CHashWriter ss(SER_GETHASH, 0);
     ss << txTmp << sigHashType;
     return ss.GetHash();
 }
 
 bool BaseSignatureChecker::VerifySignature(const std::vector<uint8_t> &vchSig,
                                            const CPubKey &pubkey,
                                            const uint256 &sighash) const {
     if (vchSig.size() == 64) {
         return pubkey.VerifySchnorr(sighash, vchSig);
     } else {
         return pubkey.VerifyECDSA(sighash, vchSig);
     }
 }
 
 template <class T>
 bool GenericTransactionSignatureChecker<T>::CheckSig(
     const std::vector<uint8_t> &vchSigIn, const std::vector<uint8_t> &vchPubKey,
     const CScript &scriptCode, uint32_t flags) const {
     CPubKey pubkey(vchPubKey);
     if (!pubkey.IsValid()) {
         return false;
     }
 
     // Hash type is one byte tacked on to the end of the signature
     std::vector<uint8_t> vchSig(vchSigIn);
     if (vchSig.empty()) {
         return false;
     }
     SigHashType sigHashType = GetHashType(vchSig);
     vchSig.pop_back();
 
     uint256 sighash = SignatureHash(scriptCode, *txTo, nIn, sigHashType, amount,
                                     this->txdata, flags);
 
     if (!VerifySignature(vchSig, pubkey, sighash)) {
         return false;
     }
 
     return true;
 }
 
 template <class T>
 bool GenericTransactionSignatureChecker<T>::CheckLockTime(
     const CScriptNum &nLockTime) const {
     // There are two kinds of nLockTime: lock-by-blockheight and
     // lock-by-blocktime, distinguished by whether nLockTime <
     // LOCKTIME_THRESHOLD.
     //
     // We want to compare apples to apples, so fail the script unless the type
     // of nLockTime being tested is the same as the nLockTime in the
     // transaction.
     if (!((txTo->nLockTime < LOCKTIME_THRESHOLD &&
            nLockTime < LOCKTIME_THRESHOLD) ||
           (txTo->nLockTime >= LOCKTIME_THRESHOLD &&
            nLockTime >= LOCKTIME_THRESHOLD))) {
         return false;
     }
 
     // Now that we know we're comparing apples-to-apples, the comparison is a
     // simple numeric one.
     if (nLockTime > int64_t(txTo->nLockTime)) {
         return false;
     }
 
     // Finally the nLockTime feature can be disabled and thus
     // CHECKLOCKTIMEVERIFY bypassed if every txin has been finalized by setting
     // nSequence to maxint. The transaction would be allowed into the
     // blockchain, making the opcode ineffective.
     //
     // Testing if this vin is not final is sufficient to prevent this condition.
     // Alternatively we could test all inputs, but testing just this input
     // minimizes the data required to prove correct CHECKLOCKTIMEVERIFY
     // execution.
     if (CTxIn::SEQUENCE_FINAL == txTo->vin[nIn].nSequence) {
         return false;
     }
 
     return true;
 }
 
 template <class T>
 bool GenericTransactionSignatureChecker<T>::CheckSequence(
     const CScriptNum &nSequence) const {
     // Relative lock times are supported by comparing the passed in operand to
     // the sequence number of the input.
     const int64_t txToSequence = int64_t(txTo->vin[nIn].nSequence);
 
     // Fail if the transaction's version number is not set high enough to
     // trigger BIP 68 rules.
     if (static_cast<uint32_t>(txTo->nVersion) < 2) {
         return false;
     }
 
     // Sequence numbers with their most significant bit set are not consensus
     // constrained. Testing that the transaction's sequence number do not have
     // this bit set prevents using this property to get around a
     // CHECKSEQUENCEVERIFY check.
     if (txToSequence & CTxIn::SEQUENCE_LOCKTIME_DISABLE_FLAG) {
         return false;
     }
 
     // Mask off any bits that do not have consensus-enforced meaning before
     // doing the integer comparisons
     const uint32_t nLockTimeMask =
         CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | CTxIn::SEQUENCE_LOCKTIME_MASK;
     const int64_t txToSequenceMasked = txToSequence & nLockTimeMask;
     const CScriptNum nSequenceMasked = nSequence & nLockTimeMask;
 
     // There are two kinds of nSequence: lock-by-blockheight and
     // lock-by-blocktime, distinguished by whether nSequenceMasked <
     // CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG.
     //
     // We want to compare apples to apples, so fail the script unless the type
     // of nSequenceMasked being tested is the same as the nSequenceMasked in the
     // transaction.
     if (!((txToSequenceMasked < CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG &&
            nSequenceMasked < CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG) ||
           (txToSequenceMasked >= CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG &&
            nSequenceMasked >= CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG))) {
         return false;
     }
 
     // Now that we know we're comparing apples-to-apples, the comparison is a
     // simple numeric one.
     if (nSequenceMasked > txToSequenceMasked) {
         return false;
     }
 
     return true;
 }
 
 // explicit instantiation
 template class GenericTransactionSignatureChecker<CTransaction>;
 template class GenericTransactionSignatureChecker<CMutableTransaction>;
 
 bool VerifyScript(const CScript &scriptSig, const CScript &scriptPubKey,
                   uint32_t flags, const BaseSignatureChecker &checker,
                   ScriptExecutionMetrics &metricsOut, ScriptError *serror) {
     set_error(serror, ScriptError::UNKNOWN);
 
     // If FORKID is enabled, we also ensure strict encoding.
     if (flags & SCRIPT_ENABLE_SIGHASH_FORKID) {
         flags |= SCRIPT_VERIFY_STRICTENC;
     }
 
     if ((flags & SCRIPT_VERIFY_SIGPUSHONLY) != 0 && !scriptSig.IsPushOnly()) {
         return set_error(serror, ScriptError::SIG_PUSHONLY);
     }
 
     ScriptExecutionMetrics metrics = {};
 
     std::vector<valtype> stack, stackCopy;
     if (!EvalScript(stack, scriptSig, flags, checker, metrics, serror)) {
         // serror is set
         return false;
     }
     if (flags & SCRIPT_VERIFY_P2SH) {
         stackCopy = stack;
     }
     if (!EvalScript(stack, scriptPubKey, flags, checker, metrics, serror)) {
         // serror is set
         return false;
     }
     if (stack.empty()) {
         return set_error(serror, ScriptError::EVAL_FALSE);
     }
     if (CastToBool(stack.back()) == false) {
         return set_error(serror, ScriptError::EVAL_FALSE);
     }
 
     // Additional validation for spend-to-script-hash transactions:
     if ((flags & SCRIPT_VERIFY_P2SH) && scriptPubKey.IsPayToScriptHash()) {
         // scriptSig must be literals-only or validation fails
         if (!scriptSig.IsPushOnly()) {
             return set_error(serror, ScriptError::SIG_PUSHONLY);
         }
 
         // Restore stack.
         swap(stack, stackCopy);
 
         // stack cannot be empty here, because if it was the P2SH  HASH <> EQUAL
         // scriptPubKey would be evaluated with an empty stack and the
         // EvalScript above would return false.
         assert(!stack.empty());
 
         const valtype &pubKeySerialized = stack.back();
         CScript pubKey2(pubKeySerialized.begin(), pubKeySerialized.end());
         popstack(stack);
 
         // Bail out early if SCRIPT_DISALLOW_SEGWIT_RECOVERY is not set, the
         // redeem script is a p2sh segwit program, and it was the only item
         // pushed onto the stack.
         if ((flags & SCRIPT_DISALLOW_SEGWIT_RECOVERY) == 0 && stack.empty() &&
             pubKey2.IsWitnessProgram()) {
             // must set metricsOut for all successful returns
 
             // Prior to activation of this flag, all transactions will count as
             // having a sigchecks count of 0 for accounting purposes outside of
             // VerifyScript.
             if (!(flags & SCRIPT_REPORT_SIGCHECKS)) {
                 metrics.nSigChecks = 0;
             }
             metricsOut = metrics;
             return set_success(serror);
         }
 
         if (!EvalScript(stack, pubKey2, flags, checker, metrics, serror)) {
             // serror is set
             return false;
         }
         if (stack.empty()) {
             return set_error(serror, ScriptError::EVAL_FALSE);
         }
         if (!CastToBool(stack.back())) {
             return set_error(serror, ScriptError::EVAL_FALSE);
         }
     }
 
     // The CLEANSTACK check is only performed after potential P2SH evaluation,
     // as the non-P2SH evaluation of a P2SH script will obviously not result in
     // a clean stack (the P2SH inputs remain). The same holds for witness
     // evaluation.
     if ((flags & SCRIPT_VERIFY_CLEANSTACK) != 0) {
         // Disallow CLEANSTACK without P2SH, as otherwise a switch
         // CLEANSTACK->P2SH+CLEANSTACK would be possible, which is not a
         // softfork (and P2SH should be one).
         assert((flags & SCRIPT_VERIFY_P2SH) != 0);
         if (stack.size() != 1) {
             return set_error(serror, ScriptError::CLEANSTACK);
         }
     }
 
     if (flags & SCRIPT_VERIFY_INPUT_SIGCHECKS) {
         // This limit is intended for standard use, and is based on an
         // examination of typical and historical standard uses.
         // - allowing P2SH ECDSA multisig with compressed keys, which at an
         // extreme (1-of-15) may have 15 SigChecks in ~590 bytes of scriptSig.
         // - allowing Bare ECDSA multisig, which at an extreme (1-of-3) may have
         // 3 sigchecks in ~72 bytes of scriptSig.
         // - Since the size of an input is 41 bytes + length of scriptSig, then
         // the most dense possible inputs satisfying this rule would be:
         //   2 sigchecks and 26 bytes: 1/33.50 sigchecks/byte.
         //   3 sigchecks and 69 bytes: 1/36.66 sigchecks/byte.
         // The latter can be readily done with 1-of-3 bare multisignatures,
         // however the former is not practically doable with standard scripts,
         // so the practical density limit is 1/36.66.
         static_assert(INT_MAX > MAX_SCRIPT_SIZE,
                       "overflow sanity check on max script size");
         static_assert(INT_MAX / 43 / 3 > MAX_OPS_PER_SCRIPT,
                       "overflow sanity check on maximum possible sigchecks "
                       "from sig+redeem+pub scripts");
         if (int(scriptSig.size()) < metrics.nSigChecks * 43 - 60) {
             return set_error(serror, ScriptError::INPUT_SIGCHECKS);
         }
     }
 
     // Prior to activation of this flag, all transactions will count as having a
     // sigchecks count of 0 for accounting purposes outside of VerifyScript.
     if (!(flags & SCRIPT_REPORT_SIGCHECKS)) {
         metrics.nSigChecks = 0;
     }
 
     metricsOut = metrics;
     return set_success(serror);
 }
diff --git a/src/script/script_flags.h b/src/script/script_flags.h
index 53383202b5..fad66b31ae 100644
--- a/src/script/script_flags.h
+++ b/src/script/script_flags.h
@@ -1,120 +1,117 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2016 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef BITCOIN_SCRIPT_SCRIPT_FLAGS_H
 #define BITCOIN_SCRIPT_SCRIPT_FLAGS_H
 
 /** Script verification flags */
 enum {
     SCRIPT_VERIFY_NONE = 0,
 
     // Evaluate P2SH subscripts (softfork safe, BIP16).
     // Note: The Segwit Recovery feature is an exception to P2SH
     SCRIPT_VERIFY_P2SH = (1U << 0),
 
     // Passing a non-strict-DER signature or one with undefined hashtype to a
     // checksig operation causes script failure. Evaluating a pubkey that is not
     // (0x04 + 64 bytes) or (0x02 or 0x03 + 32 bytes) by checksig causes script
     // failure.
     SCRIPT_VERIFY_STRICTENC = (1U << 1),
 
     // Passing a non-strict-DER signature to a checksig operation causes script
     // failure (BIP62 rule 1)
     SCRIPT_VERIFY_DERSIG = (1U << 2),
 
     // Passing a non-strict-DER signature or one with S > order/2 to a checksig
     // operation causes script failure
     // (BIP62 rule 5).
     SCRIPT_VERIFY_LOW_S = (1U << 3),
 
     // Using a non-push operator in the scriptSig causes script failure
     // (BIP62 rule 2).
     SCRIPT_VERIFY_SIGPUSHONLY = (1U << 5),
 
     // Require minimal encodings for all push operations (OP_0... OP_16,
     // OP_1NEGATE where possible, direct pushes up to 75 bytes, OP_PUSHDATA up
     // to 255 bytes, OP_PUSHDATA2 for anything larger). Evaluating any other
     // push causes the script to fail (BIP62 rule 3). In addition, whenever a
     // stack element is interpreted as a number, it must be of minimal length
     // (BIP62 rule 4).
     SCRIPT_VERIFY_MINIMALDATA = (1U << 6),
 
     // Discourage use of NOPs reserved for upgrades (NOP1-10)
     //
     // Provided so that nodes can avoid accepting or mining transactions
     // containing executed NOP's whose meaning may change after a soft-fork,
     // thus rendering the script invalid; with this flag set executing
     // discouraged NOPs fails the script. This verification flag will never be a
     // mandatory flag applied to scripts in a block. NOPs that are not executed,
     // e.g.  within an unexecuted IF ENDIF block, are *not* rejected.
     SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS = (1U << 7),
 
     // Require that only a single stack element remains after evaluation. This
     // changes the success criterion from "At least one stack element must
     // remain, and when interpreted as a boolean, it must be true" to "Exactly
     // one stack element must remain, and when interpreted as a boolean, it must
     // be true".
     // (BIP62 rule 6)
     // Note: CLEANSTACK should never be used without P2SH.
     // Note: The Segwit Recovery feature is an exception to CLEANSTACK
     SCRIPT_VERIFY_CLEANSTACK = (1U << 8),
 
     // Verify CHECKLOCKTIMEVERIFY
     //
     // See BIP65 for details.
     SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY = (1U << 9),
 
     // support CHECKSEQUENCEVERIFY opcode
     //
     // See BIP112 for details
     SCRIPT_VERIFY_CHECKSEQUENCEVERIFY = (1U << 10),
 
     // Require the argument of OP_IF/NOTIF to be exactly 0x01 or empty vector
     //
     SCRIPT_VERIFY_MINIMALIF = (1U << 13),
 
     // Signature(s) must be empty vector if an CHECK(MULTI)SIG operation failed
     //
     SCRIPT_VERIFY_NULLFAIL = (1U << 14),
 
     // Do we accept signature using SIGHASH_FORKID
     //
     SCRIPT_ENABLE_SIGHASH_FORKID = (1U << 16),
 
     // Do we accept activate replay protection using a different fork id.
     //
     SCRIPT_ENABLE_REPLAY_PROTECTION = (1U << 17),
 
     // Count sigops for OP_CHECKDATASIG and variant. The interpreter treats
     // OP_CHECKDATASIG(VERIFY) as always valid. This flag only affects sigops
     // counting, and will be removed during cleanup of the SigChecks upgrade.
     SCRIPT_VERIFY_CHECKDATASIG_SIGOPS = (1U << 18),
 
     // The exception to CLEANSTACK and P2SH for the recovery of coins sent
     // to p2sh segwit addresses is not allowed.
     SCRIPT_DISALLOW_SEGWIT_RECOVERY = (1U << 20),
 
     // Whether to allow new OP_CHECKMULTISIG logic to trigger. (new multisig
     // logic verifies faster, and only allows Schnorr signatures)
     SCRIPT_ENABLE_SCHNORR_MULTISIG = (1U << 21),
 
     // Require the number of sigchecks in an input to satisfy a specific
     // bound, defined by scriptSig length.
     // Note: The Segwit Recovery feature is a (currently moot) exception to
     // VERIFY_INPUT_SIGCHECKS
     SCRIPT_VERIFY_INPUT_SIGCHECKS = (1U << 22),
 
-    // Whether the new OP_REVERSEBYTES opcode can be used.
-    SCRIPT_ENABLE_OP_REVERSEBYTES = (1U << 23),
-
     // A utility flag to decide whether VerifyScript should output the correct
     // sigchecks value or to report zero.
     // This has no effect on script success / failure, and will be removed
     // after cleanup of the SigChecks upgrade.
     SCRIPT_REPORT_SIGCHECKS = (1U << 31),
 };
 
 #endif // BITCOIN_SCRIPT_SCRIPT_FLAGS_H
diff --git a/src/test/data/script_tests.json b/src/test/data/script_tests.json
index 7a6e0b3863..06fc3a5853 100644
--- a/src/test/data/script_tests.json
+++ b/src/test/data/script_tests.json
@@ -1,3528 +1,3525 @@
 [
 ["Format is: [[wit..., amount]?, scriptSig, scriptPubKey, flags, expected_scripterror, ... comments]"],
 ["It is evaluated as if there was a crediting coinbase transaction with two 0"],
 ["pushes as scriptSig, and one output of 0 satoshi and given scriptPubKey,"],
 ["followed by a spending transaction which spends this output as only input (and"],
 ["correct prevout hash), using the given scriptSig. All nLockTimes are 0, all"],
 ["nSequences are max."],
 
 ["", "DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK", "Test the test: we should have an empty stack after scriptSig evaluation"],
 ["  ", "DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK", "and multiple spaces should not change that."],
 ["   ", "DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["    ", "DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 2", "2 EQUALVERIFY 1 EQUAL", "P2SH,STRICTENC", "OK", "Similarly whitespace around and between symbols"],
 ["1  2", "2 EQUALVERIFY 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["  1  2", "2 EQUALVERIFY 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1  2  ", "2 EQUALVERIFY 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["  1  2  ", "2 EQUALVERIFY 1 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["1", "", "P2SH,STRICTENC", "OK"],
 ["0x02 0x0100", "", "P2SH,STRICTENC", "OK", "all bytes are significant, not only the last one"],
 ["0x09 0x000000000000000010", "", "P2SH,STRICTENC", "OK", "equals zero when cast to Int64"],
 
 ["0x01 0x0b", "11 EQUAL", "P2SH,STRICTENC", "OK", "push 1 byte"],
 ["0x02 0x417a", "'Az' EQUAL", "P2SH,STRICTENC", "OK"],
 ["0x4b 0x417a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a7a",
  "'Azzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz' EQUAL", "P2SH,STRICTENC", "OK", "push 75 bytes"],
 
 ["PUSHDATA1 0x01 0x07","7 EQUAL", "P2SH,STRICTENC", "OK"],
 ["PUSHDATA2 0x0100 0x08","8 EQUAL", "P2SH,STRICTENC", "OK"],
 ["PUSHDATA4 0x01000000 0x09","9 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["PUSHDATA1 0x00","0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["PUSHDATA2 0x0000","0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["PUSHDATA4 0x00000000","0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0x4f 1000 ADD","999 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0x50 ENDIF 1", "P2SH,STRICTENC", "OK", "0x50 is reserved (ok if not executed)"],
 ["0x51", "0x5f ADD 0x60 EQUAL", "P2SH,STRICTENC", "OK", "0x51 through 0x60 push 1 through 16 onto stack"],
 ["1","NOP", "P2SH,STRICTENC", "OK"],
 ["0", "IF VER ELSE 1 ENDIF", "P2SH,STRICTENC", "OK", "VER non-functional (ok if not executed)"],
 ["0", "IF RESERVED RESERVED1 RESERVED2 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK", "RESERVED ok in un-executed IF"],
 
 ["1", "DUP IF ENDIF", "P2SH,STRICTENC", "OK"],
 ["1", "IF 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["1", "DUP IF ELSE ENDIF", "P2SH,STRICTENC", "OK"],
 ["1", "IF 1 ELSE ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 
 ["1 1", "IF IF 1 ELSE 0 ENDIF ENDIF", "P2SH,STRICTENC", "OK"],
 ["1 0", "IF IF 1 ELSE 0 ENDIF ENDIF", "P2SH,STRICTENC", "OK"],
 ["1 1", "IF IF 1 ELSE 0 ENDIF ELSE IF 0 ELSE 1 ENDIF ENDIF", "P2SH,STRICTENC", "OK"],
 ["0 0", "IF IF 1 ELSE 0 ENDIF ELSE IF 0 ELSE 1 ENDIF ENDIF", "P2SH,STRICTENC", "OK"],
 
 ["1 0", "NOTIF IF 1 ELSE 0 ENDIF ENDIF", "P2SH,STRICTENC", "OK"],
 ["1 1", "NOTIF IF 1 ELSE 0 ENDIF ENDIF", "P2SH,STRICTENC", "OK"],
 ["1 0", "NOTIF IF 1 ELSE 0 ENDIF ELSE IF 0 ELSE 1 ENDIF ENDIF", "P2SH,STRICTENC", "OK"],
 ["0 1", "NOTIF IF 1 ELSE 0 ENDIF ELSE IF 0 ELSE 1 ENDIF ENDIF", "P2SH,STRICTENC", "OK"],
 
 ["0", "IF 0 ELSE 1 ELSE 0 ENDIF", "P2SH,STRICTENC", "OK", "Multiple ELSE's are valid and executed inverts on each ELSE encountered"],
 ["1", "IF 1 ELSE 0 ELSE ENDIF", "P2SH,STRICTENC", "OK"],
 ["1", "IF ELSE 0 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["1", "IF 1 ELSE 0 ELSE 1 ENDIF ADD 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'' 1", "IF SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ENDIF 0x14 0x68ca4fec736264c13b859bac43d5173df6871682 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["1", "NOTIF 0 ELSE 1 ELSE 0 ENDIF", "P2SH,STRICTENC", "OK", "Multiple ELSE's are valid and execution inverts on each ELSE encountered"],
 ["0", "NOTIF 1 ELSE 0 ELSE ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "NOTIF ELSE 0 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "NOTIF 1 ELSE 0 ELSE 1 ENDIF ADD 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'' 0", "NOTIF SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ELSE ELSE SHA1 ENDIF 0x14 0x68ca4fec736264c13b859bac43d5173df6871682 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["0", "IF 1 IF RETURN ELSE RETURN ELSE RETURN ENDIF ELSE 1 IF 1 ELSE RETURN ELSE 1 ENDIF ELSE RETURN ENDIF ADD 2 EQUAL", "P2SH,STRICTENC", "OK", "Nested ELSE ELSE"],
 ["1", "NOTIF 0 NOTIF RETURN ELSE RETURN ELSE RETURN ENDIF ELSE 0 NOTIF 1 ELSE RETURN ELSE 1 ENDIF ELSE RETURN ENDIF ADD 2 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["0", "IF RETURN ENDIF 1", "P2SH,STRICTENC", "OK", "RETURN only works if executed"],
 
 ["1 1", "VERIFY", "P2SH,STRICTENC", "OK"],
 ["1 0x05 0x0100000000", "VERIFY", "P2SH,STRICTENC", "OK", "values >4 bytes can be cast to boolean"],
 ["1 0x01 0x80", "IF 0 ENDIF", "P2SH,STRICTENC", "OK", "negative 0 is false"],
 
 ["10 0 11 TOALTSTACK DROP FROMALTSTACK", "ADD 21 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'gavin_was_here' TOALTSTACK 11 FROMALTSTACK", "'gavin_was_here' EQUALVERIFY 11 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["0 IFDUP", "DEPTH 1 EQUALVERIFY 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 IFDUP", "DEPTH 2 EQUALVERIFY 1 EQUALVERIFY 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0x05 0x0100000000 IFDUP", "DEPTH 2 EQUALVERIFY 0x05 0x0100000000 EQUAL", "P2SH,STRICTENC", "OK", "IFDUP dups non ints"],
 ["0 DROP", "DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0", "DUP 1 ADD 1 EQUALVERIFY 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0 1", "NIP", "P2SH,STRICTENC", "OK"],
 ["1 0", "OVER DEPTH 3 EQUALVERIFY", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "0 PICK 20 EQUALVERIFY DEPTH 3 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "1 PICK 21 EQUALVERIFY DEPTH 3 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "2 PICK 22 EQUALVERIFY DEPTH 3 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "0 ROLL 20 EQUALVERIFY DEPTH 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "1 ROLL 21 EQUALVERIFY DEPTH 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "2 ROLL 22 EQUALVERIFY DEPTH 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "ROT 22 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "ROT DROP 20 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "ROT DROP DROP 21 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "ROT ROT 21 EQUAL", "P2SH,STRICTENC", "OK"],
 ["22 21 20", "ROT ROT ROT 20 EQUAL", "P2SH,STRICTENC", "OK"],
 ["25 24 23 22 21 20", "2ROT 24 EQUAL", "P2SH,STRICTENC", "OK"],
 ["25 24 23 22 21 20", "2ROT DROP 25 EQUAL", "P2SH,STRICTENC", "OK"],
 ["25 24 23 22 21 20", "2ROT 2DROP 20 EQUAL", "P2SH,STRICTENC", "OK"],
 ["25 24 23 22 21 20", "2ROT 2DROP DROP 21 EQUAL", "P2SH,STRICTENC", "OK"],
 ["25 24 23 22 21 20", "2ROT 2DROP 2DROP 22 EQUAL", "P2SH,STRICTENC", "OK"],
 ["25 24 23 22 21 20", "2ROT 2DROP 2DROP DROP 23 EQUAL", "P2SH,STRICTENC", "OK"],
 ["25 24 23 22 21 20", "2ROT 2ROT 22 EQUAL", "P2SH,STRICTENC", "OK"],
 ["25 24 23 22 21 20", "2ROT 2ROT 2ROT 20 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 0", "SWAP 1 EQUALVERIFY 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0 1", "TUCK DEPTH 3 EQUALVERIFY SWAP 2DROP", "P2SH,STRICTENC", "OK"],
 ["13 14", "2DUP ROT EQUALVERIFY EQUAL", "P2SH,STRICTENC", "OK"],
 ["-1 0 1 2", "3DUP DEPTH 7 EQUALVERIFY ADD ADD 3 EQUALVERIFY 2DROP 0 EQUALVERIFY", "P2SH,STRICTENC", "OK"],
 ["1 2 3 5", "2OVER ADD ADD 8 EQUALVERIFY ADD ADD 6 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 3 5 7", "2SWAP ADD 4 EQUALVERIFY ADD 12 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0", "SIZE 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1", "SIZE 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["127", "SIZE 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["128", "SIZE 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["32767", "SIZE 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["32768", "SIZE 3 EQUAL", "P2SH,STRICTENC", "OK"],
 ["8388607", "SIZE 3 EQUAL", "P2SH,STRICTENC", "OK"],
 ["8388608", "SIZE 4 EQUAL", "P2SH,STRICTENC", "OK"],
 ["2147483647", "SIZE 4 EQUAL", "P2SH,STRICTENC", "OK"],
 ["2147483648", "SIZE 5 EQUAL", "P2SH,STRICTENC", "OK"],
 ["549755813887", "SIZE 5 EQUAL", "P2SH,STRICTENC", "OK"],
 ["549755813888", "SIZE 6 EQUAL", "P2SH,STRICTENC", "OK"],
 ["9223372036854775807", "SIZE 8 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-1", "SIZE 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-127", "SIZE 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-128", "SIZE 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-32767", "SIZE 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-32768", "SIZE 3 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-8388607", "SIZE 3 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-8388608", "SIZE 4 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-2147483647", "SIZE 4 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-2147483648", "SIZE 5 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-549755813887", "SIZE 5 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-549755813888", "SIZE 6 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-9223372036854775807", "SIZE 8 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'abcdefghijklmnopqrstuvwxyz'", "SIZE 26 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["42", "SIZE 1 EQUALVERIFY 42 EQUAL", "P2SH,STRICTENC", "OK", "SIZE does not consume argument"],
 
 ["2 -2 ADD", "0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["2147483647 -2147483647 ADD", "0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-1 -1 ADD", "-2 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["0 0","EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 1 ADD", "2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 1ADD", "2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["111 1SUB", "110 EQUAL", "P2SH,STRICTENC", "OK"],
 ["111 1 ADD 12 SUB", "100 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0 ABS", "0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["16 ABS", "16 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-16 ABS", "-16 NEGATE EQUAL", "P2SH,STRICTENC", "OK"],
 ["0 NOT", "NOP", "P2SH,STRICTENC", "OK"],
 ["1 NOT", "0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["11 NOT", "0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0 0NOTEQUAL", "0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 0NOTEQUAL", "1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["111 0NOTEQUAL", "1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-111 0NOTEQUAL", "1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 1 BOOLAND", "NOP", "P2SH,STRICTENC", "OK"],
 ["1 0 BOOLAND", "NOT", "P2SH,STRICTENC", "OK"],
 ["0 1 BOOLAND", "NOT", "P2SH,STRICTENC", "OK"],
 ["0 0 BOOLAND", "NOT", "P2SH,STRICTENC", "OK"],
 ["16 17 BOOLAND", "NOP", "P2SH,STRICTENC", "OK"],
 ["1 1 BOOLOR", "NOP", "P2SH,STRICTENC", "OK"],
 ["1 0 BOOLOR", "NOP", "P2SH,STRICTENC", "OK"],
 ["0 1 BOOLOR", "NOP", "P2SH,STRICTENC", "OK"],
 ["0 0 BOOLOR", "NOT", "P2SH,STRICTENC", "OK"],
 ["0x01 0x80", "DUP BOOLOR", "P2SH,STRICTENC", "EVAL_FALSE", "negative-0 negative-0 BOOLOR"],
 ["0x01 0x00", "DUP BOOLOR", "P2SH,STRICTENC", "EVAL_FALSE", " non-minimal-0  non-minimal-0 BOOLOR"],
 ["0x01 0x81", "DUP BOOLOR", "P2SH,STRICTENC", "OK", "-1 -1 BOOLOR"],
 ["0x01 0x80", "DUP BOOLAND", "P2SH,STRICTENC", "EVAL_FALSE", "negative-0 negative-0 BOOLAND"],
 ["0x01 0x00", "DUP BOOLAND", "P2SH,STRICTENC", "EVAL_FALSE", " non-minimal-0  non-minimal-0 BOOLAND"],
 ["0x01 0x81", "DUP BOOLAND", "P2SH,STRICTENC", "OK", "-1 -1 BOOLAND"],
 ["0x01 0x00", "NOT", "P2SH,STRICTENC", "OK", "non-minimal-0 NOT"],
 ["0x01 0x80", "NOT", "P2SH,STRICTENC", "OK", "negative-0 NOT"],
 ["0x01 0x81", "NOT", "P2SH,STRICTENC", "EVAL_FALSE", "negative 1 NOT"],
 ["0x01 0x80 0", "NUMEQUAL", "P2SH", "OK", "-0 0 NUMEQUAL"],
 ["0x01 0x00 0", "NUMEQUAL", "P2SH", "OK", "non-minimal-0 0 NUMEQUAL"],
 ["0x02 0x0000 0", "NUMEQUAL", "P2SH", "OK", "non-minimal-0 0 NUMEQUAL"],
 ["16 17 BOOLOR", "NOP", "P2SH,STRICTENC", "OK"],
 ["11 10 1 ADD", "NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["11 10 1 ADD", "NUMEQUALVERIFY 1", "P2SH,STRICTENC", "OK"],
 ["11 10 1 ADD", "NUMNOTEQUAL NOT", "P2SH,STRICTENC", "OK"],
 ["111 10 1 ADD", "NUMNOTEQUAL", "P2SH,STRICTENC", "OK"],
 ["11 10", "LESSTHAN NOT", "P2SH,STRICTENC", "OK"],
 ["4 4", "LESSTHAN NOT", "P2SH,STRICTENC", "OK"],
 ["10 11", "LESSTHAN", "P2SH,STRICTENC", "OK"],
 ["-11 11", "LESSTHAN", "P2SH,STRICTENC", "OK"],
 ["-11 -10", "LESSTHAN", "P2SH,STRICTENC", "OK"],
 ["11 10", "GREATERTHAN", "P2SH,STRICTENC", "OK"],
 ["4 4", "GREATERTHAN NOT", "P2SH,STRICTENC", "OK"],
 ["10 11", "GREATERTHAN NOT", "P2SH,STRICTENC", "OK"],
 ["-11 11", "GREATERTHAN NOT", "P2SH,STRICTENC", "OK"],
 ["-11 -10", "GREATERTHAN NOT", "P2SH,STRICTENC", "OK"],
 ["11 10", "LESSTHANOREQUAL NOT", "P2SH,STRICTENC", "OK"],
 ["4 4", "LESSTHANOREQUAL", "P2SH,STRICTENC", "OK"],
 ["10 11", "LESSTHANOREQUAL", "P2SH,STRICTENC", "OK"],
 ["-11 11", "LESSTHANOREQUAL", "P2SH,STRICTENC", "OK"],
 ["-11 -10", "LESSTHANOREQUAL", "P2SH,STRICTENC", "OK"],
 ["11 10", "GREATERTHANOREQUAL", "P2SH,STRICTENC", "OK"],
 ["4 4", "GREATERTHANOREQUAL", "P2SH,STRICTENC", "OK"],
 ["10 11", "GREATERTHANOREQUAL NOT", "P2SH,STRICTENC", "OK"],
 ["-11 11", "GREATERTHANOREQUAL NOT", "P2SH,STRICTENC", "OK"],
 ["-11 -10", "GREATERTHANOREQUAL NOT", "P2SH,STRICTENC", "OK"],
 ["1 0 MIN", "0 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0 1 MIN", "0 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["-1 0 MIN", "-1 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0 -2147483647 MIN", "-2147483647 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["2147483647 0 MAX", "2147483647 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0 100 MAX", "100 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["-100 0 MAX", "0 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0 -2147483647 MAX", "0 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0 0 1", "WITHIN", "P2SH,STRICTENC", "OK"],
 ["1 0 1", "WITHIN NOT", "P2SH,STRICTENC", "OK"],
 ["0 -2147483647 2147483647", "WITHIN", "P2SH,STRICTENC", "OK"],
 ["-1 -100 100", "WITHIN", "P2SH,STRICTENC", "OK"],
 ["11 -100 100", "WITHIN", "P2SH,STRICTENC", "OK"],
 ["-2147483647 -100 100", "WITHIN NOT", "P2SH,STRICTENC", "OK"],
 ["2147483647 -100 100", "WITHIN NOT", "P2SH,STRICTENC", "OK"],
 
 ["2147483647 2147483647 SUB", "0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["2147483647 DUP ADD", "4294967294 EQUAL", "P2SH,STRICTENC", "OK", ">32 bit EQUAL is valid"],
 ["2147483647 NEGATE DUP ADD", "-4294967294 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["''", "RIPEMD160 0x14 0x9c1185a5c5e9fc54612808977ee8f548b2258d31 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'a'", "RIPEMD160 0x14 0x0bdc9d2d256b3ee9daae347be6f4dc835a467ffe EQUAL", "P2SH,STRICTENC", "OK"],
 ["'abcdefghijklmnopqrstuvwxyz'", "RIPEMD160 0x14 0xf71c27109c692c1b56bbdceb5b9d2865b3708dbc EQUAL", "P2SH,STRICTENC", "OK"],
 ["''", "SHA1 0x14 0xda39a3ee5e6b4b0d3255bfef95601890afd80709 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'a'", "SHA1 0x14 0x86f7e437faa5a7fce15d1ddcb9eaeaea377667b8 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'abcdefghijklmnopqrstuvwxyz'", "SHA1 0x14 0x32d10c7b8cf96570ca04ce37f2a19d84240d3a89 EQUAL", "P2SH,STRICTENC", "OK"],
 ["''", "SHA256 0x20 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'a'", "SHA256 0x20 0xca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb EQUAL", "P2SH,STRICTENC", "OK"],
 ["'abcdefghijklmnopqrstuvwxyz'", "SHA256 0x20 0x71c480df93d6ae2f1efad1447c66c9525e316218cf51fc8d9ed832f2daf18b73 EQUAL", "P2SH,STRICTENC", "OK"],
 ["''", "DUP HASH160 SWAP SHA256 RIPEMD160 EQUAL", "P2SH,STRICTENC", "OK"],
 ["''", "DUP HASH256 SWAP SHA256 SHA256 EQUAL", "P2SH,STRICTENC", "OK"],
 ["''", "NOP HASH160 0x14 0xb472a266d0bd89c13706a4132ccfb16f7c3b9fcb EQUAL", "P2SH,STRICTENC", "OK"],
 ["'a'", "HASH160 NOP 0x14 0x994355199e516ff76c4fa4aab39337b9d84cf12b EQUAL", "P2SH,STRICTENC", "OK"],
 ["'abcdefghijklmnopqrstuvwxyz'", "HASH160 PUSHDATA1 0x14 0xc286a1af0947f58d1ad787385b1c2c4a976f9e71 EQUAL", "P2SH,STRICTENC", "OK"],
 ["''", "HASH256 0x20 0x5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'a'", "HASH256 0x20 0xbf5d3affb73efd2ec6c36ad3112dd933efed63c4e1cbffcfa88e2759c144f2d8 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'abcdefghijklmnopqrstuvwxyz'", "HASH256 PUSHDATA1 0x20 0xca139bc10c2f660da42666f72e89a225936fc60f193c161124a672050c434671 EQUAL", "P2SH,STRICTENC", "OK"],
 
 
 ["1","NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["'NOP_1_to_10' NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10","'NOP_1_to_10' EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["1", "NOP", "P2SH,STRICTENC,DISCOURAGE_UPGRADABLE_NOPS", "OK", "Discourage NOPx flag allows OP_NOP"],
 
 ["0", "IF NOP10 ENDIF 1", "P2SH,STRICTENC,DISCOURAGE_UPGRADABLE_NOPS", "OK",
  "Discouraged NOPs are allowed if not executed"],
 
 ["0", "IF CHECKDATASIG ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF CHECKDATASIGVERIFY ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF REVERSEBYTES ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xbd ELSE 1 ENDIF", "P2SH,STRICTENC", "OK", "opcodes >= FIRST_UNDEFINED_OP_VALUE invalid if executed"],
 ["0", "IF 0xbe ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xbf ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc0 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc1 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc2 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc3 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc4 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc5 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc6 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc7 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc8 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xc9 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xca ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xcb ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xcc ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xcd ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xce ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xcf ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd0 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd1 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd2 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd3 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd4 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd5 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd6 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd7 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd8 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xd9 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xda ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xdb ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xdc ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xdd ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xde ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xdf ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe0 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe1 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe2 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe3 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe4 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe5 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe6 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe7 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe8 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xe9 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xea ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xeb ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xec ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xed ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xee ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xef ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf0 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf1 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf2 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf3 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf4 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf5 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf6 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf7 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf8 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xf9 ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xfa ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xfb ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xfc ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xfd ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xfe ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 ["0", "IF 0xff ELSE 1 ENDIF", "P2SH,STRICTENC", "OK"],
 
 ["NOP",
 "'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'",
 "P2SH,STRICTENC", "OK",
 "520 byte push"],
 ["1",
 "0x616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161",
 "P2SH,STRICTENC", "OK",
 "201 opcodes executed. 0x61 is NOP"],
 ["1 2 3 4 5 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f",
 "1 2 3 4 5 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f",
 "P2SH,STRICTENC", "OK",
 "1,000 stack size (0x6f is 3DUP)"],
 ["1 TOALTSTACK 2 TOALTSTACK 3 4 5 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f",
 "1 2 3 4 5 6 7 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f",
 "P2SH,STRICTENC", "OK",
 "1,000 stack size (altstack cleared between scriptSig/scriptPubKey)"],
 ["'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f",
 "'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f 2DUP 0x616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161",
 "P2SH,STRICTENC", "OK",
 "Max-size (10,000-byte), max-push(520 bytes), max-opcodes(201), max stack size(1,000 items). 0x6f is 3DUP, 0x61 is NOP"],
 
 ["0",
 "IF 0x5050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050505050 ENDIF 1",
 "P2SH,STRICTENC", "OK",
 ">201 opcodes, but RESERVED (0x50) doesn't count towards opcode limit."],
 
 ["NOP","1", "P2SH,STRICTENC", "OK"],
 
 ["1", "0x01 0x01 EQUAL", "P2SH,STRICTENC", "OK", "The following is useful for checking implementations of BN_bn2mpi"],
 ["127", "0x01 0x7F EQUAL", "P2SH,STRICTENC", "OK"],
 ["128", "0x02 0x8000 EQUAL", "P2SH,STRICTENC", "OK", "Leave room for the sign bit"],
 ["32767", "0x02 0xFF7F EQUAL", "P2SH,STRICTENC", "OK"],
 ["32768", "0x03 0x008000 EQUAL", "P2SH,STRICTENC", "OK"],
 ["8388607", "0x03 0xFFFF7F EQUAL", "P2SH,STRICTENC", "OK"],
 ["8388608", "0x04 0x00008000 EQUAL", "P2SH,STRICTENC", "OK"],
 ["2147483647", "0x04 0xFFFFFF7F EQUAL", "P2SH,STRICTENC", "OK"],
 ["2147483648", "0x05 0x0000008000 EQUAL", "P2SH,STRICTENC", "OK"],
 ["549755813887", "0x05 0xFFFFFFFF7F EQUAL", "P2SH,STRICTENC", "OK"],
 ["549755813888", "0x06 0x000000008000 EQUAL", "P2SH,STRICTENC", "OK"],
 ["9223372036854775807", "0x08 0xFFFFFFFFFFFFFF7F EQUAL", "P2SH,STRICTENC", "OK"],
 ["-1", "0x01 0x81 EQUAL", "P2SH,STRICTENC", "OK", "Numbers are little-endian with the MSB being a sign bit"],
 ["-127", "0x01 0xFF EQUAL", "P2SH,STRICTENC", "OK"],
 ["-128", "0x02 0x8080 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-32767", "0x02 0xFFFF EQUAL", "P2SH,STRICTENC", "OK"],
 ["-32768", "0x03 0x008080 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-8388607", "0x03 0xFFFFFF EQUAL", "P2SH,STRICTENC", "OK"],
 ["-8388608", "0x04 0x00008080 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-2147483647", "0x04 0xFFFFFFFF EQUAL", "P2SH,STRICTENC", "OK"],
 ["-2147483648", "0x05 0x0000008080 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-4294967295", "0x05 0xFFFFFFFF80 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-549755813887", "0x05 0xFFFFFFFFFF EQUAL", "P2SH,STRICTENC", "OK"],
 ["-549755813888", "0x06 0x000000008080 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-9223372036854775807", "0x08 0xFFFFFFFFFFFFFFFF EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["2147483647", "1ADD 2147483648 EQUAL", "P2SH,STRICTENC", "OK", "We can do math on 4-byte integers, and compare 5-byte ones"],
 ["2147483647", "1ADD 1", "P2SH,STRICTENC", "OK"],
 ["-2147483647", "1ADD 1", "P2SH,STRICTENC", "OK"],
 
 ["1", "0x02 0x0100 EQUAL NOT", "P2SH,STRICTENC", "OK", "Not the same byte array..."],
 ["1", "0x02 0x0100 NUMEQUAL", "P2SH,STRICTENC", "OK", "... but they are numerically equal"],
 ["11", "PUSHDATA1 0x03 0x0b0000 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0", "0x01 0x80 EQUAL NOT", "P2SH,STRICTENC", "OK"],
 ["0", "0x01 0x80 NUMEQUAL", "P2SH,STRICTENC", "OK", "Zero numerically equals negative zero"],
 ["0", "0x02 0x0080 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0x03 0x000080", "0x04 0x00000080 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0x03 0x100080", "0x04 0x10000080 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0x03 0x100000", "0x04 0x10000000 NUMEQUAL", "P2SH,STRICTENC", "OK"],
 
 ["NOP", "NOP 1", "P2SH,STRICTENC", "OK", "The following tests check the if(stack.size() < N) tests in each opcode"],
 ["1", "IF 1 ENDIF", "P2SH,STRICTENC", "OK", "They are here to catch copy-and-paste errors"],
 ["0", "NOTIF 1 ENDIF", "P2SH,STRICTENC", "OK", "Most of them are duplicated elsewhere,"],
 ["1", "VERIFY 1", "P2SH,STRICTENC", "OK", "but, hey, more is always better, right?"],
 
 ["0", "TOALTSTACK 1", "P2SH,STRICTENC", "OK"],
 ["1", "TOALTSTACK FROMALTSTACK", "P2SH,STRICTENC", "OK"],
 ["0 0", "2DROP 1", "P2SH,STRICTENC", "OK"],
 ["0 1", "2DUP", "P2SH,STRICTENC", "OK"],
 ["0 0 1", "3DUP", "P2SH,STRICTENC", "OK"],
 ["0 1 0 0", "2OVER", "P2SH,STRICTENC", "OK"],
 ["0 1 0 0 0 0", "2ROT", "P2SH,STRICTENC", "OK"],
 ["0 1 0 0", "2SWAP", "P2SH,STRICTENC", "OK"],
 ["1", "IFDUP", "P2SH,STRICTENC", "OK"],
 ["NOP", "DEPTH 1", "P2SH,STRICTENC", "OK"],
 ["0", "DROP 1", "P2SH,STRICTENC", "OK"],
 ["1", "DUP", "P2SH,STRICTENC", "OK"],
 ["0 1", "NIP", "P2SH,STRICTENC", "OK"],
 ["1 0", "OVER", "P2SH,STRICTENC", "OK"],
 ["1 0 0 0 3", "PICK", "P2SH,STRICTENC", "OK"],
 ["1 0", "PICK", "P2SH,STRICTENC", "OK"],
 ["1 0 0 0 3", "ROLL", "P2SH,STRICTENC", "OK"],
 ["1 0", "ROLL", "P2SH,STRICTENC", "OK"],
 ["1 0 0", "ROT", "P2SH,STRICTENC", "OK"],
 ["1 0", "SWAP", "P2SH,STRICTENC", "OK"],
 ["0 1", "TUCK", "P2SH,STRICTENC", "OK"],
 
 ["1", "SIZE", "P2SH,STRICTENC", "OK"],
 
 ["0 0", "EQUAL", "P2SH,STRICTENC", "OK"],
 ["0 0", "EQUALVERIFY 1", "P2SH,STRICTENC", "OK"],
 ["0 0 1", "EQUAL EQUAL", "P2SH,STRICTENC", "OK", "OP_0 and bools must have identical byte representations"],
 
 ["0", "1ADD", "P2SH,STRICTENC", "OK"],
 ["2", "1SUB", "P2SH,STRICTENC", "OK"],
 ["-1", "NEGATE", "P2SH,STRICTENC", "OK"],
 ["-1", "ABS", "P2SH,STRICTENC", "OK"],
 ["0", "NOT", "P2SH,STRICTENC", "OK"],
 ["-1", "0NOTEQUAL", "P2SH,STRICTENC", "OK"],
 
 ["1 0", "ADD", "P2SH,STRICTENC", "OK"],
 ["1 0", "SUB", "P2SH,STRICTENC", "OK"],
 ["-1 -1", "BOOLAND", "P2SH,STRICTENC", "OK"],
 ["-1 0", "BOOLOR", "P2SH,STRICTENC", "OK"],
 ["0 0", "NUMEQUAL", "P2SH,STRICTENC", "OK"],
 ["0 0", "NUMEQUALVERIFY 1", "P2SH,STRICTENC", "OK"],
 ["-1 0", "NUMNOTEQUAL", "P2SH,STRICTENC", "OK"],
 ["-1 0", "LESSTHAN", "P2SH,STRICTENC", "OK"],
 ["1 0", "GREATERTHAN", "P2SH,STRICTENC", "OK"],
 ["0 0", "LESSTHANOREQUAL", "P2SH,STRICTENC", "OK"],
 ["0 0", "GREATERTHANOREQUAL", "P2SH,STRICTENC", "OK"],
 ["-1 0", "MIN", "P2SH,STRICTENC", "OK"],
 ["1 0", "MAX", "P2SH,STRICTENC", "OK"],
 ["-1 -1 0", "WITHIN", "P2SH,STRICTENC", "OK"],
 
 ["0", "RIPEMD160", "P2SH,STRICTENC", "OK"],
 ["0", "SHA1", "P2SH,STRICTENC", "OK"],
 ["0", "SHA256", "P2SH,STRICTENC", "OK"],
 ["0", "HASH160", "P2SH,STRICTENC", "OK"],
 ["0", "HASH256", "P2SH,STRICTENC", "OK"],
 ["NOP", "CODESEPARATOR 1", "P2SH,STRICTENC", "OK"],
 
 ["NOP", "NOP1 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "CHECKLOCKTIMEVERIFY 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "CHECKSEQUENCEVERIFY 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "NOP4 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "NOP5 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "NOP6 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "NOP7 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "NOP8 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "NOP9 1", "P2SH,STRICTENC", "OK"],
 ["NOP", "NOP10 1", "P2SH,STRICTENC", "OK"],
 
 ["", "0 0 0 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK", "CHECKMULTISIG is allowed to have zero keys and/or sigs"],
 ["", "0 0 0 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 0 1 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK", "Zero sigs means no sigs are checked"],
 ["", "0 0 0 1 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["", "0 0 'a' 'b' 2 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK", "Test from up to 20 pubkeys, all not checked"],
 ["", "0 0 'a' 'b' 'c' 3 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 4 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 5 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 6 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 7 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 8 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 9 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 10 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 11 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 12 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 13 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 14 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 15 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 16 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 17 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 18 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 19 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG VERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 1 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 2 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 3 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 4 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 5 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 6 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 7 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 8 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 9 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 10 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 11 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 12 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 13 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 14 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 15 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 16 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 17 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 18 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 19 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["", "0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY DEPTH 0 EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["",
 "0 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG",
 "P2SH,STRICTENC", "OK",
 "nOpCount is incremented by the number of keys evaluated in addition to the usual one op per op. In this case we have zero keys, so we can execute 201 CHECKMULTISIGS"],
 
 ["1",
 "0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY 0 0 0 CHECKMULTISIGVERIFY",
 "P2SH,STRICTENC", "OK"],
 
 ["",
 "NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG",
 "P2SH,STRICTENC", "OK",
 "Even though there are no signatures being checked nOpCount is incremented by the number of keys."],
 
 ["1",
 "NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY",
 "P2SH,STRICTENC", "OK"],
 
 ["0 0x01 1", "HASH160 0x14 0xda1745e9b549bd0bfa1a569971c77eba30cd5a4b EQUAL", "P2SH,STRICTENC", "OK", "Very basic P2SH"],
 ["PUSHDATA1 0x00 0x01 1", "HASH160 0x14 0xda1745e9b549bd0bfa1a569971c77eba30cd5a4b EQUAL", "P2SH,STRICTENC", "OK"],
 
 ["0x40 0x42424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242",
 "PUSHDATA2 0x4000 0x42424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242 EQUAL",
 "P2SH,STRICTENC", "OK",
 "Basic PUSH signedness check"],
 
 ["PUSHDATA1 0x40 0x42424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242",
 "PUSHDATA2 0x4000 0x42424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242424242 EQUAL",
 "P2SH,STRICTENC", "OK",
 "Basic PUSHDATA1 signedness check"],
 
 ["all PUSHDATA forms are equivalent"],
 
 ["PUSHDATA1 0x4b 0x111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "0x4b 0x111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 EQUAL", "", "OK", "PUSHDATA1 of 75 bytes equals direct push of it"],
 ["PUSHDATA2 0xFF00 0x111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "PUSHDATA1 0xFF 0x111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 EQUAL", "", "OK", "PUSHDATA2 of 255 bytes equals PUSHDATA1 of it"],
 
 ["0x00", "SIZE 0 EQUAL", "P2SH,STRICTENC", "OK", "Basic OP_0 execution"],
 
 ["Numeric pushes"],
 
 ["0x01 0x81", "0x4f EQUAL", "", "OK", "OP1_NEGATE pushes 0x81"],
 ["0x01 0x01", "0x51 EQUAL", "", "OK", "OP_1  pushes 0x01"],
 ["0x01 0x02", "0x52 EQUAL", "", "OK", "OP_2  pushes 0x02"],
 ["0x01 0x03", "0x53 EQUAL", "", "OK", "OP_3  pushes 0x03"],
 ["0x01 0x04", "0x54 EQUAL", "", "OK", "OP_4  pushes 0x04"],
 ["0x01 0x05", "0x55 EQUAL", "", "OK", "OP_5  pushes 0x05"],
 ["0x01 0x06", "0x56 EQUAL", "", "OK", "OP_6  pushes 0x06"],
 ["0x01 0x07", "0x57 EQUAL", "", "OK", "OP_7  pushes 0x07"],
 ["0x01 0x08", "0x58 EQUAL", "", "OK", "OP_8  pushes 0x08"],
 ["0x01 0x09", "0x59 EQUAL", "", "OK", "OP_9  pushes 0x09"],
 ["0x01 0x0a", "0x5a EQUAL", "", "OK", "OP_10 pushes 0x0a"],
 ["0x01 0x0b", "0x5b EQUAL", "", "OK", "OP_11 pushes 0x0b"],
 ["0x01 0x0c", "0x5c EQUAL", "", "OK", "OP_12 pushes 0x0c"],
 ["0x01 0x0d", "0x5d EQUAL", "", "OK", "OP_13 pushes 0x0d"],
 ["0x01 0x0e", "0x5e EQUAL", "", "OK", "OP_14 pushes 0x0e"],
 ["0x01 0x0f", "0x5f EQUAL", "", "OK", "OP_15 pushes 0x0f"],
 ["0x01 0x10", "0x60 EQUAL", "", "OK", "OP_16 pushes 0x10"],
 
 ["Equivalency of different numeric encodings"],
 
 ["0x02 0x8000", "128 NUMEQUAL", "", "OK", "0x8000 equals 128"],
 ["0x01 0x00", "0 NUMEQUAL", "", "OK", "0x00 numequals 0"],
 ["0x01 0x80", "0 NUMEQUAL", "", "OK", "0x80 (negative zero) numequals 0"],
 ["0x02 0x0080", "0 NUMEQUAL", "", "OK", "0x0080 numequals 0"],
 ["0x02 0x0500", "5 NUMEQUAL", "", "OK", "0x0500 numequals 5"],
 ["0x03 0xff7f80", "0x02 0xffff NUMEQUAL", "", "OK", ""],
 ["0x03 0xff7f00", "0x02 0xff7f NUMEQUAL", "", "OK", ""],
 ["0x04 0xffff7f80", "0x03 0xffffff NUMEQUAL", "", "OK", ""],
 ["0x04 0xffff7f00", "0x03 0xffff7f NUMEQUAL", "", "OK", ""],
 
 ["Unevaluated non-minimal pushes are ignored"],
 
 ["0 IF PUSHDATA1 0x00 ENDIF 1", "", "MINIMALDATA", "OK", "non-minimal PUSHDATA1 ignored"],
 ["", "0 IF PUSHDATA1 0x00 ENDIF 1", "MINIMALDATA", "OK", "non-minimal PUSHDATA1 ignored (scriptPubKey)"],
 ["0 IF PUSHDATA2 0x0000 ENDIF 1", "", "MINIMALDATA", "OK", "non-minimal PUSHDATA2 ignored"],
 ["", "0 IF PUSHDATA2 0x0000 ENDIF 1", "MINIMALDATA", "OK", "non-minimal PUSHDATA2 ignored (scriptPubKey)"],
 ["0 IF PUSHDATA4 0x00000000 ENDIF 1", "", "MINIMALDATA", "OK", "non-minimal PUSHDATA4 ignored"],
 ["", "0 IF PUSHDATA4 0x00000000 ENDIF 1", "MINIMALDATA", "OK", "non-minimal PUSHDATA4 ignored (scriptPubKey)"],
 ["0 IF 0x01 0x81 ENDIF 1", "", "MINIMALDATA", "OK", "1NEGATE equiv"],
 ["", "0 IF 0x01 0x81 ENDIF 1", "MINIMALDATA", "OK", "1NEGATE equiv (scriptPubKey)"],
 ["0 IF 0x01 0x01 ENDIF 1", "", "MINIMALDATA", "OK", "OP_1  equiv"],
 ["", "0 IF 0x01 0x01 ENDIF 1", "MINIMALDATA", "OK", "OP_1  equiv (scriptPubKey)"],
 ["0 IF 0x01 0x02 ENDIF 1", "", "MINIMALDATA", "OK", "OP_2  equiv"],
 ["", "0 IF 0x01 0x02 ENDIF 1", "MINIMALDATA", "OK", "OP_2  equiv (scriptPubKey)"],
 ["0 IF 0x01 0x03 ENDIF 1", "", "MINIMALDATA", "OK", "OP_3  equiv"],
 ["", "0 IF 0x01 0x03 ENDIF 1", "MINIMALDATA", "OK", "OP_3  equiv (scriptPubKey)"],
 ["0 IF 0x01 0x04 ENDIF 1", "", "MINIMALDATA", "OK", "OP_4  equiv"],
 ["", "0 IF 0x01 0x04 ENDIF 1", "MINIMALDATA", "OK", "OP_4  equiv (scriptPubKey)"],
 ["0 IF 0x01 0x05 ENDIF 1", "", "MINIMALDATA", "OK", "OP_5  equiv"],
 ["", "0 IF 0x01 0x05 ENDIF 1", "MINIMALDATA", "OK", "OP_5  equiv (scriptPubKey)"],
 ["0 IF 0x01 0x06 ENDIF 1", "", "MINIMALDATA", "OK", "OP_6  equiv"],
 ["", "0 IF 0x01 0x06 ENDIF 1", "MINIMALDATA", "OK", "OP_6  equiv (scriptPubKey)"],
 ["0 IF 0x01 0x07 ENDIF 1", "", "MINIMALDATA", "OK", "OP_7  equiv"],
 ["", "0 IF 0x01 0x07 ENDIF 1", "MINIMALDATA", "OK", "OP_7  equiv (scriptPubKey)"],
 ["0 IF 0x01 0x08 ENDIF 1", "", "MINIMALDATA", "OK", "OP_8  equiv"],
 ["", "0 IF 0x01 0x08 ENDIF 1", "MINIMALDATA", "OK", "OP_8  equiv (scriptPubKey)"],
 ["0 IF 0x01 0x09 ENDIF 1", "", "MINIMALDATA", "OK", "OP_9  equiv"],
 ["", "0 IF 0x01 0x09 ENDIF 1", "MINIMALDATA", "OK", "OP_9  equiv (scriptPubKey)"],
 ["0 IF 0x01 0x0a ENDIF 1", "", "MINIMALDATA", "OK", "OP_10 equiv"],
 ["", "0 IF 0x01 0x0a ENDIF 1", "MINIMALDATA", "OK", "OP_10 equiv (scriptPubKey)"],
 ["0 IF 0x01 0x0b ENDIF 1", "", "MINIMALDATA", "OK", "OP_11 equiv"],
 ["", "0 IF 0x01 0x0b ENDIF 1", "MINIMALDATA", "OK", "OP_11 equiv (scriptPubKey)"],
 ["0 IF 0x01 0x0c ENDIF 1", "", "MINIMALDATA", "OK", "OP_12 equiv"],
 ["", "0 IF 0x01 0x0c ENDIF 1", "MINIMALDATA", "OK", "OP_12 equiv (scriptPubKey)"],
 ["0 IF 0x01 0x0d ENDIF 1", "", "MINIMALDATA", "OK", "OP_13 equiv"],
 ["", "0 IF 0x01 0x0d ENDIF 1", "MINIMALDATA", "OK", "OP_13 equiv (scriptPubKey)"],
 ["0 IF 0x01 0x0e ENDIF 1", "", "MINIMALDATA", "OK", "OP_14 equiv"],
 ["", "0 IF 0x01 0x0e ENDIF 1", "MINIMALDATA", "OK", "OP_14 equiv (scriptPubKey)"],
 ["0 IF 0x01 0x0f ENDIF 1", "", "MINIMALDATA", "OK", "OP_15 equiv"],
 ["", "0 IF 0x01 0x0f ENDIF 1", "MINIMALDATA", "OK", "OP_15 equiv (scriptPubKey)"],
 ["0 IF 0x01 0x10 ENDIF 1", "", "MINIMALDATA", "OK", "OP_16 equiv"],
 ["", "0 IF 0x01 0x10 ENDIF 1", "MINIMALDATA", "OK", "OP_16 equiv (scriptPubKey)"],
 
 ["Numeric minimaldata rules are only applied when a stack item is numerically evaluated; the push itself is allowed"],
 
 ["0x01 0x00", "1", "MINIMALDATA", "OK"],
 ["", "0x01 0x00 1", "MINIMALDATA", "OK"],
 ["0x01 0x80", "1", "MINIMALDATA", "OK"],
 ["", "0x01 0x80 1", "MINIMALDATA", "OK"],
 ["0x02 0x0180", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0180 1", "MINIMALDATA", "OK"],
 ["0x02 0x0100", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0100 1", "MINIMALDATA", "OK"],
 ["0x02 0x0200", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0200 1", "MINIMALDATA", "OK"],
 ["0x02 0x0300", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0300 1", "MINIMALDATA", "OK"],
 ["0x02 0x0400", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0400 1", "MINIMALDATA", "OK"],
 ["0x02 0x0500", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0500 1", "MINIMALDATA", "OK"],
 ["0x02 0x0600", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0600 1", "MINIMALDATA", "OK"],
 ["0x02 0x0700", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0700 1", "MINIMALDATA", "OK"],
 ["0x02 0x0800", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0800 1", "MINIMALDATA", "OK"],
 ["0x02 0x0900", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0900 1", "MINIMALDATA", "OK"],
 ["0x02 0x0a00", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0a00 1", "MINIMALDATA", "OK"],
 ["0x02 0x0b00", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0b00 1", "MINIMALDATA", "OK"],
 ["0x02 0x0c00", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0c00 1", "MINIMALDATA", "OK"],
 ["0x02 0x0d00", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0d00 1", "MINIMALDATA", "OK"],
 ["0x02 0x0e00", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0e00 1", "MINIMALDATA", "OK"],
 ["0x02 0x0f00", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x0f00 1", "MINIMALDATA", "OK"],
 ["0x02 0x1000", "1", "MINIMALDATA", "OK"],
 ["", "0x02 0x1000 1", "MINIMALDATA", "OK"],
 
 ["Valid version of the 'Test every numeric-accepting opcode for correct handling of the numeric minimal encoding rule' script_invalid test"],
 
 ["1 0x02 0x0000", "PICK DROP", "", "OK"],
 ["1 0x02 0x0000", "ROLL DROP 1", "", "OK"],
 ["0x02 0x0000", "1ADD DROP 1", "", "OK"],
 ["0x02 0x0000", "1SUB DROP 1", "", "OK"],
 ["0x02 0x0000", "NEGATE DROP 1", "", "OK"],
 ["0x02 0x0000", "ABS DROP 1", "", "OK"],
 ["0x02 0x0000", "NOT DROP 1", "", "OK"],
 ["0x02 0x0000", "0NOTEQUAL DROP 1", "", "OK"],
 
 ["0 0x02 0x0000", "ADD DROP 1", "", "OK"],
 ["0x02 0x0000 0", "ADD DROP 1", "", "OK"],
 ["0 0x02 0x0000", "SUB DROP 1", "", "OK"],
 ["0x02 0x0000 0", "SUB DROP 1", "", "OK"],
 ["0 0x02 0x0100", "DIV DROP 1", "", "OK"],
 ["0x02 0x0000 1", "DIV DROP 1", "", "OK"],
 ["0 0x02 0x0100", "MOD DROP 1", "", "OK"],
 ["0x02 0x0000 1", "MOD DROP 1", "", "OK"],
 ["0 0x02 0x0000", "BOOLAND DROP 1", "", "OK"],
 ["0x02 0x0000 0", "BOOLAND DROP 1", "", "OK"],
 ["0 0x02 0x0000", "BOOLOR DROP 1", "", "OK"],
 ["0x02 0x0000 0", "BOOLOR DROP 1", "", "OK"],
 ["0 0x02 0x0000", "NUMEQUAL DROP 1", "", "OK"],
 ["0x02 0x0000 1", "NUMEQUAL DROP 1", "", "OK"],
 ["0 0x02 0x0000", "NUMEQUALVERIFY 1", "", "OK"],
 ["0x02 0x0000 0", "NUMEQUALVERIFY 1", "", "OK"],
 ["0 0x02 0x0000", "NUMNOTEQUAL DROP 1", "", "OK"],
 ["0x02 0x0000 0", "NUMNOTEQUAL DROP 1", "", "OK"],
 ["0 0x02 0x0000", "LESSTHAN DROP 1", "", "OK"],
 ["0x02 0x0000 0", "LESSTHAN DROP 1", "", "OK"],
 ["0 0x02 0x0000", "GREATERTHAN DROP 1", "", "OK"],
 ["0x02 0x0000 0", "GREATERTHAN DROP 1", "", "OK"],
 ["0 0x02 0x0000", "LESSTHANOREQUAL DROP 1", "", "OK"],
 ["0x02 0x0000 0", "LESSTHANOREQUAL DROP 1", "", "OK"],
 ["0 0x02 0x0000", "GREATERTHANOREQUAL DROP 1", "", "OK"],
 ["0x02 0x0000 0", "GREATERTHANOREQUAL DROP 1", "", "OK"],
 ["0 0x02 0x0000", "MIN DROP 1", "", "OK"],
 ["0x02 0x0000 0", "MIN DROP 1", "", "OK"],
 ["0 0x02 0x0000", "MAX DROP 1", "", "OK"],
 ["0x02 0x0000 0", "MAX DROP 1", "", "OK"],
 
 ["0x02 0x0000 0 0", "WITHIN DROP 1", "", "OK"],
 ["0 0x02 0x0000 0", "WITHIN DROP 1", "", "OK"],
 ["0 0 0x02 0x0000", "WITHIN DROP 1", "", "OK"],
 
 ["0 0 0x02 0x0000", "CHECKMULTISIG DROP 1", "", "OK"],
 ["0 0x02 0x0000 0", "CHECKMULTISIG DROP 1", "", "OK"],
 ["0 0x02 0x0000 0 1", "CHECKMULTISIG DROP 1", "", "OK"],
 ["0 0 0x02 0x0000", "CHECKMULTISIGVERIFY 1", "", "OK"],
 ["0 0x02 0x0000 0", "CHECKMULTISIGVERIFY 1", "", "OK"],
 
 ["0x02 0x0000 0x02 0x0100", "SPLIT 2DROP 1", "", "OK"],
 ["0x16 0x11111111111111111111111111111111111111110000 0x02 0x1400", "NUM2BIN DROP 1", "", "OK"],
 
 ["0x02 0x0000", "CHECKLOCKTIMEVERIFY DROP 1", "CHECKLOCKTIMEVERIFY", "UNSATISFIED_LOCKTIME", "fails because final sequence, not from nonminimal encoding"],
 ["0x02 0x0000", "CHECKSEQUENCEVERIFY DROP 1", "CHECKSEQUENCEVERIFY", "UNSATISFIED_LOCKTIME", "fails because tx version < 2, not from nonminimal encoding"],
 
 ["While not really correctly DER encoded, the empty signature is allowed by"],
 ["STRICTENC to provide a compact way to provide a delibrately invalid signature."],
 ["0", "0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 CHECKSIG NOT", "STRICTENC", "OK"],
 ["0 0", "1 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 1 CHECKMULTISIG NOT", "STRICTENC", "OK"],
 ["0", "0x02 0xBEEF CHECKSIG NOT", "STRICTENC", "PUBKEYTYPE", "Even with a null signature, the public key has to be correctly encoded."],
 ["0 0", "1 0x02 0xBEEF 1 CHECKMULTISIG NOT", "STRICTENC", "PUBKEYTYPE"],
 ["0", "0x21 0x020000000000000000000000000000000000000000000000000000000000000000 CHECKSIG NOT", "STRICTENC", "OK",  "Invalid public keys are fine, as long as correctly encoded."],
 ["0 0", "1 0x21 0x020000000000000000000000000000000000000000000000000000000000000000 1 CHECKMULTISIG NOT", "STRICTENC", "OK"],
 
 ["Introducing NULLFAIL doesn't change any of the above behaviour since signature is null"],
 ["0", "0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 CHECKSIG NOT", "STRICTENC,NULLFAIL", "OK"],
 ["0 0", "1 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 1 CHECKMULTISIG NOT", "STRICTENC,NULLFAIL", "OK"],
 ["0", "0x02 0xBEEF CHECKSIG NOT", "STRICTENC,NULLFAIL", "PUBKEYTYPE"],
 ["0 0", "1 0x02 0xBEEF 1 CHECKMULTISIG NOT", "STRICTENC,NULLFAIL", "PUBKEYTYPE"],
 ["0", "0x21 0x020000000000000000000000000000000000000000000000000000000000000000 CHECKSIG NOT", "STRICTENC,NULLFAIL", "OK"],
 ["0 0", "1 0x21 0x020000000000000000000000000000000000000000000000000000000000000000 1 CHECKMULTISIG NOT", "STRICTENC,NULLFAIL", "OK"],
 
 ["CHECKMULTISIG evaluation order tests. CHECKMULTISIG evaluates signatures and"],
 ["pubkeys in a specific order, and will exit early if the number of signatures"],
 ["left to check is greater than the number of keys left. As STRICTENC fails the"],
 ["script when it reaches an invalidly encoded signature or pubkey, we can use it"],
 ["to test the exact order in which signatures and pubkeys are evaluated by"],
 ["distinguishing CHECKMULTISIG returning false on the stack and the script as a"],
 ["whole failing."],
 ["See also the corresponding inverted versions of these tests in script_invalid.json"],
 [
     "0 0x47 0x3044022044dc17b0887c161bb67ba9635bf758735bdde503e4b0a0987f587f14a4e1143d022009a215772d49a85dae40d8ca03955af26ad3978a0ff965faa12915e9586249a501 0x47 0x3044022044dc17b0887c161bb67ba9635bf758735bdde503e4b0a0987f587f14a4e1143d022009a215772d49a85dae40d8ca03955af26ad3978a0ff965faa12915e9586249a501",
     "2 0 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 2 CHECKMULTISIG NOT",
     "STRICTENC", "OK",
     "2-of-2 CHECKMULTISIG NOT with the second pubkey invalid, and both signatures validly encoded. Valid pubkey fails, and CHECKMULTISIG exits early, prior to evaluation of second invalid pubkey."
 ],
 [
     "0 0 0x47 0x3044022044dc17b0887c161bb67ba9635bf758735bdde503e4b0a0987f587f14a4e1143d022009a215772d49a85dae40d8ca03955af26ad3978a0ff965faa12915e9586249a501",
     "2 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 2 CHECKMULTISIG NOT",
     "STRICTENC", "OK",
     "2-of-2 CHECKMULTISIG NOT with both pubkeys valid, but second signature invalid. Valid pubkey fails, and CHECKMULTISIG exits early, prior to evaluation of second invalid signature."
 ],
 
 ["STRICTENC+NULLFAIL ordering tests with null signatures"],
 [
     "0 0 0",
     "2 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 2 CHECKMULTISIG NOT",
     "P2SH,STRICTENC,NULLFAIL",
     "OK",
     "Nulled 2-of-2 with valid pubkeys"
 ],
 [
     "0 0 0",
     "2 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 0x02 0xBEEF 2 CHECKMULTISIG NOT",
     "P2SH,STRICTENC,NULLFAIL",
     "PUBKEYTYPE",
     "Nulled 2-of-2 with top pubkey invalidly encoded"
 ],
 [
     "0 0 0",
     "2 0x02 0xBEEF 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 2 CHECKMULTISIG NOT",
     "P2SH,STRICTENC,NULLFAIL",
     "OK",
     "Nulled 2-of-2 with top pubkey validly encoded, but another pubkey is invalidly encoded"
 ],
 
 ["Increase test coverage for DERSIG"],
 ["0x4a 0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0 CHECKSIG NOT", "", "OK", "Overly long signature is correctly encoded"],
 ["0x25 0x30220220000000000000000000000000000000000000000000000000000000000000000000", "0 CHECKSIG NOT", "", "OK", "Missing S is correctly encoded"],
 ["0x27 0x3024021077777777777777777777777777777777020a7777777777777777777777777777777701", "0 CHECKSIG NOT", "", "OK", "S with invalid S length is correctly encoded"],
 ["0x27 0x302403107777777777777777777777777777777702107777777777777777777777777777777701", "0 CHECKSIG NOT", "", "OK", "Non-integer R is correctly encoded"],
 ["0x27 0x302402107777777777777777777777777777777703107777777777777777777777777777777701", "0 CHECKSIG NOT", "", "OK", "Non-integer S is correctly encoded"],
 ["0x17 0x3014020002107777777777777777777777777777777701", "0 CHECKSIG NOT", "", "OK", "Zero-length R is correctly encoded"],
 ["0x17 0x3014021077777777777777777777777777777777020001", "0 CHECKSIG NOT", "", "OK", "Zero-length S is correctly encoded for DERSIG"],
 ["0x27 0x302402107777777777777777777777777777777702108777777777777777777777777777777701", "0 CHECKSIG NOT", "", "OK", "Negative S is correctly encoded"],
 
 ["2147483648", "CHECKSEQUENCEVERIFY", "CHECKSEQUENCEVERIFY", "OK", "CSV passes if stack top bit 1 << 31 is set"],
 
 ["", "DEPTH", "P2SH,STRICTENC",   "EVAL_FALSE", "Test the test: we should have an empty stack after scriptSig evaluation"],
 ["  ", "DEPTH", "P2SH,STRICTENC", "EVAL_FALSE", "and multiple spaces should not change that."],
 ["   ", "DEPTH", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["    ", "DEPTH", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["", "", "P2SH,STRICTENC","EVAL_FALSE"],
 ["", "NOP", "P2SH,STRICTENC","EVAL_FALSE"],
 ["", "NOP DEPTH", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["NOP", "", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["NOP", "DEPTH", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["NOP","NOP", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["NOP","NOP DEPTH", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["DEPTH", "", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["0x4c01","0x01 NOP", "P2SH,STRICTENC","BAD_OPCODE", "PUSHDATA1 with not enough bytes"],
 ["0x4d0200ff","0x01 NOP", "P2SH,STRICTENC","BAD_OPCODE", "PUSHDATA2 with not enough bytes"],
 ["0x4e03000000ffff","0x01 NOP", "P2SH,STRICTENC","BAD_OPCODE", "PUSHDATA4 with not enough bytes"],
 
 ["1", "IF 0x50 ENDIF 1", "P2SH,STRICTENC","BAD_OPCODE", "0x50 is reserved"],
 ["0x52", "0x5f ADD 0x60 EQUAL", "P2SH,STRICTENC","EVAL_FALSE", "0x51 through 0x60 push 1 through 16 onto stack"],
 ["0","NOP", "P2SH,STRICTENC","EVAL_FALSE",""],
 ["1", "IF VER ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE", "VER non-functional"],
 ["0", "IF VERIF ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE", "VERIF illegal everywhere"],
 ["0", "IF ELSE 1 ELSE VERIF ENDIF", "P2SH,STRICTENC", "BAD_OPCODE", "VERIF illegal everywhere"],
 ["0", "IF VERNOTIF ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE", "VERNOTIF illegal everywhere"],
 ["0", "IF ELSE 1 ELSE VERNOTIF ENDIF", "P2SH,STRICTENC", "BAD_OPCODE", "VERNOTIF illegal everywhere"],
 
 ["1 IF", "1 ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL", "IF/ENDIF can't span scriptSig/scriptPubKey"],
 ["1 IF 0 ENDIF", "1 ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 ["1 ELSE 0 ENDIF", "1", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 ["0 NOTIF", "123", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 
 ["0", "DUP IF ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["0", "IF 1 ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["0", "DUP IF ELSE ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["0", "IF 1 ELSE ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["0", "NOTIF ELSE 1 ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["0 1", "IF IF 1 ELSE 0 ENDIF ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["0 0", "IF IF 1 ELSE 0 ENDIF ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["1 0", "IF IF 1 ELSE 0 ENDIF ELSE IF 0 ELSE 1 ENDIF ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["0 1", "IF IF 1 ELSE 0 ENDIF ELSE IF 0 ELSE 1 ENDIF ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["0 0", "NOTIF IF 1 ELSE 0 ENDIF ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["0 1", "NOTIF IF 1 ELSE 0 ENDIF ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["1 1", "NOTIF IF 1 ELSE 0 ENDIF ELSE IF 0 ELSE 1 ENDIF ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["0 0", "NOTIF IF 1 ELSE 0 ENDIF ELSE IF 0 ELSE 1 ENDIF ENDIF", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["1", "IF RETURN ELSE ELSE 1 ENDIF", "P2SH,STRICTENC", "OP_RETURN", "Multiple ELSEs"],
 ["1", "IF 1 ELSE ELSE RETURN ENDIF", "P2SH,STRICTENC", "OP_RETURN"],
 
 ["1", "ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL", "Malformed IF/ELSE/ENDIF sequence"],
 ["1", "ELSE ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 ["1", "ENDIF ELSE", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 ["1", "ENDIF ELSE IF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 ["1", "IF ELSE ENDIF ELSE", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 ["1", "IF ELSE ENDIF ELSE ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 ["1", "IF ENDIF ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 ["1", "IF ELSE ELSE ENDIF ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL"],
 
 ["1", "RETURN", "P2SH,STRICTENC", "OP_RETURN"],
 ["1", "DUP IF RETURN ENDIF", "P2SH,STRICTENC", "OP_RETURN"],
 
 ["1", "RETURN 'data'", "P2SH,STRICTENC", "OP_RETURN", "canonical prunable txout format"],
 ["0 IF", "RETURN ENDIF 1", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL", "still prunable because IF/ENDIF can't span scriptSig/scriptPubKey"],
 
 ["0", "VERIFY 1", "P2SH,STRICTENC", "VERIFY"],
 ["1", "VERIFY", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["1", "VERIFY 0", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["1 TOALTSTACK", "FROMALTSTACK 1", "P2SH,STRICTENC", "INVALID_ALTSTACK_OPERATION", "alt stack not shared between sig/pubkey"],
 
 ["IFDUP", "DEPTH 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["DROP", "DEPTH 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["DUP", "DEPTH 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "DUP 1 ADD 2 EQUALVERIFY 0 EQUAL", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["NOP", "NIP", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "1 NIP", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "1 0 NIP", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["NOP", "OVER 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "OVER", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["0 1", "OVER DEPTH 3 EQUALVERIFY", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["19 20 21", "PICK 19 EQUALVERIFY DEPTH 2 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "0 PICK", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "-1 PICK", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["19 20 21", "0 PICK 20 EQUALVERIFY DEPTH 3 EQUAL", "P2SH,STRICTENC", "EQUALVERIFY"],
 ["19 20 21", "1 PICK 21 EQUALVERIFY DEPTH 3 EQUAL", "P2SH,STRICTENC", "EQUALVERIFY"],
 ["19 20 21", "2 PICK 22 EQUALVERIFY DEPTH 3 EQUAL", "P2SH,STRICTENC", "EQUALVERIFY"],
 ["NOP", "0 ROLL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "-1 ROLL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["19 20 21", "0 ROLL 20 EQUALVERIFY DEPTH 2 EQUAL", "P2SH,STRICTENC", "EQUALVERIFY"],
 ["19 20 21", "1 ROLL 21 EQUALVERIFY DEPTH 2 EQUAL", "P2SH,STRICTENC", "EQUALVERIFY"],
 ["19 20 21", "2 ROLL 22 EQUALVERIFY DEPTH 2 EQUAL", "P2SH,STRICTENC", "EQUALVERIFY"],
 ["NOP", "ROT 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "1 ROT 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "1 2 ROT 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "0 1 2 ROT", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["NOP", "SWAP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "SWAP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["0 1", "SWAP 1 EQUALVERIFY", "P2SH,STRICTENC", "EQUALVERIFY"],
 ["NOP", "TUCK 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "TUCK 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 0", "TUCK DEPTH 3 EQUALVERIFY SWAP 2DROP", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["NOP", "2DUP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "2DUP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "3DUP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "3DUP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 2", "3DUP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "2OVER 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "2 3 2OVER 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "2SWAP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "2 3 2SWAP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 
 ["CAT"],
 ["", "CAT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "CAT, empty stack"],
 ["'a'", "CAT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "CAT, one parameter"],
 ["'abcd' 'efgh'", "CAT 'abcdefgh' EQUAL", "P2SH,STRICTENC", "OK"],
 ["'' ''", "CAT '' EQUAL", "P2SH,STRICTENC", "OK", "CAT two empty strings"],
 ["'abc' ''", "CAT 'abc' EQUAL", "P2SH,STRICTENC", "OK", "CAT with empty string"],
 ["'' 'def'", "CAT 'def' EQUAL", "P2SH,STRICTENC", "OK", "CAT with empty string"],
 [
     "'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxh' 'ataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
     "CAT 'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh' EQUAL",
     "P2SH,STRICTENC", "OK", "CAT, maximum length"
 ],
 [
     "'' 'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
     "CAT 'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh' EQUAL",
     "P2SH,STRICTENC", "OK", "CAT, maximum length with empty string"
 ],
 [
     "'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh' ''",
     "CAT 'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh' EQUAL",
     "P2SH,STRICTENC", "OK", "CAT, maximum length with empty string"
 ],
 [
     "'a' 'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
     "CAT",
     "P2SH,STRICTENC", "PUSH_SIZE", "CAT oversized result"
 ],
 
 ["SPLIT"],
 ["", "SPLIT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "SPLIT, empty stack"],
 ["'a'", "SPLIT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "SPLIT, one parameter"],
 ["'abcdef' 3", "SPLIT 'def' EQUALVERIFY 'abc' EQUAL", "P2SH,STRICTENC", "OK"],
 ["'' 0", "SPLIT '' EQUALVERIFY '' EQUAL", "P2SH,STRICTENC", "OK", "SPLIT, empty string"],
 ["'abc' 0", "SPLIT 'abc' EQUALVERIFY '' EQUAL", "P2SH,STRICTENC", "OK", "SPLIT, boundary condition"],
 ["'abc' 3", "SPLIT '' EQUALVERIFY 'abc' EQUAL", "P2SH,STRICTENC", "OK", "SPLIT, boundary condition"],
 ["'abc' 4", "SPLIT", "P2SH,STRICTENC", "SPLIT_RANGE", "SPLIT, out of bounds"],
 ["'abc' -1", "SPLIT", "P2SH,STRICTENC", "SPLIT_RANGE", "SPLIT, out of bounds"],
 [
     "'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
     "145 SPLIT 'ataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh' EQUALVERIFY 'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxh' EQUAL",
     "P2SH,STRICTENC", "OK", "SPLIT, maximum length"
 ],
 [
     "'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
     "0 SPLIT 'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh' EQUALVERIFY '' EQUAL",
     "P2SH,STRICTENC", "OK", "SPLIT, maximum length with empty string"
 ],
 [
     "'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
     "520 SPLIT '' EQUALVERIFY 'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh' EQUAL",
     "P2SH,STRICTENC", "OK", "SPLIT, maximum length with empty string"
 ],
 
 ["REVERSEBYTES"],
-["0", "REVERSEBYTES 0 EQUAL", "P2SH", "BAD_OPCODE", "REVERSEBYTES, not yet activated in executed branch"],
-["0x02 0xbeef", "REVERSEBYTES 0x02 0xefbe EQUAL", "P2SH", "BAD_OPCODE", "REVERSEBYTES, not yet activated in executed branch"],
-["", "REVERSEBYTES 0 EQUAL", "P2SH,REVERSEBYTES", "INVALID_STACK_OPERATION", "REVERSEBYTES, empty stack"],
-["0", "REVERSEBYTES 0 EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, empty data"],
-["0x01 0x99", "REVERSEBYTES 0x01 0x99 EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, 1 byte"],
-["0x02 0xbeef", "REVERSEBYTES 0x02 0xefbe EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, 2 bytes"],
-["0x03 0xdeada1", "REVERSEBYTES 0x03 0xa1adde EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, 3 bytes"],
-["0x04 0xdeadbeef", "REVERSEBYTES 0x04 0xefbeadde EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, 4 bytes"],
-["0x41 0x1052a02f76cf6c3bc43e4671af4c6065f6d918c79f58ad7f90a49c4e2603a4728fc6d81d49087dd97bc43ae184da55dc5195553526ce076df092be27a398b68f41", "0x21 0xa8f459fbe84e0568ff03454d438183b0464e0c18ff73658ec0d2619b20ff29e502 REVERSEBYTES CHECKSIG", "NULLFAIL,STRICTENC,REVERSEBYTES,SIGHASH_FORKID", "OK", "REVERSEBYTES, reversed pubkey"],
-["'Bitcoin:_A_peer-to-peer_electronic_cash_system'", "REVERSEBYTES 'metsys_hsac_cinortcele_reep-ot-reep_A_:nioctiB' EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, whitepaper title"],
+["", "REVERSEBYTES 0 EQUAL", "P2SH", "INVALID_STACK_OPERATION", "REVERSEBYTES, empty stack"],
+["0", "REVERSEBYTES 0 EQUAL", "P2SH", "OK", "REVERSEBYTES, empty data"],
+["0x01 0x99", "REVERSEBYTES 0x01 0x99 EQUAL", "P2SH", "OK", "REVERSEBYTES, 1 byte"],
+["0x02 0xbeef", "REVERSEBYTES 0x02 0xefbe EQUAL", "P2SH", "OK", "REVERSEBYTES, 2 bytes"],
+["0x03 0xdeada1", "REVERSEBYTES 0x03 0xa1adde EQUAL", "P2SH", "OK", "REVERSEBYTES, 3 bytes"],
+["0x04 0xdeadbeef", "REVERSEBYTES 0x04 0xefbeadde EQUAL", "P2SH", "OK", "REVERSEBYTES, 4 bytes"],
+["0x41 0x1052a02f76cf6c3bc43e4671af4c6065f6d918c79f58ad7f90a49c4e2603a4728fc6d81d49087dd97bc43ae184da55dc5195553526ce076df092be27a398b68f41", "0x21 0xa8f459fbe84e0568ff03454d438183b0464e0c18ff73658ec0d2619b20ff29e502 REVERSEBYTES CHECKSIG", "NULLFAIL,STRICTENC,SIGHASH_FORKID", "OK", "REVERSEBYTES, reversed pubkey"],
+["'Bitcoin:_A_peer-to-peer_electronic_cash_system'", "REVERSEBYTES 'metsys_hsac_cinortcele_reep-ot-reep_A_:nioctiB' EQUAL", "P2SH", "OK", "REVERSEBYTES, whitepaper title"],
 [
     "'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
     "REVERSEBYTES 'hhfanqyfcglncrriufjfvjgqcbbwrilaxeczpotsfzvmyrwlobpjtvtmhamvzoiwwjqazpyekvxpvsiiwuvertiqqiksmgkfplzamdvcelrrjsrvsxgojxngirwcoxhtmvtpzdjwzsuamlpudecziyiqkuukdbakbswcyelaksmudkgqccxpbobrkdpajsgogcuspzrptvrrsyuhrtxcftlpwlodgkavcqwofyxcwrsbovwojgznkiyijhohlyxevhqnqsibheuinifzybtbblzutjtsrotyqndybrncsdyrzlblxctejeyienvjeuslnzxomqzclruxceqispbntxngdpttfzzvqxshwlktvtkupouvjaugatahxgzzjidcauprbwdwakushoyhmogialwljyjrluudbkwjrkitxfsbtrvvyaesdosyzyxiysldhrybsxfrzpwwpubzncyzupdwoumfkfxnivdsryzlizjumarmlpqwfwqvngfegryrinviygnz' EQUAL",
-    "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, 520 bytes"
+    "P2SH", "OK", "REVERSEBYTES, 520 bytes"
 ],
-["0x03 0x123456", "REVERSEBYTES 0x03 0x563412 OP_EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, 3 bytes equal"],
-["0x06 0x020406080a0c", "DUP REVERSEBYTES REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, 3 bytes double reverse equal"],
-["'Bitcoin:_A_peer-to-peer_electronic_cash_system'", "DUP REVERSEBYTES REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, whitepaper title double reverse equal"],
+["0x03 0x123456", "REVERSEBYTES 0x03 0x563412 OP_EQUAL", "P2SH", "OK", "REVERSEBYTES, 3 bytes equal"],
+["0x06 0x020406080a0c", "DUP REVERSEBYTES REVERSEBYTES OP_EQUAL", "P2SH", "OK", "REVERSEBYTES, 3 bytes double reverse equal"],
+["'Bitcoin:_A_peer-to-peer_electronic_cash_system'", "DUP REVERSEBYTES REVERSEBYTES OP_EQUAL", "P2SH", "OK", "REVERSEBYTES, whitepaper title double reverse equal"],
 [
     "'zngyivniryrgefgnvqwfwqplmramujzilzyrsdvinxfkfmuowdpuzycnzbupwwpzrfxsbyrhdlsyixyzysodseayvvrtbsfxtikrjwkbduulrjyjlwlaigomhyohsukawdwbrpuacdijzzgxhataguajvuopuktvtklwhsxqvzzfttpdgnxtnbpsiqecxurlczqmoxznlsuejvneiyejetcxlblzrydscnrbydnqytorstjtuzlbbtbyzfiniuehbisqnqhvexylhohjiyiknzgjowvobsrwcxyfowqcvakgdolwpltfcxtrhuysrrvtprzpsucgogsjapdkrbobpxccqgkdumskaleycwsbkabdkuukqiyizceduplmauszwjdzptvmthxocwrignxjogxsvrsjrrlecvdmazlpfkgmskiqqitrevuwiisvpxvkeypzaqjwwiozvmahmtvtjpbolwrymvzfstopzcexalirwbbcqgjvfjfuirrcnlgcfyqnafhh'",
     "DUP REVERSEBYTES REVERSEBYTES OP_EQUAL",
-    "P2SH,REVERSEBYTES",
+    "P2SH",
     "OK",
     "REVERSEBYTES, 520 bytes double reverse equal"
 ],
-["0x05 0x0102030201", "DUP REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, palindrome 1"],
-["0x08 0x7766554444556677", "DUP REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, palindrome 2"],
-["'madam'", "DUP REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, palindrome 3"],
-["'racecar'", "DUP REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, palindrome 4"],
-["'redrum_siris_murder'", "DUP REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, palindrome 5"],
-["'step_on_no_pets'", "DUP REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "OK", "REVERSEBYTES, palindrome 6"],
-["'Bitcoin:_A_peer-to-peer_electronic_cash_system'", "DUP REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "EVAL_FALSE", "REVERSEBYTES, non-palindrome 1"],
-["0x02 0x1234", "DUP REVERSEBYTES OP_EQUAL", "P2SH,REVERSEBYTES", "EVAL_FALSE", "REVERSEBYTES, non-palindrome 2"],
+["0x05 0x0102030201", "DUP REVERSEBYTES OP_EQUAL", "P2SH", "OK", "REVERSEBYTES, palindrome 1"],
+["0x08 0x7766554444556677", "DUP REVERSEBYTES OP_EQUAL", "P2SH", "OK", "REVERSEBYTES, palindrome 2"],
+["'madam'", "DUP REVERSEBYTES OP_EQUAL", "P2SH", "OK", "REVERSEBYTES, palindrome 3"],
+["'racecar'", "DUP REVERSEBYTES OP_EQUAL", "P2SH", "OK", "REVERSEBYTES, palindrome 4"],
+["'redrum_siris_murder'", "DUP REVERSEBYTES OP_EQUAL", "P2SH", "OK", "REVERSEBYTES, palindrome 5"],
+["'step_on_no_pets'", "DUP REVERSEBYTES OP_EQUAL", "P2SH", "OK", "REVERSEBYTES, palindrome 6"],
+["'Bitcoin:_A_peer-to-peer_electronic_cash_system'", "DUP REVERSEBYTES OP_EQUAL", "P2SH", "EVAL_FALSE", "REVERSEBYTES, non-palindrome 1"],
+["0x02 0x1234", "DUP REVERSEBYTES OP_EQUAL", "P2SH", "EVAL_FALSE", "REVERSEBYTES, non-palindrome 2"],
 
 ["NUM2BIN"],
 ["", "NUM2BIN 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "NUM2BIN, empty stack"],
 ["0", "NUM2BIN 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "NUM2BIN, one parameter"],
 ["0 0", "NUM2BIN 0 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN, canonical argument "],
 ["0 1", "NUM2BIN 0x01 0x00 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN, zero extend"],
 ["0 7", "NUM2BIN 0x07 0x00000000000000 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN, zero extend"],
 ["1 1", "NUM2BIN 1 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN, canonical argument "],
 ["-42 1", "NUM2BIN -42 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN, canonical argument "],
 ["-42 2", "NUM2BIN 0x02 0x2a80 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN, canonical argument "],
 ["-42 10", "NUM2BIN 0x0a 0x2a000000000000000080 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN, large materialization"],
 ["-42 520", "NUM2BIN", "P2SH,STRICTENC", "OK", "Pushing 520 bytes is ok"],
 ["-42 521", "NUM2BIN", "P2SH,STRICTENC", "PUSH_SIZE", "Pushing 521 bytes is not"],
 ["-42 -3", "NUM2BIN", "P2SH,STRICTENC", "PUSH_SIZE", "Negative size"],
 ["0x05 0xabcdef4280 4", "NUM2BIN 0x04 0xabcdefc2 EQUAL", "P2SH,STRICTENC", "OK", "Item size reduction"],
 ["0x03 0xabcdef 2", "NUM2BIN", "P2SH,STRICTENC", "IMPOSSIBLE_ENCODING", "output too small"],
 ["0x03 0xabcdef 3", "NUM2BIN", "P2SH,STRICTENC", "OK"],
 ["0x01 0x80 0", "NUM2BIN 0 EQUAL", "P2SH,STRICTENC", "OK", "Negative zero"],
 ["0x01 0x80 3", "NUM2BIN 0x03 0x000000 EQUAL", "P2SH,STRICTENC", "OK", "Negative zero, larger output"],
 ["0x01 0x80 1", "NUM2BIN 0x01 0x00 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN does not always return input verbatim, when same size (1) requested"],
 ["0x04 0x00000080 4", "NUM2BIN 0x04 0x00000000 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN does not always return input verbatim, when same size (4) requested"],
 ["0x05 0xabcdef4243 5", "NUM2BIN 0x05 0xabcdef4243 EQUAL", "P2SH,STRICTENC", "OK", "NUM2BIN where len(a) > 4"],
 ["0x05 0xabcdef4243 6", "NUM2BIN 0x06 0xabcdef424300 EQUAL", "P2SH,STRICTENC", "OK", "pads output properly"],
 ["0x05 0xabcdef4243 4", "NUM2BIN", "P2SH,STRICTENC", "IMPOSSIBLE_ENCODING", "output too small"],
 ["0x10 0x0102030405060708090A0B0C0D0E0F10 DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT 0x08 0x0102030405060708 CAT 520", "NUM2BIN 0x10 0x0102030405060708090A0B0C0D0E0F10 DUP CAT DUP CAT DUP CAT DUP CAT DUP CAT 0x08 0x0102030405060708 CAT EQUAL", "P2SH,STRICTENC", "OK", "520 byte 1st operand"],
 ["0x05 0x0000000000 5", "NUM2BIN 0x05 0x0000000000 EQUAL", "P2SH,STRICTENC", "OK", "1st operand not minimally encoded"],
 ["0x05 0x0001000000 3", "NUM2BIN 0x03 0x000100 EQUAL", "P2SH,STRICTENC", "OK", "1st operand can shrink"],
 ["1 0x03 0x050000", "NUM2BIN", "P2SH,STRICTENC", "OK", "2nd operand not minimally encoded"],
 ["1 0x05 0x0500000000", "NUM2BIN", "P2SH,STRICTENC", "UNKNOWN_ERROR", "2nd operand > 4 bytes"],
 ["0x04 0xabcdef42 0x05 0xabcdef4243", "NUM2BIN", "P2SH,STRICTENC", "UNKNOWN_ERROR", "2nd operand > 4 bytes"],
 
 ["BIN2NUM"],
 ["", "BIN2NUM 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "BIN2NUM, empty stack"],
 ["0", "BIN2NUM 0 EQUAL", "P2SH,STRICTENC", "OK", "BIN2NUM, canonical argument "],
 ["1", "BIN2NUM 1 EQUAL", "P2SH,STRICTENC", "OK", "BIN2NUM, canonical argument "],
 ["-42", "BIN2NUM -42 EQUAL", "P2SH,STRICTENC", "OK", "BIN2NUM, canonical argument "],
 ["0x01 0x00", "BIN2NUM 0 EQUAL", "P2SH,STRICTENC", "OK", "BIN2NUM, non-canonical argument "],
 ["0x04 0xffffff7f", "BIN2NUM 2147483647 EQUAL", "P2SH,STRICTENC", "OK", "BIN2NUM, maximum size argument "],
 ["0x04 0xffffffff", "BIN2NUM -2147483647 EQUAL", "P2SH,STRICTENC", "OK", "BIN2NUM, maximum size argument "],
 ["0x05 0xffffffff00", "BIN2NUM 2147483647 EQUAL", "P2SH,STRICTENC", "INVALID_NUMBER_RANGE", "BIN2NUM, oversized argument"],
 ["0x05 0xffffff7f80", "BIN2NUM -2147483647 EQUAL", "P2SH,STRICTENC", "OK", "BIN2NUM, non-canonical maximum size argument"],
 ["0x05 0x0100000000", "BIN2NUM 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0x05 0xFE00000000", "BIN2NUM 254 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0x05 0x0500000080", "BIN2NUM 0x01 0x85 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0x03 0x800000", "BIN2NUM 128 EQUAL", "P2SH,STRICTENC", "OK", "Pad where MSB of number is set"],
 ["0x03 0x800080", "BIN2NUM -128 EQUAL", "P2SH,STRICTENC", "OK", "Pad where MSB of number is set"],
 ["0x02 0x8000", "BIN2NUM 128 EQUAL", "P2SH,STRICTENC", "OK", "Pad where MSB of number is set"],
 ["0x02 0x8080", "BIN2NUM -128 EQUAL", "P2SH,STRICTENC", "OK", "Pad where MSB of number is set"],
 ["0x03 0x0f0000", "BIN2NUM 15 EQUAL", "P2SH,STRICTENC", "OK", "Don't pad where MSB of number is not set"],
 ["0x03 0x0f0080", "BIN2NUM -15 EQUAL", "P2SH,STRICTENC", "OK", "Don't pad where MSB of number is not set"],
 ["0x02 0x0f00", "BIN2NUM 15 EQUAL", "P2SH,STRICTENC", "OK", "Don't pad where MSB of number is not set"],
 ["0x02 0x0f80", "BIN2NUM -15 EQUAL", "P2SH,STRICTENC", "OK", "Don't pad where MSB of number is not set"],
 ["0x05 0x0100800000", "BIN2NUM 8388609 EQUAL", "P2SH,STRICTENC", "OK", "Ensure significant zero bytes are retained"],
 ["0x05 0x0100800080", "BIN2NUM -8388609 EQUAL", "P2SH,STRICTENC", "OK", "Ensure significant zero bytes are retained"],
 ["0x05 0x01000f0000", "BIN2NUM 983041 EQUAL", "P2SH,STRICTENC", "OK", "Ensure significant zero bytes are retained"],
 ["0x05 0x01000f0080", "BIN2NUM -983041 EQUAL", "P2SH,STRICTENC", "OK", "Ensure significant zero bytes are retained"],
 
 ["NOP", "SIZE 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 
 ["Disabled opcodes"],
 ["'abc'", "IF INVERT ELSE 1 ENDIF", "P2SH,STRICTENC", "DISABLED_OPCODE", "INVERT disabled"],
 ["2 0 IF 2MUL ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "2MUL disabled"],
 ["2 0 IF 2DIV ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "2DIV disabled"],
 ["2 2 0 IF MUL ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "MUL disabled"],
 ["2 2 0 IF LSHIFT ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "LSHIFT disabled"],
 ["2 2 0 IF RSHIFT ELSE 1 ENDIF", "NOP", "P2SH,STRICTENC", "DISABLED_OPCODE", "RSHIFT disabled"],
 
 ["Bitwise opcodes"],
 ["AND"],
 ["0 0", "AND 0 EQUAL", "P2SH,STRICTENC", "OK", "AND, empty parameters"],
 ["0x01 0x00 0x01 0x00", "AND 0x01 0x00 EQUAL", "P2SH,STRICTENC", "OK", "AND, simple and"],
 ["1 0x01 0x00", "AND 0x01 0x00 EQUAL", "P2SH,STRICTENC", "OK", "AND, simple and"],
 ["0x01 0x00 1", "AND 0x01 0x00 EQUAL", "P2SH,STRICTENC", "OK", "AND, simple and"],
 ["1 1", "AND 1 EQUAL", "P2SH,STRICTENC", "OK", "AND, simple and"],
 ["0", "AND 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "AND, invalid parameter count"],
 ["", "AND 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "AND, empty stack"],
 ["0 1", "AND 1 EQUAL", "P2SH,STRICTENC", "OPERAND_SIZE", "AND, different operand size"],
 ["0x01 0xab 0x01 0xcd", "AND 0x01 0x89 EQUAL", "P2SH,STRICTENC", "OK", "AND, more complex operands"],
 ["OR"],
 ["0 0", "OR 0 EQUAL", "P2SH,STRICTENC", "OK", "OR, empty parameters"],
 ["0x01 0x00 0x01 0x00", "OR 0x01 0x00 EQUAL", "P2SH,STRICTENC", "OK", "OR, simple and"],
 ["1 0x01 0x00", "OR 1 EQUAL", "P2SH,STRICTENC", "OK", "OR, simple and"],
 ["0x01 0x00 1", "OR 1 EQUAL", "P2SH,STRICTENC", "OK", "OR, simple and"],
 ["1 1", "OR 1 EQUAL", "P2SH,STRICTENC", "OK", "OR, simple and"],
 ["0", "OR 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "OR, invalid parameter count"],
 ["", "OR 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "OR, empty stack"],
 ["0 1", "OR 1 EQUAL", "P2SH,STRICTENC", "OPERAND_SIZE", "OR, different operand size"],
 ["0x01 0xab 0x01 0xcd", "OR 0x01 0xef EQUAL", "P2SH,STRICTENC", "OK", "XOR, more complex operands"],
 ["XOR"],
 ["0 0", "XOR 0 EQUAL", "P2SH,STRICTENC", "OK", "XOR, empty parameters"],
 ["0x01 0x00 0x01 0x00", "XOR 0x01 0x00 EQUAL", "P2SH,STRICTENC", "OK", "XOR, simple and"],
 ["1 0x01 0x00", "XOR 1 EQUAL", "P2SH,STRICTENC", "OK", "XOR, simple and"],
 ["0x01 0x00 1", "XOR 1 EQUAL", "P2SH,STRICTENC", "OK", "XOR, simple and"],
 ["1 1", "XOR 0x01 0x00 EQUAL", "P2SH,STRICTENC", "OK", "XOR, simple and"],
 ["0", "XOR 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "XOR, invalid parameter count"],
 ["", "XOR 0 EQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "XOR, empty stack"],
 ["0 1", "XOR 1 EQUAL", "P2SH,STRICTENC", "OPERAND_SIZE", "XOR, different operand size"],
 ["0x01 0xab 0x01 0xcd", "XOR 0x01 0x66 EQUAL", "P2SH,STRICTENC", "OK", "XOR, more complex operands"],
 
 ["DIV"],
 ["1 1", "DIV 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 -1", "DIV -1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-1 1", "DIV -1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-1 -1", "DIV 1 EQUAL", "P2SH,STRICTENC", "OK"],
 ["28 21", "DIV 1 EQUAL", "P2SH,STRICTENC", "OK", "Round towards zero"],
 ["12 -7", "DIV -1 EQUAL", "P2SH,STRICTENC", "OK", "Round towards zero"],
 ["-32 29", "DIV -1 EQUAL", "P2SH,STRICTENC", "OK", "Round towards zero"],
 ["-42 -27", "DIV 1 EQUAL", "P2SH,STRICTENC", "OK", "Round towards zero"],
 ["0 123", "DIV 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["511 0", "DIV", "P2SH,STRICTENC", "DIV_BY_ZERO", "DIV, divide by zero"],
 ["1 1", "DIV DEPTH 1 EQUAL", "P2SH,STRICTENC", "OK", "Stack depth correct"],
 ["1", "DIV", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "Not enough operands"],
 ["0", "DIV", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "Not enough operands"],
 ["2147483647 1", "DIV 2147483647 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["1 2147483647", "DIV 0 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["2147483647 2147483647", "DIV 1 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-2147483647 1", "DIV -2147483647 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-1 2147483647", "DIV 0 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-2147483647 2147483647", "DIV -1 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["2147483647 -1", "DIV -2147483647 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["1 -2147483647", "DIV 0 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["2147483647 -2147483647", "DIV -1 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-2147483647 -1", "DIV 2147483647 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-1 -2147483647", "DIV 0 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-2147483647 -2147483647", "DIV 1 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["2147483648 1", "DIV", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 ["1 2147483648", "DIV", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 ["-2147483648 1", "DIV", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 ["1 -2147483648", "DIV", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 
 ["MOD"],
 ["1 1", "MOD 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-1 1", "MOD 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 -1", "MOD 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-1 -1", "MOD 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["82 23", "MOD 13 EQUAL", "P2SH,STRICTENC", "OK"],
 ["8 -3", "MOD 2 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-71 13", "MOD -6 EQUAL", "P2SH,STRICTENC", "OK"],
 ["-110 -31", "MOD -17 EQUAL", "P2SH,STRICTENC", "OK"],
 ["0 1", "MOD 0 EQUAL", "P2SH,STRICTENC", "OK"],
 ["1 0", "MOD", "P2SH,STRICTENC", "MOD_BY_ZERO", "MOD, modulo by zero"],
 ["1 1", "MOD DEPTH 1 EQUAL", "P2SH,STRICTENC", "OK", "Stack depth correct"],
 ["1", "MOD", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "Not enough operands"],
 ["0", "MOD", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "Not enough operands"],
 ["2147483647 123", "MOD 79 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["123 2147483647", "MOD 123 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["2147483647 2147483647", "MOD 0 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-2147483647 123", "MOD -79 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-123 2147483647", "MOD -123 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-2147483647 2147483647", "MOD 0 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["2147483647 -123", "MOD 79 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["123 -2147483647", "MOD 123 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["2147483647 -2147483647", "MOD 0 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-2147483647 -123", "MOD -79 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-123 -2147483647", "MOD -123 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["-2147483647 -2147483647", "MOD 0 EQUAL", "P2SH,STRICTENC", "OK", "Check boundary condition"],
 ["2147483648 1", "MOD", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 ["1 2147483648", "MOD", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 ["-2147483648 1", "MOD", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 ["1 -2147483648", "MOD", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 
 ["EQUAL"],
 ["", "EQUAL NOT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "EQUAL must error when there are no stack items"],
 ["0", "EQUAL NOT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "EQUAL must error when there are not 2 stack items"],
 ["0 1","EQUAL", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["1 1 ADD", "0 EQUAL", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["11 1 ADD 12 SUB", "11 EQUAL", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["CHECKDATASIG"],
 ["", "CHECKDATASIG", "P2SH,STRICTENC,NULLFAIL", "INVALID_STACK_OPERATION"],
 ["0", "CHECKDATASIG", "P2SH,STRICTENC,NULLFAIL", "INVALID_STACK_OPERATION"],
 ["0 0", "CHECKDATASIG", "P2SH,STRICTENC,NULLFAIL", "INVALID_STACK_OPERATION"],
 [
 	"0 0",
 	"0 CHECKDATASIG",
 	"P2SH,STRICTENC,NULLFAIL",
 	"PUBKEYTYPE"
 ],
 [
 	"0 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
 	"P2SH,STRICTENC,NULLFAIL",
 	"EVAL_FALSE"
 ],
 [
 	"0x08 0x3006020101020101 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
 	"P2SH,STRICTENC",
 	"EVAL_FALSE", "Check that NULLFAIL trigger only when specified"
 ],
 [
 	"0x08 0x3006020101020101 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
 	"P2SH,STRICTENC,NULLFAIL",
 	"NULLFAIL"
 ],
 [
 	"0x09 0x300602010102010101 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
 	"P2SH,STRICTENC,NULLFAIL",
 	"SIG_DER", "Ensure that sighashtype is ignored"
 ],
 [
 	"0x09 0x300702010102020001 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
 	"P2SH,STRICTENC,NULLFAIL,CHECKDATASIG",
 	"SIG_DER", "Non canonical DER encoding"
 ],
 
 ["CHECKDATASIGVERIFY"],
 ["", "CHECKDATASIGVERIFY 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["0", "CHECKDATASIGVERIFY 1", "P2SH,STRICTENC,NULLFAIL", "INVALID_STACK_OPERATION"],
 ["0 0", "CHECKDATASIGVERIFY 1", "P2SH,STRICTENC,NULLFAIL", "INVALID_STACK_OPERATION"],
 [
 	"0 0",
 	"0 CHECKDATASIGVERIFY 1",
 	"P2SH,STRICTENC,NULLFAIL",
 	"PUBKEYTYPE"
 ],
 [
 	"0 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
 	"P2SH,STRICTENC,NULLFAIL",
 	"CHECKDATASIGVERIFY"
 ],
 [
 	"0x08 0x3006020101020101 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
 	"P2SH,STRICTENC",
 	"CHECKDATASIGVERIFY", "Check that NULLFAIL trigger only when specified"
 ],
 [
 	"0x08 0x3006020101020101 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
 	"P2SH,STRICTENC,NULLFAIL",
 	"NULLFAIL"
 ],
 [
 	"0x09 0x300602010102010101 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
 	"P2SH,STRICTENC,NULLFAIL",
 	"SIG_DER", "Ensure that sighashtype is ignored"
 ],
 [
 	"0x09 0x300702010102020001 0",
 	"0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
 	"P2SH,STRICTENC,NULLFAIL,CHECKDATASIG",
 	"SIG_DER", "Non canonical DER encoding"
 ],
 
 ["ADD"],
 ["2147483648 0 ADD", "NOP", "P2SH,STRICTENC", "UNKNOWN_ERROR", "arithmetic operands must be in range [-2^31...2^31] "],
 ["-2147483648 0 ADD", "NOP", "P2SH,STRICTENC", "UNKNOWN_ERROR", "arithmetic operands must be in range [-2^31...2^31] "],
 ["2147483647 DUP ADD", "4294967294 NUMEQUAL", "P2SH,STRICTENC", "UNKNOWN_ERROR", "NUMEQUAL must be in numeric range"],
 ["'abcdef' NOT", "0 EQUAL", "P2SH,STRICTENC", "UNKNOWN_ERROR", "NOT is an arithmetic operand"],
 
 ["2 DUP MUL", "4 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"],
 ["2 2MUL", "4 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"],
 ["2 2DIV", "1 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"],
 ["2 2 LSHIFT", "8 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"],
 ["2 1 RSHIFT", "1 EQUAL", "P2SH,STRICTENC", "DISABLED_OPCODE", "disabled"],
 
 ["1", "NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10 2 EQUAL", "P2SH,STRICTENC", "EVAL_FALSE"],
 ["'NOP_1_to_10' NOP1 CHECKLOCKTIMEVERIFY CHECKSEQUENCEVERIFY NOP4 NOP5 NOP6 NOP7 NOP8 NOP9 NOP10","'NOP_1_to_11' EQUAL", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["Ensure 100% coverage of discouraged NOPS"],
 ["1", "NOP1",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 ["1", "NOP4",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 ["1", "NOP5",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 ["1", "NOP6",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 ["1", "NOP7",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 ["1", "NOP8",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 ["1", "NOP9",  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 ["1", "NOP10", "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS"],
 
 ["NOP10", "1", "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS", "Discouraged NOP10 in scriptSig"],
 
 ["1 0x01 0xb9", "HASH160 0x14 0x15727299b05b45fdaf9ac9ecf7565cfe27c3e567 EQUAL",
  "P2SH,DISCOURAGE_UPGRADABLE_NOPS", "DISCOURAGE_UPGRADABLE_NOPS", "Discouraged NOP10 in redeemScript"],
 
 ["0x50","1", "P2SH,STRICTENC", "BAD_OPCODE", "opcode 0x50 is reserved"],
-["1", "IF REVERSEBYTES ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE", "opcode OP_REVERSEBYTES invalid if executed normally"],
 ["1", "IF 0xbd ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE", "opcodes >= FIRST_UNDEFINED_OP_VALUE invalid if executed"],
 ["1", "IF 0xbe ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xbf ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc0 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc1 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc2 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc3 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc4 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc5 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc6 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc7 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc8 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xc9 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xca ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xcb ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xcc ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xcd ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xce ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xcf ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd0 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd1 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd2 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd3 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd4 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd5 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd6 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd7 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd8 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xd9 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xda ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xdb ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xdc ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xdd ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xde ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xdf ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe0 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe1 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe2 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe3 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe4 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe5 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe6 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe7 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe8 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xe9 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xea ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xeb ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xec ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xed ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xee ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xef ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf0 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf1 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf2 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf3 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf4 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf5 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf6 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf7 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf8 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xf9 ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xfa ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xfb ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xfc ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xfd ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xfe ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 ["1", "IF 0xff ELSE 1 ENDIF", "P2SH,STRICTENC", "BAD_OPCODE"],
 
 ["1 IF 1 ELSE", "0xff ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL", "invalid because scriptSig and scriptPubKey are processed separately"],
 
 ["NOP", "RIPEMD160", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "SHA1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "SHA256", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "HASH160", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "HASH256", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 
 ["NOP",
 "'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'",
 "P2SH,STRICTENC",
 "PUSH_SIZE",
 ">520 byte push"],
 ["0",
 "IF 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' ENDIF 1",
 "P2SH,STRICTENC",
 "PUSH_SIZE",
 ">520 byte push in non-executed IF branch"],
 ["1",
 "0x61616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161",
 "P2SH,STRICTENC",
 "OP_COUNT",
 ">201 opcodes executed. 0x61 is NOP"],
 ["0",
 "IF 0x6161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161 ENDIF 1",
 "P2SH,STRICTENC",
 "OP_COUNT",
 ">201 opcodes including non-executed IF branch. 0x61 is NOP"],
 ["1 2 3 4 5 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f",
 "1 2 3 4 5 6 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f",
 "P2SH,STRICTENC",
 "STACK_SIZE",
 ">1,000 stack size (0x6f is 3DUP)"],
 ["1 2 3 4 5 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f",
 "1 TOALTSTACK 2 TOALTSTACK 3 4 5 6 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f",
 "P2SH,STRICTENC",
 "STACK_SIZE",
 ">1,000 stack+altstack size"],
 ["NOP",
 "0 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' 0x6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f6f 2DUP 0x616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161616161",
 "P2SH,STRICTENC",
 "SCRIPT_SIZE",
 "10,001-byte scriptPubKey"],
 
 ["NOP1","NOP10", "P2SH,STRICTENC", "EVAL_FALSE"],
 
 ["1","VER", "P2SH,STRICTENC", "BAD_OPCODE", "OP_VER is reserved"],
 ["1","VERIF", "P2SH,STRICTENC", "BAD_OPCODE", "OP_VERIF is reserved"],
 ["1","VERNOTIF", "P2SH,STRICTENC", "BAD_OPCODE", "OP_VERNOTIF is reserved"],
 ["1","RESERVED", "P2SH,STRICTENC", "BAD_OPCODE", "OP_RESERVED is reserved"],
 ["1","RESERVED1", "P2SH,STRICTENC", "BAD_OPCODE", "OP_RESERVED1 is reserved"],
 ["1","RESERVED2", "P2SH,STRICTENC", "BAD_OPCODE", "OP_RESERVED2 is reserved"],
 ["1","0xbd", "P2SH,STRICTENC", "BAD_OPCODE", "0xbd == FIRST_UNDEFINED_OP_VALUE"],
 
 ["2147483648", "1ADD 1", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 ["2147483648", "NEGATE 1", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers"],
 ["-2147483648", "1ADD 1", "P2SH,STRICTENC", "UNKNOWN_ERROR", "Because we use a sign bit, -2147483648 is also 5 bytes"],
 ["2147483647", "1ADD 1SUB 1", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers, even if the result is 4-bytes"],
 ["2147483648", "1SUB 1", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do math on 5-byte integers, even if the result is 4-bytes"],
 
 ["2147483648 1", "BOOLOR 1", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do BOOLOR on 5-byte integers (but we can still do IF etc)"],
 ["2147483648 1", "BOOLAND 1", "P2SH,STRICTENC", "UNKNOWN_ERROR", "We cannot do BOOLAND on 5-byte integers"],
 
 ["1", "1 ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL", "ENDIF without IF"],
 ["1", "IF 1", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL", "IF without ENDIF"],
 ["1 IF 1", "ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL", "IFs don't carry over"],
 
 ["NOP", "IF 1 ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL", "The following tests check the if(stack.size() < N) tests in each opcode"],
 ["NOP", "NOTIF 1 ENDIF", "P2SH,STRICTENC", "UNBALANCED_CONDITIONAL", "They are here to catch copy-and-paste errors"],
 ["NOP", "VERIFY 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "Most of them are duplicated elsewhere,"],
 
 ["NOP", "TOALTSTACK 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION", "but, hey, more is always better, right?"],
 ["1", "FROMALTSTACK", "P2SH,STRICTENC", "INVALID_ALTSTACK_OPERATION"],
 ["1", "2DROP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "2DUP", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 1", "3DUP", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 1 1", "2OVER", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 1 1 1 1", "2ROT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 1 1", "2SWAP", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "IFDUP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "DROP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "DUP 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "NIP", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "OVER", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 1 1 3", "PICK", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["0", "PICK 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 1 1 3", "ROLL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["0", "ROLL 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 1", "ROT", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "SWAP", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "TUCK", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 
 ["NOP", "SIZE 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 
 ["1", "EQUAL 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "EQUALVERIFY 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 
 ["NOP", "1ADD 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "1SUB 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "NEGATE 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "ABS 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "NOT 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "0NOTEQUAL 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 
 ["1", "ADD", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "SUB", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "BOOLAND", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "BOOLOR", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "NUMEQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "NUMEQUALVERIFY 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "NUMNOTEQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "LESSTHAN", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "GREATERTHAN", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "LESSTHANOREQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "GREATERTHANOREQUAL", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "MIN", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1", "MAX", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["1 1", "WITHIN", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 
 ["NOP", "RIPEMD160 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "SHA1 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "SHA256 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "HASH160 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 ["NOP", "HASH256 1", "P2SH,STRICTENC", "INVALID_STACK_OPERATION"],
 
 ["Increase CHECKSIG and CHECKMULTISIG negative test coverage"],
 ["", "CHECKSIG NOT", "STRICTENC", "INVALID_STACK_OPERATION", "CHECKSIG must error when there are no stack items"],
 ["0", "CHECKSIG NOT", "STRICTENC", "INVALID_STACK_OPERATION", "CHECKSIG must error when there are not 2 stack items"],
 ["", "CHECKMULTISIG NOT", "STRICTENC", "INVALID_STACK_OPERATION", "CHECKMULTISIG must error when there are no stack items"],
 ["", "-1 CHECKMULTISIG NOT", "STRICTENC", "PUBKEY_COUNT", "CHECKMULTISIG must error when the specified number of pubkeys is negative"],
 ["", "1 CHECKMULTISIG NOT", "STRICTENC", "INVALID_STACK_OPERATION", "CHECKMULTISIG must error when there are not enough pubkeys on the stack"],
 ["", "-1 0 CHECKMULTISIG NOT", "STRICTENC", "SIG_COUNT", "CHECKMULTISIG must error when the specified number of signatures is negative"],
 ["", "1 'pk1' 1 CHECKMULTISIG NOT", "STRICTENC", "INVALID_STACK_OPERATION", "CHECKMULTISIG must error when there are not enough signatures on the stack"],
 ["", "'dummy' 'sig1' 1 'pk1' 1 CHECKMULTISIG IF 1 ENDIF", "", "EVAL_FALSE", "CHECKMULTISIG must push false to stack when signature is invalid when NOT in strict enc mode"],
 
 ["",
 "0 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG 0 0 CHECKMULTISIG",
 "P2SH,STRICTENC",
 "OP_COUNT",
 "202 CHECKMULTISIGS, fails due to 201 op limit"],
 
 ["1",
 "0 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY 0 0 CHECKMULTISIGVERIFY",
 "P2SH,STRICTENC",
 "INVALID_STACK_OPERATION",
 ""],
 
 ["",
 "NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIG",
 "P2SH,STRICTENC",
 "OP_COUNT",
 "Fails due to 201 script operation limit"],
 
 ["1",
 "NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP NOP 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY 0 0 'a' 'b' 'c' 'd' 'e' 'f' 'g' 'h' 'i' 'j' 'k' 'l' 'm' 'n' 'o' 'p' 'q' 'r' 's' 't' 20 CHECKMULTISIGVERIFY",
 "P2SH,STRICTENC",
 "OP_COUNT",
 ""],
 
 
 ["0 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21", "21 CHECKMULTISIG 1", "P2SH,STRICTENC", "PUBKEY_COUNT", "nPubKeys > 20"],
 ["0 'sig' 1 0", "CHECKMULTISIG 1", "P2SH,STRICTENC", "SIG_COUNT", "nSigs > nPubKeys"],
 
 
 ["NOP 0x01 1", "HASH160 0x14 0xda1745e9b549bd0bfa1a569971c77eba30cd5a4b EQUAL", "P2SH,STRICTENC", "SIG_PUSHONLY", "Tests for Script.IsPushOnly()"],
 ["NOP1 0x01 1", "HASH160 0x14 0xda1745e9b549bd0bfa1a569971c77eba30cd5a4b EQUAL", "P2SH,STRICTENC", "SIG_PUSHONLY"],
 
 ["0 0x01 0x50", "HASH160 0x14 0xece424a6bb6ddf4db592c0faed60685047a361b1 EQUAL", "P2SH,STRICTENC", "BAD_OPCODE", "OP_RESERVED in P2SH should fail"],
 ["0 0x01 VER", "HASH160 0x14 0x0f4d7845db968f2a81b530b6f3c1d6246d4c7e01 EQUAL", "P2SH,STRICTENC", "BAD_OPCODE", "OP_VER in P2SH should fail"],
 
 ["0x00", "'00' EQUAL", "P2SH,STRICTENC", "EVAL_FALSE", "Basic OP_0 execution"],
 
 ["MINIMALDATA enforcement for PUSHDATAs"],
 
 ["PUSHDATA1 0x00", "DROP 1", "MINIMALDATA", "MINIMALDATA", "Empty vector minimally represented by OP_0"],
 ["", "PUSHDATA1 0x00 DROP 1", "MINIMALDATA", "MINIMALDATA", "Empty vector minimally represented by OP_0 (scriptPubKey)"],
 ["0x01 0x81", "DROP 1", "MINIMALDATA", "MINIMALDATA", "-1 minimally represented by OP_1NEGATE"],
 ["", "0x01 0x81 DROP 1", "MINIMALDATA", "MINIMALDATA", "-1 minimally represented by OP_1NEGATE (scriptPubKey)"],
 ["0x01 0x01", "DROP 1", "MINIMALDATA", "MINIMALDATA", "1 to 16 minimally represented by OP_1 to OP_16"],
 ["", "0x01 0x01 DROP 1", "MINIMALDATA", "MINIMALDATA", "1 to 16 minimally represented by OP_1 to OP_16 (scriptPubKey)"],
 ["0x01 0x02", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x02 DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x03", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x03 DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x04", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x04 DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x05", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x05 DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x06", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x06 DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x07", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x07 DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x08", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x08 DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x09", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x09 DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x0a", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x0a DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x0b", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x0b DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x0c", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x0c DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x0d", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x0d DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x0e", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x0e DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x0f", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x0f DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["0x01 0x10", "DROP 1", "MINIMALDATA", "MINIMALDATA"],
 ["", "0x01 0x10 DROP 1", "MINIMALDATA", "MINIMALDATA"],
 
 ["PUSHDATA1 0x48 0x111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "DROP 1", "MINIMALDATA",
  "MINIMALDATA",
  "PUSHDATA1 of 72 bytes minimally represented by direct push"],
 ["", "PUSHDATA1 0x48 0x111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 DROP 1", "MINIMALDATA",
  "MINIMALDATA",
  "PUSHDATA1 of 72 bytes minimally represented by direct push (scriptPubKey)"],
 
 ["PUSHDATA2 0xFF00 0x111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "DROP 1", "MINIMALDATA",
  "MINIMALDATA",
  "PUSHDATA2 of 255 bytes minimally represented by PUSHDATA1"],
 ["", "PUSHDATA2 0xFF00 0x111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 DROP 1", "MINIMALDATA",
  "MINIMALDATA",
  "PUSHDATA2 of 255 bytes minimally represented by PUSHDATA1 (scriptPubKey)"],
 
 ["PUSHDATA4 0x00010000 0x11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111", "DROP 1", "MINIMALDATA",
  "MINIMALDATA",
  "PUSHDATA4 of 256 bytes minimally represented by PUSHDATA2"],
 ["", "PUSHDATA4 0x00010000 0x11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111 DROP 1", "MINIMALDATA",
  "MINIMALDATA",
  "PUSHDATA4 of 256 bytes minimally represented by PUSHDATA2 (scriptPubKey)"],
 
 ["MINIMALDATA push rule enforcement with P2SH"],
 ["0x01 0x4f", "HASH160 0x14 0xc692a0d72bb4690b00f2728775fb8e45eeb190ad OP_EQUAL", "P2SH,MINIMALDATA", "OK", "minimal push inside P2SH redeemScript"],
 ["PUSHDATA1 0x01 0x4f", "HASH160 0x14 0xc692a0d72bb4690b00f2728775fb8e45eeb190ad OP_EQUAL", "P2SH,MINIMALDATA", "MINIMALDATA", "P2SH redeemScript itself was not pushed minimally"],
 ["1 0x01 0x81", "HASH160 0x14 0x19e672940307de32037c538ad37578ab38f2b83e OP_EQUAL", "P2SH,MINIMALDATA", "MINIMALDATA", "P2SH redeemscript 'OP_BIN2NUM' pushed naively"],
 ["1 -1", "HASH160 0x14 0x19e672940307de32037c538ad37578ab38f2b83e OP_EQUAL", "P2SH,MINIMALDATA", "OK", "P2SH redeemscript 'OP_BIN2NUM' pushed minimally"],
 ["0x02 0x0181", "HASH160 0x14 0x823ceb939791c0227262f8c2e5d29f072a590609 OP_EQUAL", "P2SH,MINIMALDATA", "MINIMALDATA", "non-minimal push inside P2SH redeemScript"],
 ["0x02 0x0181", "HASH160 0x14 0x823ceb939791c0227262f8c2e5d29f072a590609 OP_EQUAL", "MINIMALDATA", "OK", "non-minimal push inside P2SH redeemScript but P2SH not active"],
 
 ["MINIMALDATA enforcement for numeric arguments"],
 
 ["0x01 0x00", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "numequals 0"],
 ["0x02 0x0000", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "numequals 0"],
 ["0x01 0x80", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "0x80 (negative zero) numequals 0"],
 ["0x02 0x0080", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "numequals 0"],
 ["0x02 0x0500", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "numequals 5"],
 ["0x03 0x050000", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "numequals 5"],
 ["0x02 0x0580", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "numequals -5"],
 ["0x03 0x050080", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "numequals -5"],
 ["0x03 0xff7f80", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "Minimal encoding is 0xffff"],
 ["0x03 0xff7f00", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "Minimal encoding is 0xff7f"],
 ["0x04 0xffff7f80", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "Minimal encoding is 0xffffff"],
 ["0x04 0xffff7f00", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR", "Minimal encoding is 0xffff7f"],
 
 ["Test every numeric-accepting opcode for correct handling of the numeric minimal encoding rule"],
 
 ["1 0x02 0x0000", "PICK DROP", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["1 0x02 0x0000", "ROLL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000", "1ADD DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000", "1SUB DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000", "NEGATE DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000", "ABS DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000", "NOT DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000", "0NOTEQUAL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 
 ["0 0x02 0x0000", "ADD DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "ADD DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "SUB DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "SUB DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0100", "DIV DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 1", "DIV DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0100", "MOD DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 1", "MOD DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "BOOLAND DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "BOOLAND DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "BOOLOR DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "BOOLOR DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "NUMEQUAL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 1", "NUMEQUAL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "NUMEQUALVERIFY 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "NUMEQUALVERIFY 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "NUMNOTEQUAL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "NUMNOTEQUAL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "LESSTHAN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "LESSTHAN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "GREATERTHAN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "GREATERTHAN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "LESSTHANOREQUAL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "LESSTHANOREQUAL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "GREATERTHANOREQUAL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "GREATERTHANOREQUAL DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "MIN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "MIN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000", "MAX DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x02 0x0000 0", "MAX DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 
 ["0x02 0x0000 0 0", "WITHIN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000 0", "WITHIN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0 0x02 0x0000", "WITHIN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 
 ["0 0 0x02 0x0000", "CHECKMULTISIG DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000 0", "CHECKMULTISIG DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000 0 1", "CHECKMULTISIG DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0 0x02 0x0000", "CHECKMULTISIGVERIFY 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0 0x02 0x0000 0", "CHECKMULTISIGVERIFY 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 
 ["0x02 0x0000 1", "SPLIT 2DROP 1", "MINIMALDATA", "OK", "first operand isn't a number, so no encoding rules"],
 ["0x02 0x0000 0x02 0x0100", "SPLIT 2DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 ["0x16 0x11111111111111111111111111111111111111110000 0x01 0x14", "NUM2BIN DROP 1", "MINIMALDATA", "OK", "first operand is an unlimited number and exempted from length/minimal encoding rules"],
 ["0x16 0x11111111111111111111111111111111111111110000 0x02 0x1400", "NUM2BIN DROP 1", "MINIMALDATA", "UNKNOWN_ERROR"],
 
 ["0x16 0xffffff7f000000000000000000000000000000000000", "BIN2NUM DROP 1", "MINIMALDATA", "OK", "first operand is a number limited in magnitude but exempted from length/minimal encoding rules"],
 
 ["0x02 0x0000", "CHECKLOCKTIMEVERIFY DROP 1", "MINIMALDATA,CHECKLOCKTIMEVERIFY", "UNKNOWN_ERROR"],
 ["0x02 0x0000", "CHECKSEQUENCEVERIFY DROP 1", "MINIMALDATA,CHECKSEQUENCEVERIFY", "UNKNOWN_ERROR"],
 
 ["64/65-byte sig length tests"],
 ["0x41 0x303e021d4444444444444444444444444444444444444444444444444444444444021d444444444444444444444444444444444444444444444444444444444401", "0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 CHECKSIG NOT", "", "OK"],
 ["0x40 0x303e021d4444444444444444444444444444444444444444444444444444444444021d4444444444444444444444444444444444444444444444444444444444", "0 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 CHECKDATASIG NOT", "", "OK"],
 ["0 0x41 0x303e021d4444444444444444444444444444444444444444444444444444444444021d444444444444444444444444444444444444444444444444444444444401", "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 1 CHECKMULTISIG NOT", "", "SIG_BADLENGTH"],
 ["0 0x41 0x303e021d4444444444444444444444444444444444444444444444444444444444021d444444444444444444444444444444444444444444444444444444444401", "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 1 CHECKMULTISIG NOT", "STRICTENC,NULLFAIL", "SIG_BADLENGTH"],
 ["0 0x40 0x303d021d4444444444444444444444444444444444444444444444444444444444021c4444444444444444444444444444444444444444444444444444444401", "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 1 CHECKMULTISIG NOT", "", "OK"],
 ["0 0x42 0x303f021d4444444444444444444444444444444444444444444444444444444444021e44444444444444444444444444444444444444444444444444444444444401", "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 1 CHECKMULTISIG NOT", "", "OK"],
 
 ["0x41 0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", "0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 CHECKSIG NOT", "", "OK"],
 ["0x41 0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", "0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 CHECKSIG NOT", "STRICTENC", "OK"],
 ["0x40 0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 CHECKDATASIG NOT", "", "OK"],
 ["0x40 0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 CHECKDATASIG NOT", "STRICTENC", "OK"],
 ["0 0x41 0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 1 CHECKMULTISIG NOT", "STRICTENC", "SIG_BADLENGTH"],
 ["0 0x41 0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 1 CHECKMULTISIG NOT", "STRICTENC,NULLFAIL", "SIG_BADLENGTH"],
 
 
 
 ["Order of CHECKMULTISIG evaluation tests, inverted by swapping the order of"],
 ["pubkeys/signatures so they fail due to the STRICTENC rules on validly encoded"],
 ["signatures and pubkeys."],
 [
     "0 0x47 0x3044022044dc17b0887c161bb67ba9635bf758735bdde503e4b0a0987f587f14a4e1143d022009a215772d49a85dae40d8ca03955af26ad3978a0ff965faa12915e9586249a501 0x47 0x3044022044dc17b0887c161bb67ba9635bf758735bdde503e4b0a0987f587f14a4e1143d022009a215772d49a85dae40d8ca03955af26ad3978a0ff965faa12915e9586249a501",
     "2 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 0 2 CHECKMULTISIG NOT",
     "STRICTENC",
     "PUBKEYTYPE",
     "2-of-2 CHECKMULTISIG NOT with the first pubkey invalid, and both signatures validly encoded."
 ],
 [
     "0 0x47 0x3044022044dc17b0887c161bb67ba9635bf758735bdde503e4b0a0987f587f14a4e1143d022009a215772d49a85dae40d8ca03955af26ad3978a0ff965faa12915e9586249a501 1",
     "2 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 2 CHECKMULTISIG NOT",
     "STRICTENC",
     "SIG_DER",
     "2-of-2 CHECKMULTISIG NOT with both pubkeys valid, but first signature invalid."
 ],
 [
     "0 0x47 0x304402205451ce65ad844dbb978b8bdedf5082e33b43cae8279c30f2c74d9e9ee49a94f802203fe95a7ccf74da7a232ee523ef4a53cb4d14bdd16289680cdb97a63819b8f42f01 0x46 0x304402205451ce65ad844dbb978b8bdedf5082e33b43cae8279c30f2c74d9e9ee49a94f802203fe95a7ccf74da7a232ee523ef4a53cb4d14bdd16289680cdb97a63819b8f42f",
     "2 0x21 0x02a673638cb9587cb68ea08dbef685c6f2d2a751a8b3c6f2a7e9a4999e6e4bfaf5 0x21 0x02a673638cb9587cb68ea08dbef685c6f2d2a751a8b3c6f2a7e9a4999e6e4bfaf5 0x21 0x02a673638cb9587cb68ea08dbef685c6f2d2a751a8b3c6f2a7e9a4999e6e4bfaf5 3 CHECKMULTISIG",
     "P2SH,STRICTENC",
     "SIG_DER",
     "2-of-3 with one valid and one invalid signature due to parse error, nSigs > validSigs"
 ],
 
 ["Increase DERSIG test coverage"],
 ["0x4a 0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0 CHECKSIG NOT", "DERSIG", "SIG_DER", "Overly long signature is incorrectly encoded for DERSIG"],
 ["0x25 0x30220220000000000000000000000000000000000000000000000000000000000000000000", "0 CHECKSIG NOT", "DERSIG", "SIG_DER", "Missing S is incorrectly encoded for DERSIG"],
 ["0x27 0x3024021077777777777777777777777777777777020a7777777777777777777777777777777701", "0 CHECKSIG NOT", "DERSIG", "SIG_DER", "S with invalid S length is incorrectly encoded for DERSIG"],
 ["0x27 0x302403107777777777777777777777777777777702107777777777777777777777777777777701", "0 CHECKSIG NOT", "DERSIG", "SIG_DER", "Non-integer R is incorrectly encoded for DERSIG"],
 ["0x27 0x302402107777777777777777777777777777777703107777777777777777777777777777777701", "0 CHECKSIG NOT", "DERSIG", "SIG_DER", "Non-integer S is incorrectly encoded for DERSIG"],
 ["0x17 0x3014020002107777777777777777777777777777777701", "0 CHECKSIG NOT", "DERSIG", "SIG_DER", "Zero-length R is incorrectly encoded for DERSIG"],
 ["0x17 0x3014021077777777777777777777777777777777020001", "0 CHECKSIG NOT", "DERSIG", "SIG_DER", "Zero-length S is incorrectly encoded for DERSIG"],
 ["0x27 0x302402107777777777777777777777777777777702108777777777777777777777777777777701", "0 CHECKSIG NOT", "DERSIG", "SIG_DER", "Negative S is incorrectly encoded for DERSIG"],
 
 ["Segwit recovery tests"],
 [
     "0x16 0x001491b24bf9f5288532960ac687abb035127b1d28a5",
     "HASH160 0x14 0x17743beb429c55c942d2ec703b98c4d57c2df5c6 EQUAL",
     "CLEANSTACK,DISALLOW_SEGWIT_RECOVERY,P2SH",
     "CLEANSTACK",
     "v0 P2SH-P2WPKH with SCRIPT_DISALLOW_SEGWIT_RECOVERY"
 ],
 [
     "0x16 0x001491b24bf9f5288532960ac687abb035127b1d28a5",
     "HASH160 0x14 0x17743beb429c55c942d2ec703b98c4d57c2df5c6 EQUAL",
     "CLEANSTACK,P2SH",
     "OK",
     "Valid Segwit Recovery with v0 P2SH-P2WPKH"
 ],
 [
     "0 0x16 0x001491b24bf9f5288532960ac687abb035127b1d28a5",
     "HASH160 0x14 0x17743beb429c55c942d2ec703b98c4d57c2df5c6 EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "v0 P2SH-P2WPKH Segwit Recovery with extra stack item"
 ],
 [
     "0x22 0x00205a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
     "HASH160 0x14 0x17a6be2f8fe8e94f033e53d17beefda0f3ac4409 EQUAL",
     "CLEANSTACK,DISALLOW_SEGWIT_RECOVERY,P2SH",
     "CLEANSTACK",
     "v0 P2SH-P2WSH with SCRIPT_DISALLOW_SEGWIT_RECOVERY"
 ],
 [
     "0x22 0x00205a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
     "HASH160 0x14 0x17a6be2f8fe8e94f033e53d17beefda0f3ac4409 EQUAL",
     "CLEANSTACK,P2SH",
     "OK",
     "Valid Segwit Recovery with v0 P2SH-P2WSH"
 ],
 [
     "0 0x22 0x00205a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
     "HASH160 0x14 0x17a6be2f8fe8e94f033e53d17beefda0f3ac4409 EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "v0 P2SH-P2WSH Segwit Recovery with extra stack item"
 ],
 [
     "0x03 0x00015a",
     "HASH160 0x14 0x40b6941895022d458de8f4bbfe27f3aaa4fb9a74 EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "Segwit Recovery with invalid witness program (too short)"
 ],
 [
     "0x04 0x00025a01",
     "HASH160 0x14 0x86123d8e050333a605e434ecf73128d83815b36f EQUAL",
     "CLEANSTACK,P2SH",
     "OK",
     "Segwit Recovery with valid witness program (min allowed length)"
 ],
 [
     "0x2a 0x00285a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f2021222324252627",
     "HASH160 0x14 0xdf7b93f88e83471b479fb219ae90e5b633d6b750 EQUAL",
     "CLEANSTACK,P2SH",
     "OK",
     "Segwit Recovery with valid witness program (max allowed length)"
 ],
 [
     "0x2b 0x00295a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728",
     "HASH160 0x14 0x13aa4fcfd630508e0794dca320cac172c5790aea EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "Segwit Recovery with invalid witness program (too long)"
 ],
 [
     "0x22 0x60205a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
     "HASH160 0x14 0x9b0c7017004d3818b7c833ddb3cb5547a22034d0 EQUAL",
     "CLEANSTACK,P2SH",
     "OK",
     "Segwit Recovery with valid witness program (max allowed version)"
 ],
 [
     "0x22 0x4f205a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
     "HASH160 0x14 0x97aa1e96e49ca6d744d7344f649dd9f94bcc35eb EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "Segwit Recovery with invalid witness program (invalid version -1)"
 ],
 [
     "0x23 0x0111205a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
     "HASH160 0x14 0x4b5321beb1c09f593ff3c02be4af21c7f949e101 EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "Segwit Recovery with invalid witness program (invalid version 17)"
 ],
 [
     "0x23 0x00205a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f51",
     "HASH160 0x14 0x8eb812176c9e71732584123dd06d3246e659b199 EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "Segwit Recovery with invalid witness program (more than 2 stack items)"
 ],
 [
     "0x04 0x00020000",
     "HASH160 0x14 0x0e01bcfe7c6f3fd2fd8f81092299369744684733 EQUAL",
     "CLEANSTACK,P2SH",
     "OK",
     "Valid segwit recovery, in spite of false value being left on stack (0)"
 ],
 [
     "0x04 0x00020080",
     "HASH160 0x14 0x10ddc638cb26615f867dad80efacced9e73766bc EQUAL",
     "CLEANSTACK,P2SH",
     "OK",
     "Valid segwit recovery, in spite of false value being left on stack (minus 0)"
 ],
 [
     "0x04 0x00020000",
     "HASH160 0x14 0x0e01bcfe7c6f3fd2fd8f81092299369744684733 EQUAL",
     "CLEANSTACK,DISALLOW_SEGWIT_RECOVERY,P2SH",
     "EVAL_FALSE",
     "Otherwise valid segwit recovery, in spite of false value being left on stack (0), but with SCRIPT_DISALLOW_SEGWIT_RECOVERY"
 ],
 [
     "0x04 0x00020080",
     "HASH160 0x14 0x10ddc638cb26615f867dad80efacced9e73766bc EQUAL",
     "CLEANSTACK,DISALLOW_SEGWIT_RECOVERY,P2SH",
     "EVAL_FALSE",
     "Otherwise valid segwit recovery, in spite of false value being left on stack (minus 0), but with SCRIPT_DISALLOW_SEGWIT_RECOVERY"
 ],
 [
     "0x22 0x50205a0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",
     "HASH160 0x14 0xbe02794ceede051da41b420e88a86fff2802af06 EQUAL",
     "CLEANSTACK,P2SH",
     "BAD_OPCODE",
     "Segwit Recovery with invalid witness program (OP_RESERVED in version field)"
 ],
 [
     "0x17 0x01001491b24bf9f5288532960ac687abb035127b1d28a5",
     "HASH160 0x14 0x0718743e67c1ef4911e0421f206c5ff81755718e EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "Segwit Recovery with invalid witness program (non-minimal push in version field)"
 ],
 [
     "0x05 0x004c0245aa",
     "HASH160 0x14 0xd3ec673296c7fd7e1a9e53bfc36f414de303e905 EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "Segwit Recovery with invalid witness program (non-minimal push in program field)"
 ],
 [
     "0x16 0x001491b24bf9f5288532960ac687abb035127b1d28a5",
     "HASH160 0x14 0x17a6be2f8fe8e94f033e53d17beefda0f3ac4409 EQUAL",
     "CLEANSTACK,P2SH",
     "EVAL_FALSE",
     "v0 P2SH-P2WPKH Segwit Recovery whose redeem script hash does not match P2SH output"
 ],
 [
     "0x16 0x001491b24bf9f5288532960ac687abb035127b1d28a5",
     "1",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "v0 P2SH-P2WPKH Segwit Recovery spending a non-P2SH output"
 ],
 
 ["Automatically generated test cases"],
 [
     "0x47 0x3044022022127048516d473153d1f74e46e828496776752e3255f672f760a41e83f54e6f0220502956b739ed82aad916dc4a73e1fd55d02aad514b5211f1ba7d0dadf53c637901",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "",
     "OK",
     "P2PK"
 ],
 [
     "0x47 0x3044022022127048516d463153d1f74e46e828496776752e3255f672f760a41e83f54e6f0220502956b739ed82aad916dc4a73e1fd55d02aad514b5211f1ba7d0dadf53c637901",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "",
     "EVAL_FALSE",
     "P2PK, bad sig"
 ],
 [
     "0x47 0x304402201e0ec3c6c263f34049c93e0bc646d7287ca2cc6571d658e4e7269daebc96ef35022009841f101e6dcaba8993d0259e5732a871e253be807556bf5618bf0bc3e84af001 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508",
     "DUP HASH160 0x14 0x1018853670f9f3b0582c5b9ee8ce93764ac32b93 EQUALVERIFY CHECKSIG",
     "",
     "OK",
     "P2PKH"
 ],
 [
     "0x47 0x304402201dddd1a3b642f1b543cbecad602558636135d59b3850a4d1646a0b11c712b340022016d58230012421b304d1cc42ccc1e33738206be64f7984be30ed437fa7a2fd0a01 0x21 0x03363d90d446b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640",
     "DUP HASH160 0x14 0xc0834c0c158f53be706d234c38fd52de7eece656 EQUALVERIFY CHECKSIG",
     "",
     "EQUALVERIFY",
     "P2PKH, bad pubkey"
 ],
 [
     "0x47 0x304402206e8719d1746852542bed4f05a57f0369759553c7d655229759de2643f371e20002207a7f06790da5757d2f37c4d074de0fe66ac149ee011baeb4dd3fa97f288637f881",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "",
     "OK",
     "P2PK anyonecanpay"
 ],
 [
     "0x47 0x304402206e8719d1746852542bed4f05a57f0369759553c7d655229759de2643f371e20002207a7f06790da5757d2f37c4d074de0fe66ac149ee011baeb4dd3fa97f288637f801",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "",
     "EVAL_FALSE",
     "P2PK anyonecanpay marked with normal hashtype"
 ],
 [
     "0x47 0x304402206f04a92fb434b24b06180c7c2af5f4fb73f15427da93b5ab8c167c7d10f4f37902203f0b57300a19fe106d79f427360a6b4720117ab50de44047e52a35de2523291e01 0x23 0x210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798ac",
     "HASH160 0x14 0x23b0ad3477f2178bc0b3eed26e4e6316f4e83aa1 EQUAL",
     "P2SH",
     "OK",
     "P2SH(P2PK)"
 ],
 [
     "0x47 0x304402206f04a92fb434b24b06180c7c2af5f4fb73f15427da93b5ab8c167c7d10f4f37902203f0b57300a19fe106d79f427360a6b4720117ab50de44047e52a35de2523291e01 0x23 0x210279be667ef9dcbbac54a06295ce870b07029bfcdb2dce28d959f2815b16f81798ac",
     "HASH160 0x14 0x23b0ad3477f2178bc0b3eed26e4e6316f4e83aa1 EQUAL",
     "P2SH",
     "EVAL_FALSE",
     "P2SH(P2PK), bad redeemscript"
 ],
 [
     "0x47 0x304402201799a8feda56fd3c58b816eac4f0bb916136b4f60b5c5da3264f5c29aec13abf022029c9d7779a5376b5d0398e389817699bb2485a305eb1fa5868081c3a9d89bee201 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 0x19 0x76a91491b24bf9f5288532960ac687abb035127b1d28a588ac",
     "HASH160 0x14 0x7f67f0521934a57d3039f77f9f32cf313f3ac74b EQUAL",
     "P2SH",
     "OK",
     "P2SH(P2PKH)"
 ],
 [
     "0x47 0x3044022001aabce638c1bc883223651a4252d36e5918681e85562fe5b112f08bc944644902203110421d46142317ec5ca117ce4d40593ace16ab5b9688eb2ce8103b3a9273c701 0x19 0x76a9147cf9c846cd4882efec4bf07e44ebdad495c94f4b88ac",
     "HASH160 0x14 0x2df519943d5acc0ef5222091f9dfe3543f489a82 EQUAL",
     "",
     "OK",
     "P2SH(P2PKH), bad sig but no VERIFY_P2SH"
 ],
 [
     "0x47 0x3044022001aabce638c1bc883223651a4252d36e5918681e85562fe5b112f08bc944644902203110421d46142317ec5ca117ce4d40593ace16ab5b9688eb2ce8103b3a9273c701 0x19 0x76a9147cf9c846cd4882efec4bf07e44ebdad495c94f4b88ac",
     "HASH160 0x14 0x2df519943d5acc0ef5222091f9dfe3543f489a82 EQUAL",
     "P2SH",
     "EQUALVERIFY",
     "P2SH(P2PKH), bad sig"
 ],
 [
     "0 0x47 0x304402204d69d5caa4dbab259f79fce89d3b459bbd91697c1c052a1554ff3b08b2241cbd0220330a8e17a90d51996e363cb8902fce6278c6350fa59ae12832db2f6a44d64dce01 0x47 0x3044022031a1e5289b0d9c33ec182a7f67210b9997187c710f7d3f0f28bdfb618c4e025c02205d95fe63ee83a20ec44159a06f7c0b43b61d5f0c346ca4a2cc7b91878ad1a85001 0x47 0x304402200a9faba8228f7a86bf6c3b2a0da0e2f9136ea390e5a5f66dbf232e499459f34a0220437bcac47d837870eeb41aabc379cbf2b1dcef954bd887f3968849922694ebd701",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "",
     "OK",
     "3-of-3"
 ],
 [
     "0 0x47 0x304402204d69d5caa4dbab259f79fce89d3b459bbd91697c1c052a1554ff3b08b2241cbd0220330a8e17a90d51996e363cb8902fce6278c6350fa59ae12832db2f6a44d64dce01 0x47 0x3044022031a1e5289b0d9c33ec182a7f67210b9997187c710f7d3f0f28bdfb618c4e025c02205d95fe63ee83a20ec44159a06f7c0b43b61d5f0c346ca4a2cc7b91878ad1a85001 0",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "",
     "EVAL_FALSE",
     "3-of-3, 2 sigs"
 ],
 [
     "0 0x47 0x304402205b6256a4755890fe278ea083eddf5c0519d0d7fad14fe265e077c5627171b27e02200d841cb15cdc9a9c8f3ec20c5e4bb1b0e5715d26353f500378f4215195e3558c01 0x47 0x304402200b0620f910e92621934e88ae0177b0bb381ba812d4c23c77afbf1a3ab637a0bb0220275387c859089939e22d803dfae77a4ecd122d951d0feb9e6a65a6918c2b1e0201 0x4c69 0x52210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464053ae",
     "HASH160 0x14 0xc9e4a896d149702d0d1695434feddd52e24ad78d EQUAL",
     "P2SH",
     "OK",
     "P2SH(2-of-3)"
 ],
 [
     "0 0x47 0x304402205b6256a4755890fe278ea083eddf5c0519d0d7fad14fe265e077c5627171b27e02200d841cb15cdc9a9c8f3ec20c5e4bb1b0e5715d26353f500378f4215195e3558c01 0 0x4c69 0x52210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464053ae",
     "HASH160 0x14 0xc9e4a896d149702d0d1695434feddd52e24ad78d EQUAL",
     "P2SH",
     "EVAL_FALSE",
     "P2SH(2-of-3), 1 sig"
 ],
 [
     "0x47 0x30440220007dc49df798c714600c93a94dcdffc89013aac6683c2be18c54d136fea0a26e0220681bb9fad75a638536c0cfafaca8332a15c6c4047fd3989df5d232c0efa5411f01",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "",
     "OK",
     "P2PK with too much R padding but no DERSIG"
 ],
 [
     "0x47 0x30440220007dc49df798c714600c93a94dcdffc89013aac6683c2be18c54d136fea0a26e0220681bb9fad75a638536c0cfafaca8332a15c6c4047fd3989df5d232c0efa5411f01",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "DERSIG",
     "SIG_DER",
     "P2PK with too much R padding"
 ],
 [
     "0x48 0x304502207a404c8f2bb2ac64db7cbd4d3490eaecb06115172d99e4447e6f4dbfbaa92fe4022100631033d772b4313d4a0d3cda8eacab93654dd8bcdfb9340ba9271be29cfc249c01",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "",
     "OK",
     "P2PK with too much S padding but no DERSIG"
 ],
 [
     "0x48 0x304502207a404c8f2bb2ac64db7cbd4d3490eaecb06115172d99e4447e6f4dbfbaa92fe4022100631033d772b4313d4a0d3cda8eacab93654dd8bcdfb9340ba9271be29cfc249c01",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "DERSIG",
     "SIG_DER",
     "P2PK with too much S padding"
 ],
 [
     "0x47 0x30440220d888248d694d649657d71a5baebb70512525ba5fe76575afb5cbbe9f0680783d022054a16bce5e3957be61e15940b11d66515bc8df1c0e090c47acf32515d56ef95001",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "",
     "OK",
     "P2PK with too little R padding but no DERSIG"
 ],
 [
     "0x47 0x30440220d888248d694d649657d71a5baebb70512525ba5fe76575afb5cbbe9f0680783d022054a16bce5e3957be61e15940b11d66515bc8df1c0e090c47acf32515d56ef95001",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "DERSIG",
     "SIG_DER",
     "P2PK with too little R padding"
 ],
 [
     "0x47 0x30440220001d5bd10da0bc0ab3018cea865f8d936bf625fee21464b127532f6021d5e82b02203b3660b9dccd43ae3def3ec3e1853b2566bb6bd899f5364c06508eec532f700e01",
     "0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG NOT",
     "",
     "OK",
     "P2PK NOT with bad sig with too much R padding but no DERSIG"
 ],
 [
     "0x47 0x30440220001d5bd10da0bc0ab3018cea865f8d936bf625fee21464b127532f6021d5e82b02203b3660b9dccd43ae3def3ec3e1853b2566bb6bd899f5364c06508eec532f700e01",
     "0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG NOT",
     "DERSIG",
     "SIG_DER",
     "P2PK NOT with bad sig with too much R padding"
 ],
 [
     "0x47 0x30440220001d5bd10da0bd0ab3018cea865f8d936bf625fee21464b127532f6021d5e82b02203b3660b9dccd43ae3def3ec3e1853b2566bb6bd899f5364c06508eec532f700e01",
     "0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG NOT",
     "",
     "EVAL_FALSE",
     "P2PK NOT with too much R padding but no DERSIG"
 ],
 [
     "0x47 0x30440220001d5bd10da0bd0ab3018cea865f8d936bf625fee21464b127532f6021d5e82b02203b3660b9dccd43ae3def3ec3e1853b2566bb6bd899f5364c06508eec532f700e01",
     "0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG NOT",
     "DERSIG",
     "SIG_DER",
     "P2PK NOT with too much R padding"
 ],
 [
     "0x47 0x30440220d888248d694d649657d71a5baebb70512525ba5fe76575afb5cbbe9f0680783d022054a16bce5e3957be61e15940b11d66515bc8df1c0e090c47acf32515d56ef95001",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "",
     "OK",
     "BIP66 example 1, without DERSIG"
 ],
 [
     "0x47 0x30440220d888248d694d649657d71a5baebb70512525ba5fe76575afb5cbbe9f0680783d022054a16bce5e3957be61e15940b11d66515bc8df1c0e090c47acf32515d56ef95001",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "DERSIG",
     "SIG_DER",
     "BIP66 example 1, with DERSIG"
 ],
 [
     "0x47 0x304402208eae7755261155b02becf6e6990fe6d1392210ff19d46cbbba5456e4b59a71cd022047054a0a3f229eaf9f597033c85877913596fa7bdaf2f1b55cf5704ce6ee99bc01",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG NOT",
     "",
     "EVAL_FALSE",
     "BIP66 example 2, without DERSIG"
 ],
 [
     "0x47 0x304402208eae7755261155b02becf6e6990fe6d1392210ff19d46cbbba5456e4b59a71cd022047054a0a3f229eaf9f597033c85877913596fa7bdaf2f1b55cf5704ce6ee99bc01",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG NOT",
     "DERSIG",
     "SIG_DER",
     "BIP66 example 2, with DERSIG"
 ],
 [
     "0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "",
     "EVAL_FALSE",
     "BIP66 example 3, without DERSIG"
 ],
 [
     "0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "DERSIG",
     "EVAL_FALSE",
     "BIP66 example 3, with DERSIG"
 ],
 [
     "0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG NOT",
     "",
     "OK",
     "BIP66 example 4, without DERSIG"
 ],
 [
     "0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG NOT",
     "DERSIG",
     "OK",
     "BIP66 example 4, with DERSIG"
 ],
 [
     "0x09 0x300602010102010101",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG NOT",
     "DERSIG",
     "OK",
     "BIP66 example 4, with DERSIG, non-null DER-compliant signature"
 ],
 [
     "0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG NOT",
     "DERSIG,NULLFAIL",
     "OK",
     "BIP66 example 4, with DERSIG and NULLFAIL"
 ],
 [
     "0x09 0x300602010102010101",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG NOT",
     "DERSIG,NULLFAIL",
     "NULLFAIL",
     "BIP66 example 4, with DERSIG and NULLFAIL, non-null DER-compliant signature"
 ],
 [
     "1",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "",
     "EVAL_FALSE",
     "BIP66 example 5, without DERSIG"
 ],
 [
     "1",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG",
     "DERSIG",
     "SIG_DER",
     "BIP66 example 5, with DERSIG"
 ],
 [
     "1",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG NOT",
     "",
     "OK",
     "BIP66 example 6, without DERSIG"
 ],
 [
     "1",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKSIG NOT",
     "DERSIG",
     "SIG_DER",
     "BIP66 example 6, with DERSIG"
 ],
 [
     "0 0x47 0x30440220868d1de0f6cc0b0d465992dd177fc545df03381f5a79c171ad55990e623417da022078276700801d7f454b013ded53ddeca5d9ea55bd704e1683832ece986c09fd3201 0x47 0x304402207349bbfeebc59c0efc363dc94e0c0f0491e9c6456a86b753c4ce1ca74b51bfdf02200d94da026a56016b975451d7b0dd2c46780ac3dfa008791e0665af04a235e80f01",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG",
     "",
     "OK",
     "BIP66 example 7, without DERSIG"
 ],
 [
     "0 0x47 0x30440220868d1de0f6cc0b0d465992dd177fc545df03381f5a79c171ad55990e623417da022078276700801d7f454b013ded53ddeca5d9ea55bd704e1683832ece986c09fd3201 0x47 0x304402207349bbfeebc59c0efc363dc94e0c0f0491e9c6456a86b753c4ce1ca74b51bfdf02200d94da026a56016b975451d7b0dd2c46780ac3dfa008791e0665af04a235e80f01",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG",
     "DERSIG",
     "SIG_DER",
     "BIP66 example 7, with DERSIG"
 ],
 [
     "0 0x47 0x30440220e8172152b43bc9c788442b116c2345f04591d44d5be77cd6e9acafed7cd3649e022075c0e1014e000cf02e2cc4b33159d74e94c54a5c8d2c046bae2a7e1e38896b2f01 0x47 0x30440220667437f14da10aca92795812e31784b42824d865c535584b7f01a0b1d7bda8b802203331b1f9d6421310aace34a3a8b193853bf17dcec0cfe3f2ddec806bbeee527801",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG NOT",
     "",
     "EVAL_FALSE",
     "BIP66 example 8, without DERSIG"
 ],
 [
     "0 0x47 0x30440220e8172152b43bc9c788442b116c2345f04591d44d5be77cd6e9acafed7cd3649e022075c0e1014e000cf02e2cc4b33159d74e94c54a5c8d2c046bae2a7e1e38896b2f01 0x47 0x30440220667437f14da10aca92795812e31784b42824d865c535584b7f01a0b1d7bda8b802203331b1f9d6421310aace34a3a8b193853bf17dcec0cfe3f2ddec806bbeee527801",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG NOT",
     "DERSIG",
     "SIG_DER",
     "BIP66 example 8, with DERSIG"
 ],
 [
     "0 0 0x47 0x30440220e6afebaa7f2b0a06c014519ee51d97e73365151e802a3913bb9b1198021ffdb702200e6cbbe6ba99a5b4424756a544e5ffed5867b67430b9ba893f2b65309a8a762d01",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG",
     "",
     "EVAL_FALSE",
     "BIP66 example 9, without DERSIG"
 ],
 [
     "0 0 0x47 0x30440220e6afebaa7f2b0a06c014519ee51d97e73365151e802a3913bb9b1198021ffdb702200e6cbbe6ba99a5b4424756a544e5ffed5867b67430b9ba893f2b65309a8a762d01",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG",
     "DERSIG",
     "SIG_DER",
     "BIP66 example 9, with DERSIG"
 ],
 [
     "0 0 0x47 0x30440220e8e61fae71ba1147b92ea58aae6d314001d6071add352af500da476f466782600220112491a261785241c009386e18a5f79b946a58ba958081a7da1ccec31f3aa9bc01",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG NOT",
     "",
     "OK",
     "BIP66 example 10, without DERSIG"
 ],
 [
     "0 0 0x47 0x30440220e8e61fae71ba1147b92ea58aae6d314001d6071add352af500da476f466782600220112491a261785241c009386e18a5f79b946a58ba958081a7da1ccec31f3aa9bc01",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG NOT",
     "DERSIG",
     "SIG_DER",
     "BIP66 example 10, with DERSIG"
 ],
 [
     "0 0x47 0x30440220868d1de0f6cc0b0d465992dd177fc545df03381f5a79c171ad55990e623417da022078276700801d7f454b013ded53ddeca5d9ea55bd704e1683832ece986c09fd3201 0",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG",
     "",
     "EVAL_FALSE",
     "BIP66 example 11, without DERSIG"
 ],
 [
     "0 0x47 0x30440220868d1de0f6cc0b0d465992dd177fc545df03381f5a79c171ad55990e623417da022078276700801d7f454b013ded53ddeca5d9ea55bd704e1683832ece986c09fd3201 0",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG",
     "DERSIG",
     "EVAL_FALSE",
     "BIP66 example 11, with DERSIG"
 ],
 [
     "0 0x47 0x30440220e8172152b43bc9c788442b116c2345f04591d44d5be77cd6e9acafed7cd3649e022075c0e1014e000cf02e2cc4b33159d74e94c54a5c8d2c046bae2a7e1e38896b2f01 0",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG NOT",
     "",
     "OK",
     "BIP66 example 12, without DERSIG"
 ],
 [
     "0 0x47 0x30440220e8172152b43bc9c788442b116c2345f04591d44d5be77cd6e9acafed7cd3649e022075c0e1014e000cf02e2cc4b33159d74e94c54a5c8d2c046bae2a7e1e38896b2f01 0",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 2 CHECKMULTISIG NOT",
     "DERSIG",
     "OK",
     "BIP66 example 12, with DERSIG"
 ],
 [
     "0x48 0x3044022032d4a3dec9cad54c94b5585fb058f7e41ac5173843b0c2e7197a40421ee4ab54022041d4d4296d8c2821bb39f6349f0140bc2c95f16496df9fcd894758673d1db7d80101",
     "0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG",
     "",
     "OK",
     "P2PK with multi-byte hashtype, without DERSIG"
 ],
 [
     "0x48 0x3044022032d4a3dec9cad54c94b5585fb058f7e41ac5173843b0c2e7197a40421ee4ab54022041d4d4296d8c2821bb39f6349f0140bc2c95f16496df9fcd894758673d1db7d80101",
     "0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG",
     "DERSIG",
     "SIG_DER",
     "P2PK with multi-byte hashtype, with DERSIG"
 ],
 [
     "0x48 0x3045022032d4a3dec9cad54c94b5585fb058f7e41ac5173843b0c2e7197a40421ee4ab54022100be2b2bd69273d7de44c609cb60febf428e18eb821869006e368b06259318896901",
     "0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG",
     "",
     "OK",
     "P2PK with high S but no LOW_S"
 ],
 [
     "0x48 0x3045022032d4a3dec9cad54c94b5585fb058f7e41ac5173843b0c2e7197a40421ee4ab54022100be2b2bd69273d7de44c609cb60febf428e18eb821869006e368b06259318896901",
     "0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG",
     "LOW_S",
     "SIG_HIGH_S",
     "P2PK with high S"
 ],
 [
     "0x47 0x304402201162483d0440fc508d79d314a91cfc4df4ea31b302f02c16893fa15d9c9f7f06022032afebdd5b2964c40c887b967f9599e0e5b5ff5b2f899ab62ada12a5af2a481701",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "",
     "OK",
     "P2PK with hybrid pubkey but no STRICTENC"
 ],
 [
     "0x47 0x304402201162483d0440fc508d79d314a91cfc4df4ea31b302f02c16893fa15d9c9f7f06022032afebdd5b2964c40c887b967f9599e0e5b5ff5b2f899ab62ada12a5af2a481701",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "STRICTENC",
     "PUBKEYTYPE",
     "P2PK with hybrid pubkey"
 ],
 [
     "0x47 0x3044022057a786d0e26b1bad0f928d05b94a995afefe4f523450ef82893779e95cf2042102203b049387f08eac1829061b91a6cf0b67280b4b4948e4e1773d3b4dfbbd64a4c001",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG NOT",
     "",
     "EVAL_FALSE",
     "P2PK NOT with hybrid pubkey but no STRICTENC"
 ],
 [
     "0x47 0x3044022057a786d0e26b1bad0f928d05b94a995afefe4f523450ef82893779e95cf2042102203b049387f08eac1829061b91a6cf0b67280b4b4948e4e1773d3b4dfbbd64a4c001",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG NOT",
     "STRICTENC",
     "PUBKEYTYPE",
     "P2PK NOT with hybrid pubkey"
 ],
 [
     "0x47 0x3044022057a786d0e26b1aad0f928d05b94a995afefe4f523450ef82893779e95cf2042102203b049387f08eac1829061b91a6cf0b67280b4b4948e4e1773d3b4dfbbd64a4c001",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG NOT",
     "",
     "OK",
     "P2PK NOT with invalid hybrid pubkey but no STRICTENC"
 ],
 [
     "0x47 0x3044022057a786d0e26b1aad0f928d05b94a995afefe4f523450ef82893779e95cf2042102203b049387f08eac1829061b91a6cf0b67280b4b4948e4e1773d3b4dfbbd64a4c001",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG NOT",
     "STRICTENC",
     "PUBKEYTYPE",
     "P2PK NOT with invalid hybrid pubkey"
 ],
 [
     "0 0x47 0x30440220379db2a13c8c679bda7f500c93bae36e0d75c96b8af1754316a9c80e843f2923022046ee947cd3b916ab78f95be6ae29cc2f037ddb47f8e59c966b1e6813b270648001",
     "1 0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 2 CHECKMULTISIG",
     "",
     "OK",
     "1-of-2 with the second 1 hybrid pubkey and no STRICTENC"
 ],
 [
     "0 0x47 0x30440220379db2a13c8c679bda7f500c93bae36e0d75c96b8af1754316a9c80e843f2923022046ee947cd3b916ab78f95be6ae29cc2f037ddb47f8e59c966b1e6813b270648001",
     "1 0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 2 CHECKMULTISIG",
     "STRICTENC",
     "OK",
     "1-of-2 with the second 1 hybrid pubkey"
 ],
 [
     "0 0x47 0x304402202d4dd56f6dee2eccc049a4ebd65e77e4325aa3f2940130412b9f96fd28fa8c5a022074963950dd250d2fc943e60c7a4133cc8b1fcc46253e9b19f71c9723d1d894ef01",
     "1 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 2 CHECKMULTISIG",
     "STRICTENC",
     "PUBKEYTYPE",
     "1-of-2 with the first 1 hybrid pubkey"
 ],
 [
     "0x47 0x30440220020cf2d9ccc6d8a8b2f6f0f90e9805845194d9715392e58f08e1b63d2566c53e02207b75a322355b3820f59dffc5793ed5947aa3f4e460edeb28cc306573db09495705",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "",
     "OK",
     "P2PK with undefined hashtype but no STRICTENC"
 ],
 [
     "0x47 0x30440220020cf2d9ccc6d8a8b2f6f0f90e9805845194d9715392e58f08e1b63d2566c53e02207b75a322355b3820f59dffc5793ed5947aa3f4e460edeb28cc306573db09495705",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "STRICTENC",
     "SIG_HASHTYPE",
     "P2PK with undefined hashtype"
 ],
 [
     "0x47 0x3044022070fd4f47970fdb7814b79482d1132a7c3598437bef78f8458de6e5d66ce918fd02204e657846fee57cb6fc3cbaae6b85db8646cc351f96155c86387388c2e8a5a83a21 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
     "DUP HASH160 0x14 0x91b24bf9f5288532960ac687abb035127b1d28a5 EQUALVERIFY CHECKSIG",
     "",
     "OK",
     "P2PKH with invalid sighashtype"
 ],
 [
     "0x47 0x3044022070fd4f47970fdb7814b79482d1132a7c3598437bef78f8458de6e5d66ce918fd02204e657846fee57cb6fc3cbaae6b85db8646cc351f96155c86387388c2e8a5a83a21 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
     "DUP HASH160 0x14 0x91b24bf9f5288532960ac687abb035127b1d28a5 EQUALVERIFY CHECKSIG",
     "STRICTENC",
     "SIG_HASHTYPE",
     "P2PKH with invalid sighashtype and STRICTENC"
 ],
 [
     "0x47 0x30440220643b4c3979d9d2c41842d4843113c1b40ca1df85805c7c654cabb015208c23f702207d3675bf98419065ac9a24865b652551849a0b1e52fdc429cd150f5e7897627821 0x43 0x41048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26cafac",
     "HASH160 0x14 0x49ba2f86705b5dcd48d93b750f03289db3b8ce21 EQUAL",
     "P2SH",
     "OK",
     "P2SH(P2PK) with invalid sighashtype"
 ],
 [
     "0x47 0x30440220643b4c3979d9d2c41842d4843113c1b40ca1df85805c7c654cabb015208c23f702207d3675bf98419065ac9a24865b652551849a0b1e52fdc429cd150f5e7897627821 0x43 0x41048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26cafac",
     "HASH160 0x14 0x49ba2f86705b5dcd48d93b750f03289db3b8ce21 EQUAL",
     "P2SH,STRICTENC",
     "SIG_HASHTYPE",
     "P2SH(P2PK) with invalid sighashtype and STRICTENC"
 ],
 [
     "0x47 0x304402200cbfa0902c2129020eb09acbf89725a409573096046d4bb7ba0bdc2af1588139022062a9c69be90b7f434c7e38a8a741df604a695610a8f6a0789082f1104f72d57105",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG NOT",
     "",
     "OK",
     "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC"
 ],
 [
     "0x47 0x304402200cbfa0902c2129020eb09acbf89725a409573096046d4bb7ba0bdc2af1588139022062a9c69be90b7f434c7e38a8a741df604a695610a8f6a0789082f1104f72d57105",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG NOT",
     "STRICTENC",
     "SIG_HASHTYPE",
     "P2PK NOT with invalid sig and undefined hashtype"
 ],
 [
     "1 0x47 0x304402204d69d5caa4dbab259f79fce89d3b459bbd91697c1c052a1554ff3b08b2241cbd0220330a8e17a90d51996e363cb8902fce6278c6350fa59ae12832db2f6a44d64dce01 0x47 0x3044022031a1e5289b0d9c33ec182a7f67210b9997187c710f7d3f0f28bdfb618c4e025c02205d95fe63ee83a20ec44159a06f7c0b43b61d5f0c346ca4a2cc7b91878ad1a85001 0x47 0x304402200a9faba8228f7a86bf6c3b2a0da0e2f9136ea390e5a5f66dbf232e499459f34a0220437bcac47d837870eeb41aabc379cbf2b1dcef954bd887f3968849922694ebd701",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "",
     "OK",
     "3-of-3 with nonzero dummy"
 ],
 [
     "1 0x47 0x304402203f78692a12d075d5057dea07265f0ba8ede774f083b85896fe07231efbe155da0220388fc48ffd8fb1c189fbf8bd767ee1c38b3f5d864b18faa1d81d0c3670cda85b01 0x47 0x3044022070a2850b5363fc49db8f617f08f5947bb85a1d439da07a6dc0d2fc178d9a5f3f022019e15a476e9dab8e3cb18a2bcae279366b1701c1b11c020851517cf03132bbff01 0x47 0x304402206457d83204e94902c789a16fa9e2f1f1d25684c7748c93373e9077b01a49b80a02204b0509cba423c7bbad8f80653c54a1ce10c901d33292464a4d5162f2016ddc2901",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG NOT",
     "",
     "OK",
     "3-of-3 NOT with invalid sig and nonzero dummy"
 ],
 [
     "0 0x47 0x3044022044b11d5a64bebbd4280c616146bc961eed3081300eef527fbe8da91f6775892a022045b044719bf5c7100617cd518fff22c102f93e6768ed986543668be43bc44d1601 DUP",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 2 CHECKMULTISIG",
     "",
     "OK",
     "2-of-2 with two identical keys and sigs pushed using OP_DUP but no SIGPUSHONLY"
 ],
 [
     "0 0x47 0x3044022044b11d5a64bebbd4280c616146bc961eed3081300eef527fbe8da91f6775892a022045b044719bf5c7100617cd518fff22c102f93e6768ed986543668be43bc44d1601 DUP",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 2 CHECKMULTISIG",
     "SIGPUSHONLY",
     "SIG_PUSHONLY",
     "2-of-2 with two identical keys and sigs pushed using OP_DUP"
 ],
 [
     "0x47 0x304402204b26ae3298e583956aed912c1e6a32b94efc4cf3a97495d83f7a6edd64f8c11702204d0b112f3ebbffe8a0626deb57f62f33432fae8dc1a3de1658464bbb12f8260c01 NOP8 0x23 0x2103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640ac",
     "HASH160 0x14 0x215640c2f72f0d16b4eced26762035a42ffed39a EQUAL",
     "",
     "OK",
     "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY"
 ],
 [
     "0x47 0x3044022032d4a3dec9cad54c94b5585fb058f7e41ac5173843b0c2e7197a40421ee4ab54022041d4d4296d8c2821bb39f6349f0140bc2c95f16496df9fcd894758673d1db7d801 NOP8",
     "0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 CHECKSIG",
     "",
     "OK",
     "P2PK with non-push scriptSig but with P2SH validation"
 ],
 [
     "0x47 0x304402204b26ae3298e583956aed912c1e6a32b94efc4cf3a97495d83f7a6edd64f8c11702204d0b112f3ebbffe8a0626deb57f62f33432fae8dc1a3de1658464bbb12f8260c01 NOP8 0x23 0x2103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640ac",
     "HASH160 0x14 0x215640c2f72f0d16b4eced26762035a42ffed39a EQUAL",
     "P2SH",
     "SIG_PUSHONLY",
     "P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY"
 ],
 [
     "0x47 0x304402204b26ae3298e583956aed912c1e6a32b94efc4cf3a97495d83f7a6edd64f8c11702204d0b112f3ebbffe8a0626deb57f62f33432fae8dc1a3de1658464bbb12f8260c01 NOP8 0x23 0x2103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640ac",
     "HASH160 0x14 0x215640c2f72f0d16b4eced26762035a42ffed39a EQUAL",
     "SIGPUSHONLY",
     "SIG_PUSHONLY",
     "P2SH(P2PK) with non-push scriptSig but not P2SH"
 ],
 [
     "0 0x47 0x3044022044b11d5a64bebbd4280c616146bc961eed3081300eef527fbe8da91f6775892a022045b044719bf5c7100617cd518fff22c102f93e6768ed986543668be43bc44d1601 0x47 0x3044022044b11d5a64bebbd4280c616146bc961eed3081300eef527fbe8da91f6775892a022045b044719bf5c7100617cd518fff22c102f93e6768ed986543668be43bc44d1601",
     "2 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 2 CHECKMULTISIG",
     "SIGPUSHONLY",
     "OK",
     "2-of-2 with two identical keys and sigs pushed"
 ],
 [
     "11 0x47 0x3044022022127048516d473153d1f74e46e828496776752e3255f672f760a41e83f54e6f0220502956b739ed82aad916dc4a73e1fd55d02aad514b5211f1ba7d0dadf53c637901",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "P2SH",
     "OK",
     "P2PK with unnecessary input but no CLEANSTACK"
 ],
 [
     "11 0x47 0x3044022022127048516d473153d1f74e46e828496776752e3255f672f760a41e83f54e6f0220502956b739ed82aad916dc4a73e1fd55d02aad514b5211f1ba7d0dadf53c637901",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "P2PK with unnecessary input"
 ],
 [
     "11 0x47 0x3044022065066ad31463bd8ebb9cb7ef621e9c96fa3411a3ed393a3e41120a7ea688babf02206869ac4e007f853c1a15bca2670eabeb9a54cac1bddf5c4f73c03f8c17cbffa701 0x43 0x410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac",
     "HASH160 0x14 0x31edc23bdafda4639e669f89ad6b2318dd79d032 EQUAL",
     "P2SH",
     "OK",
     "P2SH with unnecessary input but no CLEANSTACK"
 ],
 [
     "11 0x47 0x3044022065066ad31463bd8ebb9cb7ef621e9c96fa3411a3ed393a3e41120a7ea688babf02206869ac4e007f853c1a15bca2670eabeb9a54cac1bddf5c4f73c03f8c17cbffa701 0x43 0x410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac",
     "HASH160 0x14 0x31edc23bdafda4639e669f89ad6b2318dd79d032 EQUAL",
     "CLEANSTACK,P2SH",
     "CLEANSTACK",
     "P2SH with unnecessary input"
 ],
 [
     "0x47 0x3044022065066ad31463bd8ebb9cb7ef621e9c96fa3411a3ed393a3e41120a7ea688babf02206869ac4e007f853c1a15bca2670eabeb9a54cac1bddf5c4f73c03f8c17cbffa701 0x43 0x410479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8ac",
     "HASH160 0x14 0x31edc23bdafda4639e669f89ad6b2318dd79d032 EQUAL",
     "CLEANSTACK,P2SH",
     "OK",
     "P2SH with CLEANSTACK"
 ],
 [
     [
         123450.00000000
     ],
     "0x47 0x304402206e3afa6dd4d1db87538fa48a0ef3f824d7ec554103fe5fb3527254d78bd79617022066097e981df0d1ce3c07224a73585ca1f5e8ebdf79639b2cc73c20bde066075141",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "SIGHASH_FORKID",
     "OK",
     "P2PK FORKID"
 ],
 [
     [
         123450.00000000
     ],
     "0x47 0x3044022054e19540c81ccb214b62acda158faf01440d98adab2e13ed43a4d35cc551bfff02205b05fc09882819b3fdbe56adfef63243d7faa5c4837db0c72ad9356eae9a5b8c41",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "SIGHASH_FORKID",
     "EVAL_FALSE",
     "P2PK INVALID AMOUNT"
 ],
 [
     [
         123450.00000000
     ],
     "0x47 0x304402206e3afa6dd4d1db87538fa48a0ef3f824d7ec554103fe5fb3527254d78bd79617022066097e981df0d1ce3c07224a73585ca1f5e8ebdf79639b2cc73c20bde066075141",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "STRICTENC",
     "ILLEGAL_FORKID",
     "P2PK INVALID FORKID"
 ],
 [
     [
         123450.00000000
     ],
     "0x47 0x304402205ce75e7249823fe2cc78f861579189f8e10585008aa057d4e6d755bfca1c8c6802200f63547feabc3f198f18742e84d57d6ca4bdd477d10a121554647cba36742f2b41",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "REPLAY_PROTECTION,SIGHASH_FORKID",
     "OK",
     "P2PK REPLAY PROTECTED"
 ],
 [
     [
         123450.00000000
     ],
     "0x47 0x304402206e3afa6dd4d1db87538fa48a0ef3f824d7ec554103fe5fb3527254d78bd79617022066097e981df0d1ce3c07224a73585ca1f5e8ebdf79639b2cc73c20bde066075141",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "REPLAY_PROTECTION,SIGHASH_FORKID",
     "EVAL_FALSE",
     "P2PK REPLAY PROTECTED"
 ],
 [
     "0x46 0x3044022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022037964f01a61db1b24ea44137b3d67d7095ec25f68bd7b508e01441e5539d96a9 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
     "NULLFAIL,STRICTENC",
     "OK",
     "Standard CHECKDATASIG"
 ],
 [
     "0x46 0x3044022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022037964f01a61db1b24ea44137b3d67d7095ec25f68bd7b508e01441e5539d96a9 1",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG NOT",
     "NULLFAIL,STRICTENC",
     "NULLFAIL",
     "CHECKDATASIG with NULLFAIL flags"
 ],
 [
     "0x46 0x3044022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022037964f01a61db1b24ea44137b3d67d7095ec25f68bd7b508e01441e5539d96a9 1",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG NOT",
     "STRICTENC",
     "OK",
     "CHECKDATASIG without NULLFAIL flags"
 ],
 [
     "0 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG NOT",
     "NULLFAIL,STRICTENC",
     "OK",
     "CHECKDATASIG empty signature"
 ],
 [
     "0x47 0x3045022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022100c869b0fe59e24e4db15bbec84c29828e24c2b6f02370eb32dfbe1ca77c98aa98 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
     "NULLFAIL,STRICTENC",
     "OK",
     "CHECKDATASIG with High S but no Low S"
 ],
 [
     "0x47 0x3045022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022100c869b0fe59e24e4db15bbec84c29828e24c2b6f02370eb32dfbe1ca77c98aa98 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
     "LOW_S,NULLFAIL,STRICTENC",
     "SIG_HIGH_S",
     "CHECKDATASIG with High S"
 ],
 [
     "0x46 0x3044022093cbfaab2bbef6fc019d1286018fd11e2612d817756d40913b3f82a428f1e90a022045d010bd0f3c31aa470d096bb3f693275214f48d4e727f45a9e0adb2645d7489 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
     "NULLFAIL",
     "OK",
     "CHECKDATASIG with too little R padding but no DERSIG"
 ],
 [
     "0x46 0x3044022093cbfaab2bbef6fc019d1286018fd11e2612d817756d40913b3f82a428f1e90a022045d010bd0f3c31aa470d096bb3f693275214f48d4e727f45a9e0adb2645d7489 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIG",
     "NULLFAIL,STRICTENC",
     "SIG_DER",
     "CHECKDATASIG with too little R padding"
 ],
 [
     "0x46 0x304402205ffea7d9fa4e0ce8058c96edfb721aaf2840912080ac4ae86a92d9462e69fde302203567149cb9c8c343523a87d7a64be304983899d2e2c6f267a7136c48ff21908d 0",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIG",
     "NULLFAIL",
     "OK",
     "CHECKDATASIG with hybrid pubkey but no STRICTENC"
 ],
 [
     "0x46 0x304402205ffea7d9fa4e0ce8058c96edfb721aaf2840912080ac4ae86a92d9462e69fde302203567149cb9c8c343523a87d7a64be304983899d2e2c6f267a7136c48ff21908d 0",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIG",
     "NULLFAIL,STRICTENC",
     "PUBKEYTYPE",
     "CHECKDATASIG with hybrid pubkey"
 ],
 [
     "0x46 0x304402205ffea7d9fa4e0de8058c96edfb721aaf2840912080ac4ae86a92d9462e69fde302203567149cb9c8c343523a87d7a64be304983899d2e2c6f267a7136c48ff21908d 0",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIG NOT",
     "",
     "OK",
     "CHECKDATASIG with invalid hybrid pubkey but no STRICTENC"
 ],
 [
     "0x46 0x304402205ffea7d9fa4e0de8058c96edfb721aaf2840912080ac4ae86a92d9462e69fde302203567149cb9c8c343523a87d7a64be304983899d2e2c6f267a7136c48ff21908d 0",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIG",
     "NULLFAIL,STRICTENC",
     "PUBKEYTYPE",
     "CHECKDATASIG with invalid hybrid pubkey"
 ],
 [
     "0x46 0x3044022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022037964f01a61db1b24ea44137b3d67d7095ec25f68bd7b508e01441e5539d96a9 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
     "NULLFAIL,STRICTENC",
     "OK",
     "Standard CHECKDATASIGVERIFY"
 ],
 [
     "0x46 0x3044022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022037964f01a61db1b24ea44137b3d67d7095ec25f68bd7b508e01441e5539d96a9 1",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
     "NULLFAIL,STRICTENC",
     "NULLFAIL",
     "CHECKDATASIGVERIFY with NULLFAIL flags"
 ],
 [
     "0x46 0x3044022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022037964f01a61db1b24ea44137b3d67d7095ec25f68bd7b508e01441e5539d96a9 1",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
     "STRICTENC",
     "CHECKDATASIGVERIFY",
     "CHECKDATASIGVERIFY without NULLFAIL flags"
 ],
 [
     "0 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
     "NULLFAIL,STRICTENC",
     "CHECKDATASIGVERIFY",
     "CHECKDATASIGVERIFY empty signature"
 ],
 [
     "0x47 0x3045022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022100c869b0fe59e24e4db15bbec84c29828e24c2b6f02370eb32dfbe1ca77c98aa98 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
     "NULLFAIL,STRICTENC",
     "OK",
     "CHECKDATASIG with High S but no Low S"
 ],
 [
     "0x47 0x3045022021309a532a60d471cc4ef025a96572c7bf26c4640b53c7d45e411a5aa99980f6022100c869b0fe59e24e4db15bbec84c29828e24c2b6f02370eb32dfbe1ca77c98aa98 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
     "LOW_S,NULLFAIL,STRICTENC",
     "SIG_HIGH_S",
     "CHECKDATASIG with High S"
 ],
 [
     "0x46 0x3044022093cbfaab2bbef6fc019d1286018fd11e2612d817756d40913b3f82a428f1e90a022045d010bd0f3c31aa470d096bb3f693275214f48d4e727f45a9e0adb2645d7489 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
     "NULLFAIL",
     "OK",
     "CHECKDATASIGVERIFY with too little R padding but no DERSIG"
 ],
 [
     "0x46 0x3044022093cbfaab2bbef6fc019d1286018fd11e2612d817756d40913b3f82a428f1e90a022045d010bd0f3c31aa470d096bb3f693275214f48d4e727f45a9e0adb2645d7489 0",
     "0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 CHECKDATASIGVERIFY 1",
     "NULLFAIL,STRICTENC",
     "SIG_DER",
     "CHECKDATASIGVERIFY with too little R padding"
 ],
 [
     "0x46 0x304402205ffea7d9fa4e0ce8058c96edfb721aaf2840912080ac4ae86a92d9462e69fde302203567149cb9c8c343523a87d7a64be304983899d2e2c6f267a7136c48ff21908d 0",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIGVERIFY 1",
     "NULLFAIL",
     "OK",
     "CHECKDATASIGVERIFY with hybrid pubkey but no STRICTENC"
 ],
 [
     "0x46 0x304402205ffea7d9fa4e0ce8058c96edfb721aaf2840912080ac4ae86a92d9462e69fde302203567149cb9c8c343523a87d7a64be304983899d2e2c6f267a7136c48ff21908d 0",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIGVERIFY 1",
     "NULLFAIL,STRICTENC",
     "PUBKEYTYPE",
     "CHECKDATASIGVERIFY with hybrid pubkey"
 ],
 [
     "0x46 0x304402205ffea7d9fa4e0de8058c96edfb721aaf2840912080ac4ae86a92d9462e69fde302203567149cb9c8c343523a87d7a64be304983899d2e2c6f267a7136c48ff21908d 0",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIGVERIFY 1",
     "",
     "CHECKDATASIGVERIFY",
     "CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC"
 ],
 [
     "0x46 0x304402205ffea7d9fa4e0de8058c96edfb721aaf2840912080ac4ae86a92d9462e69fde302203567149cb9c8c343523a87d7a64be304983899d2e2c6f267a7136c48ff21908d 0",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIGVERIFY 1",
     "NULLFAIL,STRICTENC",
     "PUBKEYTYPE",
     "CHECKDATASIGVERIFY with invalid hybrid pubkey"
 ],
 [
     "0x41 0x0df4be7f5fe74b2855b92082720e889038e15d8d747334fa3f300ef4ab1db1eea56aa83d1d60809ff6703791736be87cfb6cbc5c4036aeed3b4ea4e6dab3509001",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "",
     "OK",
     "CHECKSIG Schnorr"
 ],
 [
     "0x41 0x0df4be7f5fe74b2855b92082720e889038e15d8d747334fa3f300ef4ab1db1eea56aa83d1d60809ff6703791736be87cfb6cbc5c4036aeed3b4ea4e6dab3509001",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "STRICTENC",
     "OK",
     "CHECKSIG Schnorr w/ STRICTENC"
 ],
 [
     "0x41 0x3cf1b3f60b74d0821039f7dc7c21abe3119b9d94ae13f5e5258a8269bee9dfc51c84dbb3ba3eff82de61046f6cfef22ea5cf4a46e3776a5fb35d743aea310f6701",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "STRICTENC",
     "OK",
     "CHECKSIG Schnorr other key"
 ],
 [
     "0x41 0x35b32856cbd89eb40130a50c6931ce002e3e9db033179ab6265a276a04795ec8f87e9b4d8343f399915371d7f4a7d4d0c97753f2473b253197695a58eede92de01",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG NOT",
     "STRICTENC",
     "OK",
     "CHECKSIG Schnorr mismatched key"
 ],
 [
     "0x41 0x8d37e95e36718d7fbc8ffd63b0b4ebb89dd5fb683510a95345869399f810a8724a00e5cbbb2190205ffabac601d80bf110a67013521b7a7c02b2a51e07d723eb01",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIGVERIFY 1",
     "",
     "OK",
     "CHECKSIGVERIFY Schnorr"
 ],
 [
     "0x41 0x8d37e95e36718d7fbc8ffd63b0b4ebb89dd5fb683510a95345869399f810a8724a00e5cbbb2190205ffabac601d80bf110a67013521b7a7c02b2a51e07d723eb01",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIGVERIFY 1",
     "STRICTENC",
     "OK",
     "CHECKSIGVERIFY Schnorr w/ STRICTENC"
 ],
 [
     "0x41 0x53c4de3cb6a0190073c98fa415f63b720ea491748c9a760d5d249bb05f13990aa464be04b625cc36cd9e302dc276ad232d5d65d6327bdb18b7c529300d67013f01",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIGVERIFY 1",
     "STRICTENC",
     "OK",
     "CHECKSIGVERIFY Schnorr other key"
 ],
 [
     "0x41 0x74c51dae216d8ebee5418204cf90839ea9a288b93eccb1de54b5b5d06bcd69c7028e1b3c6643c001403e7862bee6be39c107e5c8d0a9a8e9143862e5d73c555a01",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIGVERIFY 1",
     "STRICTENC",
     "CHECKSIGVERIFY",
     "CHECKSIGVERIFY Schnorr mismatched key"
 ],
 [
     "0x40 0x9db0671f61f1fafa84aaab76ad2e070b27cf9ae85338bafc0b947ac9ad8c56ff7b24aa76c95ad86bb13cbff314742dbe1f545869d1a28efa54b411ccd37717e5",
     "0 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIG",
     "",
     "OK",
     "CHECKDATASIG Schnorr"
 ],
 [
     "0x40 0x9db0671f61f1fafa84aaab76ad2e070b27cf9ae85338bafc0b947ac9ad8c56ff7b24aa76c95ad86bb13cbff314742dbe1f545869d1a28efa54b411ccd37717e5",
     "0 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIG",
     "STRICTENC",
     "OK",
     "CHECKDATASIG Schnorr w/ STRICTENC"
 ],
 [
     "0x40 0x65c4bceda6ebb49e692180387e72c84be500f3431daac85d08d5d6c527e296f5b8a5b868a681f76aee309ad05e152b4f190732b3e7c46ef788b68c6035f6eab0",
     "0 0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKDATASIG",
     "STRICTENC",
     "OK",
     "CHECKDATASIG Schnorr other key"
 ],
 [
     "0x40 0x65c4bceda6ebb49e692180387e72c84be500f3431daac85d08d5d6c527e296f5b8a5b868a681f76aee309ad05e152b4f190732b3e7c46ef788b68c6035f6eab0",
     "0 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIG NOT",
     "STRICTENC",
     "OK",
     "CHECKDATASIG Schnorr mismatched key"
 ],
 [
     "0x40 0xe20d68eea1c55d8c23310ef33b4c68e3d876b1c5a36595f4dcc9d728894c957879e53bb4aebf8b3aa36861d89266ff864d2c3f513ab6f79c9d226ad45fbf5407",
     "1 0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKDATASIG",
     "STRICTENC",
     "OK",
     "CHECKDATASIG Schnorr other message"
 ],
 [
     "0x40 0xe20d68eea1c55d8c23310ef33b4c68e3d876b1c5a36595f4dcc9d728894c957879e53bb4aebf8b3aa36861d89266ff864d2c3f513ab6f79c9d226ad45fbf5407",
     "0 0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKDATASIG NOT",
     "STRICTENC",
     "OK",
     "CHECKDATASIG Schnorr wrong message"
 ],
 [
     "0x40 0x9db0671f61f1fafa84aaab76ad2e070b27cf9ae85338bafc0b947ac9ad8c56ff7b24aa76c95ad86bb13cbff314742dbe1f545869d1a28efa54b411ccd37717e5",
     "0 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIGVERIFY 1",
     "",
     "OK",
     "CHECKDATASIGVERIFY Schnorr"
 ],
 [
     "0x40 0x9db0671f61f1fafa84aaab76ad2e070b27cf9ae85338bafc0b947ac9ad8c56ff7b24aa76c95ad86bb13cbff314742dbe1f545869d1a28efa54b411ccd37717e5",
     "0 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIGVERIFY 1",
     "STRICTENC",
     "OK",
     "CHECKDATASIGVERIFY Schnorr w/ STRICTENC"
 ],
 [
     "0x40 0x65c4bceda6ebb49e692180387e72c84be500f3431daac85d08d5d6c527e296f5b8a5b868a681f76aee309ad05e152b4f190732b3e7c46ef788b68c6035f6eab0",
     "0 0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKDATASIGVERIFY 1",
     "STRICTENC",
     "OK",
     "CHECKDATASIGVERIFY Schnorr other key"
 ],
 [
     "0x40 0x65c4bceda6ebb49e692180387e72c84be500f3431daac85d08d5d6c527e296f5b8a5b868a681f76aee309ad05e152b4f190732b3e7c46ef788b68c6035f6eab0",
     "0 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKDATASIGVERIFY 1",
     "STRICTENC",
     "CHECKDATASIGVERIFY",
     "CHECKDATASIGVERIFY Schnorr mismatched key"
 ],
 [
     "0x40 0xe20d68eea1c55d8c23310ef33b4c68e3d876b1c5a36595f4dcc9d728894c957879e53bb4aebf8b3aa36861d89266ff864d2c3f513ab6f79c9d226ad45fbf5407",
     "1 0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKDATASIGVERIFY 1",
     "STRICTENC",
     "OK",
     "CHECKDATASIGVERIFY Schnorr other message"
 ],
 [
     "0x40 0xe20d68eea1c55d8c23310ef33b4c68e3d876b1c5a36595f4dcc9d728894c957879e53bb4aebf8b3aa36861d89266ff864d2c3f513ab6f79c9d226ad45fbf5407",
     "0 0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKDATASIGVERIFY 1",
     "STRICTENC",
     "CHECKDATASIGVERIFY",
     "CHECKDATASIGVERIFY Schnorr wrong message"
 ],
 [
     "0 0x41 0x105e4fed395e64ca013ac1ce020ef69b9990a577fe4b74648faafb69e499f76dd53d5c64aa866924361dd3aadde9b7184bbcb4f79520396c9ed17c4d8489a59701",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIG",
     "",
     "SIG_BADLENGTH",
     "CHECKMULTISIG Schnorr w/ no STRICTENC"
 ],
 [
     "0 0x41 0x105e4fed395e64ca013ac1ce020ef69b9990a577fe4b74648faafb69e499f76dd53d5c64aa866924361dd3aadde9b7184bbcb4f79520396c9ed17c4d8489a59701",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIG",
     "STRICTENC",
     "SIG_BADLENGTH",
     "CHECKMULTISIG Schnorr w/ STRICTENC"
 ],
 [
     "0 0x41 0x833682d4f60cc916a22a2c263e658fa662c49badb1e2a8c6208987bf99b1abd740498371480069e7a7a6e7471bf78c27bd9a1fd04fb212a92017346250ac187b01 0x41 0xea4a8d20562a950f4695dc24804565482e9fa111704886179d0c348f2b8a15fe691a305cd599c59c131677146661d5b98cb935330989a85f33afc70d0a21add101 0x41 0xce9011d76a4df05d6280b2382b4d91490dbec7c3e72dc826be1fc9b4718f627955190745cac96521ea46d6d324c7376461e225310e6cd605b9f266d170769b7901",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "",
     "SIG_BADLENGTH",
     "Schnorr 3-of-3"
 ],
 [
     "0 0x47 0x304402204d69d5caa4dbab259f79fce89d3b459bbd91697c1c052a1554ff3b08b2241cbd0220330a8e17a90d51996e363cb8902fce6278c6350fa59ae12832db2f6a44d64dce01 0x47 0x3044022031a1e5289b0d9c33ec182a7f67210b9997187c710f7d3f0f28bdfb618c4e025c02205d95fe63ee83a20ec44159a06f7c0b43b61d5f0c346ca4a2cc7b91878ad1a85001 0x41 0xce9011d76a4df05d6280b2382b4d91490dbec7c3e72dc826be1fc9b4718f627955190745cac96521ea46d6d324c7376461e225310e6cd605b9f266d170769b7901",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "",
     "SIG_BADLENGTH",
     "Schnorr-ECDSA-mixed 3-of-3"
 ],
 [
     "0 0x41 0x17fa4dd3e62694cc7816d32b73d5646ea768072aea4926a09e159e5f57be8fd6523800b259fe2a12e27aa29a3719f19e9e4b99d7f8e465a6f19454f914ccb3ec01",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIGVERIFY 1",
     "",
     "SIG_BADLENGTH",
     "CHECKMULTISIGVERIFY Schnorr w/ no STRICTENC"
 ],
 [
     "0 0x41 0x17fa4dd3e62694cc7816d32b73d5646ea768072aea4926a09e159e5f57be8fd6523800b259fe2a12e27aa29a3719f19e9e4b99d7f8e465a6f19454f914ccb3ec01",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIGVERIFY 1",
     "STRICTENC",
     "SIG_BADLENGTH",
     "CHECKMULTISIGVERIFY Schnorr w/ STRICTENC"
 ],
 [
     "0x41 0x6f1b69791cd7284b5510daef44cd5acd5c1f3d61f6a79705e18f106b46122f1ed8c5965f3c92c90943f9b51f57207e9e5b7fc462571281e2c92377e4ef20ab2b01",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG NOT",
     "",
     "OK",
     "Schnorr P2PK, bad sig"
 ],
 [
     "0x41 0x6f1b69791cd7284b5510daef44cd5acd5c1f3d61f6a79705e18f106b46122f1ed8c5965f3c92c90943f9b51f57207e9e5b7fc462571281e2c92377e4ef20ab2b01",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG NOT",
     "STRICTENC",
     "OK",
     "Schnorr P2PK, bad sig STRICTENC"
 ],
 [
     "0x41 0x6f1b69791cd7284b5510daef44cd5acd5c1f3d61f6a79705e18f106b46122f1ed8c5965f3c92c90943f9b51f57207e9e5b7fc462571281e2c92377e4ef20ab2b01",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG NOT",
     "NULLFAIL",
     "NULLFAIL",
     "Schnorr P2PK, bad sig NULLFAIL"
 ],
 [
     "0x41 0x4463c103b21e76713571365c4c09224c2a1b343b3cf02e3b56f4f0890a6e7ff96d0bfa2ffa22f8067db3414cc1789abfc48638cb4bc7463907042975f4c84ece01 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508",
     "DUP HASH160 0x14 0x1018853670f9f3b0582c5b9ee8ce93764ac32b93 EQUALVERIFY CHECKSIG",
     "",
     "OK",
     "Schnorr P2PKH"
 ],
 [
     "0x41 0xd78d543b601bc93b394b5c669933d16d860dc7480383efcaae9521d6ceb4065ba17c02a6d9289efef762fa7a0482eff9c5bce4dd95f8bea421ee70bdd8d5488d01",
     "0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 CHECKSIG",
     "STRICTENC",
     "OK",
     "Schnorr P2PK with compressed pubkey"
 ],
 [
     "0x41 0x0df4be7f5fe74b2855b92082720e889038e15d8d747334fa3f300ef4ab1db1eea56aa83d1d60809ff6703791736be87cfb6cbc5c4036aeed3b4ea4e6dab3509001",
     "0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "STRICTENC",
     "OK",
     "Schnorr P2PK with uncompressed pubkey"
 ],
 [
     "0x41 0xd211631fdebf4c8376b3d169ef65a1987460eda43c3312e561b0226fa3069f68a68bac0dbf780f77dd60ff602c66186f1da2bb0a31f10187796242f48295ddbe01",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "STRICTENC",
     "PUBKEYTYPE",
     "Schnorr P2PK with hybrid pubkey"
 ],
 [
     "0x41 0xd211631fdebf4c8376b3d169ef65a1987460eda43c3312e561b0226fa3069f68a68bac0dbf780f77dd60ff602c66186f1da2bb0a31f10187796242f48295ddbe01",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG",
     "",
     "OK",
     "Schnorr P2PK with hybrid pubkey but no STRICTENC"
 ],
 [
     "0x41 0x078b6b4e7d0689f3a1ef9b5283039c39b7ab3a26c04143017ee7136edbc1ccbcf47173c92c5823b778e4aaba3bf9ef2e988eb54c4cb709dbfa8e62110843c19901",
     "0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 CHECKSIG NOT",
     "",
     "OK",
     "Schnorr P2PK NOT with damaged hybrid pubkey but no STRICTENC"
 ],
 [
     "0x41 0xa522c6aab80595e0fdaf473c89a32e97978858809949fafd6f851254daae231f45338fe53187f79d8507f08c08f8bd2ee795e6ccaca0a04c4e40c613395a685b05",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "STRICTENC",
     "SIG_HASHTYPE",
     "Schnorr P2PK with undefined basehashtype and STRICTENC"
 ],
 [
     "0x41 0x128f02ec5b36057a7f3793c5ffdef9e6cca0ea3200a2f07e5c7189a267daafc4feb2b65a8c7f22b203557fef4c078e98382dc99939666b7c6dbcc62bd25b0bf821 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
     "DUP HASH160 0x14 0x91b24bf9f5288532960ac687abb035127b1d28a5 EQUALVERIFY CHECKSIG",
     "",
     "OK",
     "Schnorr P2PKH with invalid sighashtype but no STRICTENC"
 ],
 [
     "0x41 0x128f02ec5b36057a7f3793c5ffdef9e6cca0ea3200a2f07e5c7189a267daafc4feb2b65a8c7f22b203557fef4c078e98382dc99939666b7c6dbcc62bd25b0bf821 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8",
     "DUP HASH160 0x14 0x91b24bf9f5288532960ac687abb035127b1d28a5 EQUALVERIFY CHECKSIG",
     "STRICTENC",
     "SIG_HASHTYPE",
     "Schnorr P2PKH with invalid sighashtype and STRICTENC"
 ],
 [
     "0x41 0x3dae009b3fc84066b644b0508d1cc68fbbdefbb91b049aaa46e8de5c3b4598707d93df80a275022354f8e3e65ca6561c55d2f626c8395d237fb1f2b6b93e83f081",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "",
     "OK",
     "Schnorr P2PK anyonecanpay"
 ],
 [
     "0x41 0x3dae009b3fc84066b644b0508d1cc68fbbdefbb91b049aaa46e8de5c3b4598707d93df80a275022354f8e3e65ca6561c55d2f626c8395d237fb1f2b6b93e83f001",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "",
     "EVAL_FALSE",
     "Schnorr P2PK anyonecanpay marked with normal hashtype"
 ],
 [
     "0x41 0xd06f2e8e262a974d330c185acdd2eed99622f2c9cc0980eacf976f37965186dba2564a564e8c6697127d9729e6cedd44060ab7ece5c2f0ded2ad3f9a7308c7ce41",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "SIGHASH_FORKID,STRICTENC",
     "OK",
     "Schnorr P2PK with forkID"
 ],
 [
     "0x41 0x3cf1b3f60b74d0821039f7dc7c21abe3119b9d94ae13f5e5258a8269bee9dfc51c84dbb3ba3eff82de61046f6cfef22ea5cf4a46e3776a5fb35d743aea310f6701",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "SIGHASH_FORKID,STRICTENC",
     "MISSING_FORKID",
     "Schnorr P2PK with non-forkID sig"
 ],
 [
     "0x41 0x3cf1b3f60b74d0821039f7dc7c21abe3119b9d94ae13f5e5258a8269bee9dfc51c84dbb3ba3eff82de61046f6cfef22ea5cf4a46e3776a5fb35d743aea310f6741",
     "0x41 0x048282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f5150811f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf CHECKSIG",
     "SIGHASH_FORKID,STRICTENC",
     "EVAL_FALSE",
     "Schnorr P2PK with cheater forkID bit"
 ],
 [
     "0x09 0x300602010702010701 0x21 0x03a7bcb86f12d0635c850b6f0c945e4b4fcb400092a74b8d7e83275eb562d9fbb6",
     "CHECKSIG",
     "STRICTENC",
     "OK",
     "recovered-pubkey CHECKSIG 7,7 (wrapped r)"
 ],
 [
     "0x40 0x303d021d776879206d757374207765207375666665722077697468206563647361021c2121212121212121212121212121212121212121212121212121212101 0x21 0x02da78d331f65fd308ed7afbc80d48c908a83050276cb9bdc1fa414bfea4511570",
     "CHECKSIG",
     "STRICTENC",
     "OK",
     "recovered-pubkey CHECKSIG with 63-byte DER"
 ],
 [
     "0x41 0x303e021d776879206d757374207765207375666665722077697468206563647361021d212121212121212121212121212121212121212121212121212121212101 0x21 0x03f5d556a48a11a677f1a8eb0771f6cd11b1bcf378478c586d54f18634521b833e",
     "CHECKSIG",
     "STRICTENC",
     "EVAL_FALSE",
     "recovered-pubkey CHECKSIG with 64-byte DER"
 ],
 [
     "0x42 0x303f021d776879206d757374207765207375666665722077697468206563647361021e21212121212121212121212121212121212121212121212121212121212101 0x21 0x02224d851056412fbe03d1e2e8ec9030f5ee99c7b403e9743f261625eb8dd22922",
     "CHECKSIG",
     "STRICTENC",
     "OK",
     "recovered-pubkey CHECKSIG with 65-byte DER"
 ],
 [
     "0 0x41 0x303e021d776879206d757374207765207375666665722077697468206563647361021d212121212121212121212121212121212121212121212121212121212101 0x21 0x036cd1f91735dda2d984cfbc17ab0e9e7d754d7e4e1fceb691751cdd5c26b0aecc",
     "1 SWAP 1 CHECKMULTISIG",
     "STRICTENC",
     "SIG_BADLENGTH",
     "recovered-pubkey CHECKMULTISIG with 64-byte DER"
 ],
 [
     "0 0x47 0x30440220379db2a13c8c679bda7f500c93bae36e0d75c96b8af1754316a9c80e843f2923022046ee947cd3b916ab78f95be6ae29cc2f037ddb47f8e59c966b1e6813b270648001",
     "1 0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 2 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "1-of-2 with unchecked hybrid pubkey with SCHNORR_MULTISIG"
 ],
 [
     "0 0x47 0x304402202d4dd56f6dee2eccc049a4ebd65e77e4325aa3f2940130412b9f96fd28fa8c5a022074963950dd250d2fc943e60c7a4133cc8b1fcc46253e9b19f71c9723d1d894ef01",
     "1 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x41 0x0679be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 2 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "PUBKEYTYPE",
     "1-of-2 with checked hybrid pubkey with SCHNORR_MULTISIG"
 ],
 [
     "0 0x41 0x105e4fed395e64ca013ac1ce020ef69b9990a577fe4b74648faafb69e499f76dd53d5c64aa866924361dd3aadde9b7184bbcb4f79520396c9ed17c4d8489a59701",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG",
     "SIG_BADLENGTH",
     "Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG but no STRICTENC"
 ],
 [
     "0 0x41 0x105e4fed395e64ca013ac1ce020ef69b9990a577fe4b74648faafb69e499f76dd53d5c64aa866924361dd3aadde9b7184bbcb4f79520396c9ed17c4d8489a59701",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "SIG_BADLENGTH",
     "Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG"
 ],
 [
     "0 0x41 0x833682d4f60cc916a22a2c263e658fa662c49badb1e2a8c6208987bf99b1abd740498371480069e7a7a6e7471bf78c27bd9a1fd04fb212a92017346250ac187b01 0x41 0xea4a8d20562a950f4695dc24804565482e9fa111704886179d0c348f2b8a15fe691a305cd599c59c131677146661d5b98cb935330989a85f33afc70d0a21add101 0x41 0xce9011d76a4df05d6280b2382b4d91490dbec7c3e72dc826be1fc9b4718f627955190745cac96521ea46d6d324c7376461e225310e6cd605b9f266d170769b7901",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "SIG_BADLENGTH",
     "Legacy 3-of-3 Schnorr w/ SCHNORR_MULTISIG"
 ],
 [
     "0 0x47 0x304402204d69d5caa4dbab259f79fce89d3b459bbd91697c1c052a1554ff3b08b2241cbd0220330a8e17a90d51996e363cb8902fce6278c6350fa59ae12832db2f6a44d64dce01 0x47 0x3044022031a1e5289b0d9c33ec182a7f67210b9997187c710f7d3f0f28bdfb618c4e025c02205d95fe63ee83a20ec44159a06f7c0b43b61d5f0c346ca4a2cc7b91878ad1a85001 0x41 0xce9011d76a4df05d6280b2382b4d91490dbec7c3e72dc826be1fc9b4718f627955190745cac96521ea46d6d324c7376461e225310e6cd605b9f266d170769b7901",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "SIG_BADLENGTH",
     "Legacy 3-of-3 mixed Schnorr-ECDSA w/ SCHNORR_MULTISIG"
 ],
 [
     "0 0x41 0x303e021d776879206d757374207765207375666665722077697468206563647361021d212121212121212121212121212121212121212121212121212121212101 0x21 0x036cd1f91735dda2d984cfbc17ab0e9e7d754d7e4e1fceb691751cdd5c26b0aecc",
     "1 SWAP 1 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "SIG_BADLENGTH",
     "recovered-pubkey CHECKMULTISIG with 64-byte DER w/ SCHNORR_MULTISIG"
 ],
 [
     "0 0 0",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG NOT",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 2-of-3 w/ SCHNORR_MULTISIG (return-false still valid via legacy mode)"
 ],
 [
     "0",
     "0 0 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 0-of-0 w/ SCHNORR_MULTISIG"
 ],
 [
     "0",
     "0 0x02 0xbeef 1 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 0-of-1 w/ SCHNORR_MULTISIG, null dummy"
 ],
 [
     "1 0x41 0x105e4fed395e64ca013ac1ce020ef69b9990a577fe4b74648faafb69e499f76dd53d5c64aa866924361dd3aadde9b7184bbcb4f79520396c9ed17c4d8489a59701",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 1-of-1 Schnorr"
 ],
 [
     "0x02 0x0100 0x41 0x105e4fed395e64ca013ac1ce020ef69b9990a577fe4b74648faafb69e499f76dd53d5c64aa866924361dd3aadde9b7184bbcb4f79520396c9ed17c4d8489a59701",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "BITFIELD_SIZE",
     "CHECKMULTISIG 1-of-1 Schnorr, nonminimal bits"
 ],
 [
     "7 0x41 0x833682d4f60cc916a22a2c263e658fa662c49badb1e2a8c6208987bf99b1abd740498371480069e7a7a6e7471bf78c27bd9a1fd04fb212a92017346250ac187b01 0x41 0xea4a8d20562a950f4695dc24804565482e9fa111704886179d0c348f2b8a15fe691a305cd599c59c131677146661d5b98cb935330989a85f33afc70d0a21add101 0x41 0xce9011d76a4df05d6280b2382b4d91490dbec7c3e72dc826be1fc9b4718f627955190745cac96521ea46d6d324c7376461e225310e6cd605b9f266d170769b7901",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 3-of-3 Schnorr"
 ],
 [
     "15 0x41 0x6d1d1f8db2b4e43a51b4f5f16367045f9c1832b8103ce2bab3a21afc223351a685e84bca02c863110e7ad22d4735cd31e1908e741530e3a07863292c3ff21df901 0x41 0x6d1d1f8db2b4e43a51b4f5f16367045f9c1832b8103ce2bab3a21afc223351a685e84bca02c863110e7ad22d4735cd31e1908e741530e3a07863292c3ff21df901 0x41 0x98ac816c0adb14db2a593f6402bf70e347a219fba0ccad805a5e37a67e265c800b1d493440965634fe740852fbe4164ec45a722a463099ae8a9872896da972ef01 0x41 0xe62867a73ae91b390f6ae11717d360fbc7e813a6dc3917040556834350d5b3cfb464e7222a716f37a32ba3fee353ad4957aa3f47cf7ea1285873bc9a0e64759801",
     "4 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "SIG_COUNT",
     "CHECKMULTISIG 4-of-3 Schnorr"
 ],
 [
     "6 0x41 0x4829a4df8042001ba6a3ee6ec1e9c26de662aade55a49f8d018acff0bac0df2edd881cf21f2a1aa651b6f703f0cde22fedaa9b8bc3451101bcac37bcb89dcc8001 0x41 0xa3fac6b1aa2cc8bb222ee379711c243b26a164ced7f2e2f4a0e184a3e53352bfaee598c6446861e5a7e819871b7ce948f5562ecf214c19dfa5112c19d74adc7101",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 2-of-3 (110) Schnorr"
 ],
 [
     "5 0x41 0xb8c744ebecfa75ef478b2b8852795d93b99640e5c05421ef6f651d4044be6cf2db2c61d0b5395e685731556c87e501433fb6e6a3b44c113d0ba19df8fd01c18101 0x41 0xa3fac6b1aa2cc8bb222ee379711c243b26a164ced7f2e2f4a0e184a3e53352bfaee598c6446861e5a7e819871b7ce948f5562ecf214c19dfa5112c19d74adc7101",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 2-of-3 (101) Schnorr"
 ],
 [
     "3 0x41 0xb8c744ebecfa75ef478b2b8852795d93b99640e5c05421ef6f651d4044be6cf2db2c61d0b5395e685731556c87e501433fb6e6a3b44c113d0ba19df8fd01c18101 0x41 0x4829a4df8042001ba6a3ee6ec1e9c26de662aade55a49f8d018acff0bac0df2edd881cf21f2a1aa651b6f703f0cde22fedaa9b8bc3451101bcac37bcb89dcc8001",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 2-of-3 (011) Schnorr"
 ],
 [
     "3 0x41 0xb8c744ebecfa75ef478b2b8852795d93b99640e5c05421ef6f651d4044be6cf2db2c61d0b5395e685731556c87e501433fb6e6a3b44c113d0ba19df8fd01c18101 0x41 0xa3fac6b1aa2cc8bb222ee379711c243b26a164ced7f2e2f4a0e184a3e53352bfaee598c6446861e5a7e819871b7ce948f5562ecf214c19dfa5112c19d74adc7101",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "NULLFAIL",
     "CHECKMULTISIG 2-of-3 Schnorr, mismatched bits Schnorr"
 ],
 [
     "7 0x41 0x4829a4df8042001ba6a3ee6ec1e9c26de662aade55a49f8d018acff0bac0df2edd881cf21f2a1aa651b6f703f0cde22fedaa9b8bc3451101bcac37bcb89dcc8001 0x41 0xa3fac6b1aa2cc8bb222ee379711c243b26a164ced7f2e2f4a0e184a3e53352bfaee598c6446861e5a7e819871b7ce948f5562ecf214c19dfa5112c19d74adc7101",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "INVALID_BIT_COUNT",
     "CHECKMULTISIG 2-of-3 Schnorr, all bits set"
 ],
 [
     "14 0x41 0xb8c744ebecfa75ef478b2b8852795d93b99640e5c05421ef6f651d4044be6cf2db2c61d0b5395e685731556c87e501433fb6e6a3b44c113d0ba19df8fd01c18101 0x41 0x4829a4df8042001ba6a3ee6ec1e9c26de662aade55a49f8d018acff0bac0df2edd881cf21f2a1aa651b6f703f0cde22fedaa9b8bc3451101bcac37bcb89dcc8001",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "BIT_RANGE",
     "CHECKMULTISIG 2-of-3 Schnorr, extra high bit set"
 ],
 [
     "10 0x41 0xb8c744ebecfa75ef478b2b8852795d93b99640e5c05421ef6f651d4044be6cf2db2c61d0b5395e685731556c87e501433fb6e6a3b44c113d0ba19df8fd01c18101 0x41 0x4829a4df8042001ba6a3ee6ec1e9c26de662aade55a49f8d018acff0bac0df2edd881cf21f2a1aa651b6f703f0cde22fedaa9b8bc3451101bcac37bcb89dcc8001",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "BIT_RANGE",
     "CHECKMULTISIG 2-of-3 Schnorr, too high bit set"
 ],
 [
     "2 0x41 0xb8c744ebecfa75ef478b2b8852795d93b99640e5c05421ef6f651d4044be6cf2db2c61d0b5395e685731556c87e501433fb6e6a3b44c113d0ba19df8fd01c18101 0x41 0x4829a4df8042001ba6a3ee6ec1e9c26de662aade55a49f8d018acff0bac0df2edd881cf21f2a1aa651b6f703f0cde22fedaa9b8bc3451101bcac37bcb89dcc8001",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "INVALID_BIT_COUNT",
     "CHECKMULTISIG 2-of-3 Schnorr, too few bits set"
 ],
 [
     "0x01 0x00 0 0",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "INVALID_BIT_COUNT",
     "CHECKMULTISIG 2-of-3 Schnorr, with no bits set (attempt to malleate return-false)"
 ],
 [
     "0 0x41 0xb8c744ebecfa75ef478b2b8852795d93b99640e5c05421ef6f651d4044be6cf2db2c61d0b5395e685731556c87e501433fb6e6a3b44c113d0ba19df8fd01c18101 0x41 0x4829a4df8042001ba6a3ee6ec1e9c26de662aade55a49f8d018acff0bac0df2edd881cf21f2a1aa651b6f703f0cde22fedaa9b8bc3451101bcac37bcb89dcc8001",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "SIG_BADLENGTH",
     "CHECKMULTISIG null dummy with schnorr sigs (with SCHNORR_MULTISIG on)"
 ],
 [
     "3 0x41 0x4829a4df8042001ba6a3ee6ec1e9c26de662aade55a49f8d018acff0bac0df2edd881cf21f2a1aa651b6f703f0cde22fedaa9b8bc3451101bcac37bcb89dcc8001 0x41 0xb8c744ebecfa75ef478b2b8852795d93b99640e5c05421ef6f651d4044be6cf2db2c61d0b5395e685731556c87e501433fb6e6a3b44c113d0ba19df8fd01c18101",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "NULLFAIL",
     "CHECKMULTISIG 2-of-3 Schnorr, misordered signatures"
 ],
 [
     "-1 0x41 0x34b9918c9cd9aa3ad0f642f1dd435164e7bed979e539b2890b8d465b70db47385c514a21b1c6659ab40b8e5395ceae8f6c67c6f4c24e940cbe0a6fe496e7d15e01 0x41 0x057e3e62dbcf8a1bd3526271ad63f568bdae4d248bd87dfcf4a80b9f6da28e0994e04c670a56e624301141f53efc9a40f7d503171809e3f70d5aee203a90567d01",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 DUP 2DUP 2DUP 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 8 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 2-of-8 Schnorr, right way to represent 0b10000001"
 ],
 [
     "0x02 0x8100 0x41 0x34b9918c9cd9aa3ad0f642f1dd435164e7bed979e539b2890b8d465b70db47385c514a21b1c6659ab40b8e5395ceae8f6c67c6f4c24e940cbe0a6fe496e7d15e01 0x41 0x057e3e62dbcf8a1bd3526271ad63f568bdae4d248bd87dfcf4a80b9f6da28e0994e04c670a56e624301141f53efc9a40f7d503171809e3f70d5aee203a90567d01",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 DUP 2DUP 2DUP 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 8 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "BITFIELD_SIZE",
     "CHECKMULTISIG 2-of-8 Schnorr, wrong way to represent 0b10000001"
 ],
 [
     "0x01 0x20 0x41 0xa07b665bb4c5385afb0b0369ee675c5e890c9b9b63962aea5d9fcaeb0fc427e1c13b76baff5bedcf90f61070b3c62b976ffeaf4c6701ee37ae764a1e171b8afc01",
     "1 -1 -1 -1 -1 -1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 -1 7 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 1-of-7 Schnorr, second-to-last key"
 ],
 [
     "0x02 0x0004 0x41 0x9d831f1ffb45eb4578098e9df80374e4c9172aa99fe3d7bb226feafa5ba280ed2e02834aeef31ee91d12e84afb2701ae6f88821be008741b2c689a779ff3276101",
     "1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 -1 -1 13 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 1-of-13 Schnorr, third-to-last key"
 ],
 [
     "0x03 0xffff0f 0x41 0x5f4f7ffff1fa44347dbc148d51fe661b60fbc44b5abe22a04d97ecfb891bdb2568eb91aa38a426dfd7b82e0b45b57af6f3e56143fabc850ebfdfcf6a0d03c4b001 0x41 0x28add881f6fa489a9016f066022ed80acecbafc351a6d17025cf87bf2b0d9b09f6d001f5df2b1be0d1909a8fe9280b59b5a8cb6d1e37425e733ff3267ce1e1b401 0x41 0x9f66f20bca4a64fc3cc170c3e1ef2bcb62f86b719b2f8e7154407e9210fde99164d754f787bf65020dc7db3838c8aae3591eaf465f45433fcb3d0a94bea4090401",
     "OVER DUP DUP 2DUP 3DUP 3DUP 3DUP 3DUP 0x01 0x14 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 OVER DUP DUP 2DUP 3DUP 3DUP 3DUP 3DUP 0x01 0x14 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 20-of-20 Schnorr"
 ],
 [
     "0x03 0x000010 0x41 0x5f4f7ffff1fa44347dbc148d51fe661b60fbc44b5abe22a04d97ecfb891bdb2568eb91aa38a426dfd7b82e0b45b57af6f3e56143fabc850ebfdfcf6a0d03c4b001 0x41 0x28add881f6fa489a9016f066022ed80acecbafc351a6d17025cf87bf2b0d9b09f6d001f5df2b1be0d1909a8fe9280b59b5a8cb6d1e37425e733ff3267ce1e1b401 0x41 0x9f66f20bca4a64fc3cc170c3e1ef2bcb62f86b719b2f8e7154407e9210fde99164d754f787bf65020dc7db3838c8aae3591eaf465f45433fcb3d0a94bea4090401",
     "OVER DUP DUP 2DUP 3DUP 3DUP 3DUP 3DUP 0x01 0x14 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 OVER DUP DUP 2DUP 3DUP 3DUP 3DUP 3DUP 0x01 0x14 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "BIT_RANGE",
     "CHECKMULTISIG 20-of-20 Schnorr, checkbits +1"
 ],
 [
     "0x03 0x000010 0x41 0xbe6635b93b92ff98d0d929d3537bf2941bbc33b9b4adc14d928e1b6eae1aa1fd23455e4094764f70dd896f47b3279b57965ecad1b4d32c1000be27be8cf83ece01",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 DUP 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 3DUP 3DUP 3DUP 3DUP 3DUP 3DUP 0x01 0x15 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "PUBKEY_COUNT",
     "CHECKMULTISIG 1-of-21 Schnorr"
 ],
 [
     "0x03 0x010000 0x41 0x020fb4d03e4c7ea6e17f5a7d03c74a6cc33fd7f949d6bc5eb8f6122a4fa5a9bc208adafc7a92030fea664f044cccfd473b8ebaae94cd7bdeec8346a02ac0e3df01",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 DUP 2DUP 3DUP 3DUP 3DUP 3DUP 3DUP 0x01 0x14 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 1-of-20 Schnorr, first key"
 ],
 [
     "0x03 0x000001 0x41 0x020fb4d03e4c7ea6e17f5a7d03c74a6cc33fd7f949d6bc5eb8f6122a4fa5a9bc208adafc7a92030fea664f044cccfd473b8ebaae94cd7bdeec8346a02ac0e3df01",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 DUP 2DUP 3DUP 3DUP 3DUP 3DUP 3DUP 0x01 0x14 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "NULLFAIL",
     "CHECKMULTISIG 1-of-20 Schnorr, first key, wrong endianness"
 ],
 [
     "1 0x41 0xf92f753aa4238dfce5e2c68a5bb9f04c4a457c775ef247a2fda9318d2b6ab086cf7d116a24f38a045d179ff59d84c872e9fc2ef0f7574306c22380cd18da411301",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 2DUP 2DUP 3DUP 3DUP 3DUP 3DUP 3DUP 0x01 0x14 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "BITFIELD_SIZE",
     "CHECKMULTISIG 1-of-20 Schnorr, truncating zeros not allowed"
 ],
 [
     "0x03 0x000008 0x41 0xdbcb269b86b9b0abb01fdf0a38b3ba9852150188bb2255e4a0794ecbbdcba52a6577ca08e0dd89b9543cae1bcf152e5444ee70759bc58a553a4c1e41144fc27001",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 DUP 2DUP 3DUP 3DUP 3DUP 3DUP 3DUP 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x01 0x14 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 1-of-20 Schnorr, last key"
 ],
 [
     "0x03 0x080000 0x41 0xdbcb269b86b9b0abb01fdf0a38b3ba9852150188bb2255e4a0794ecbbdcba52a6577ca08e0dd89b9543cae1bcf152e5444ee70759bc58a553a4c1e41144fc27001",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 DUP 2DUP 3DUP 3DUP 3DUP 3DUP 3DUP 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x01 0x14 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "NULLFAIL",
     "CHECKMULTISIG 1-of-20 Schnorr, last key, wrong endianness"
 ],
 [
     "0x02 0x0800 0x41 0xdbcb269b86b9b0abb01fdf0a38b3ba9852150188bb2255e4a0794ecbbdcba52a6577ca08e0dd89b9543cae1bcf152e5444ee70759bc58a553a4c1e41144fc27001",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 DUP 2DUP 3DUP 3DUP 3DUP 3DUP 3DUP 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x01 0x14 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "BITFIELD_SIZE",
     "CHECKMULTISIG 1-of-20 Schnorr, last key, truncating zeros not allowed"
 ],
 [
     "6 0x41 0x3dfd744897afdad123edf671b9f7ad99f884cf714ada36f4c1cba12f7bdc71c6369832821a91964eb7d05552f1e32e5506d6dc2262e3ca5d1238690e3ddb075401 0x41 0x84aa5be4ebc905d6390a5be1b0101a0f2aab9563603a52c864db5deb459266cf1ea4376d378aa69a907a4e255919ecbff044d21b76dd004d34266c7ad8b84af501",
     "2 0x02 0xbeef 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 2-of-3 (110) Schnorr, first key garbage"
 ],
 [
     "3 0x41 0xb7aa94db79ecf22bdfd4d986ac4ba294fc044dd75696a6f95b12fef2dee48e02e06ccda571e0d513a03c585f86a8df1223a02556c11d7f1da71ba10544e9bc9501 0x41 0x3dfd744897afdad123edf671b9f7ad99f884cf714ada36f4c1cba12f7bdc71c6369832821a91964eb7d05552f1e32e5506d6dc2262e3ca5d1238690e3ddb075401",
     "2 0x02 0xbeef 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "PUBKEYTYPE",
     "CHECKMULTISIG 2-of-3 (011) Schnorr, first key garbage"
 ],
 [
     "3 0x41 0xc09a62bbf5b7e45503a682cc72559b4d060edf1144023b47e765375a8e0cb017da3b0b72e2912a772989ce922f7f298890e66ff9f36c813b872682fc6b95a04b01 0x41 0x7e57eab163176c372e6f2baa2446998817b429d9cd8e3ee3a6841a95bf19fa128562848b590bf2ada480a23bbb6697f3e920594e7bf410b3b8af489862ee660601",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x02 0xbeef 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 2-of-3 (011) Schnorr, last key garbage"
 ],
 [
     "6 0x41 0x7e57eab163176c372e6f2baa2446998817b429d9cd8e3ee3a6841a95bf19fa128562848b590bf2ada480a23bbb6697f3e920594e7bf410b3b8af489862ee660601 0x41 0x64b53fe45bc169d53366fe20f7340596ba9ad86566ae725535e32c5a40d4d3dbd448bc898d0528395eca1c634e4ce422c856c6063cb947d8191127317da4a5a001",
     "2 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x02 0xbeef 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "PUBKEYTYPE",
     "CHECKMULTISIG 2-of-3 (110) Schnorr, last key garbage"
 ],
 [
     "0x01 0x00",
     "0 0 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "BITFIELD_SIZE",
     "CHECKMULTISIG 0-of-0 with SCHNORR_MULTISIG, dummy must be null"
 ],
 [
     "0x01 0x00",
     "0 0x02 0xbeef 1 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "CHECKMULTISIG 0-of-1 with SCHNORR_MULTISIG, dummy need not be null"
 ],
 [
     "1 0x41 0x17fa4dd3e62694cc7816d32b73d5646ea768072aea4926a09e159e5f57be8fd6523800b259fe2a12e27aa29a3719f19e9e4b99d7f8e465a6f19454f914ccb3ec01",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIGVERIFY 1",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "OP_CHECKMULTISIGVERIFY Schnorr"
 ],
 [
     "1 0x47 0x304402204d0106d6babcaca95277692eaa566bdc89d9f44b1106c18423345c7e9ac40d79022033a3750421038d15f15101ffdca1147a0eb980bb1b809280cb5368c50c10c42c01",
     "1 0x41 0x0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 1 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "SIG_NONSCHNORR",
     "CHECKMULTISIG 1-of-1 ECDSA signature in Schnorr mode"
 ],
 [
     "7 0x47 0x304402204d69d5caa4dbab259f79fce89d3b459bbd91697c1c052a1554ff3b08b2241cbd0220330a8e17a90d51996e363cb8902fce6278c6350fa59ae12832db2f6a44d64dce01 0x41 0xea4a8d20562a950f4695dc24804565482e9fa111704886179d0c348f2b8a15fe691a305cd599c59c131677146661d5b98cb935330989a85f33afc70d0a21add101 0x41 0xce9011d76a4df05d6280b2382b4d91490dbec7c3e72dc826be1fc9b4718f627955190745cac96521ea46d6d324c7376461e225310e6cd605b9f266d170769b7901",
     "3 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "MINIMALDATA,NULLFAIL,SCHNORR_MULTISIG,STRICTENC",
     "SIG_NONSCHNORR",
     "CHECKMULTISIG 3-of-3 Schnorr with mixed-in ECDSA signature"
 ],
 [
     "0 0x47 0x3044022031feb7bc6e213668042b34749aa7aa99a4b40dc8ba53f872fb270442a2e69ecf0220012df792d5bc247a4ebe12f4de300d70aa768f5d9f49a5db752aef86e23f1bd501",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 3 CHECKMULTISIG",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "SigChecks on bare CHECKMULTISIG 1-of-3 ECDSA"
 ],
 [
     "0x03 0x010000 0x41 0x071da33a41ccc6ff5fcb275cae36e953e6a6092af5c8d256ca640387d36c42ae25117b502bae0881437ad0ff7db7ab23afba59fbcb03563471941733e67fb1ac01",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 0x01 0x14 CHECKMULTISIG",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "SigChecks on bare CHECKMULTISIG 1-of-20 Schnorr"
 ],
 [
     "0x41 0xd78d543b601bc93b394b5c669933d16d860dc7480383efcaae9521d6ceb4065ba17c02a6d9289efef762fa7a0482eff9c5bce4dd95f8bea421ee70bdd8d5488d01",
     "0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 CHECKSIG",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "SigChecks on P2PK Schnorr"
 ],
 [
     "0x47 0x30440220355bca231b5c6eac1c304ece6391404a5e8c9683f1c20749736e56f35969954302205d4af886536352ddf065407828763f3fc41755c34fd08afa4934505fd75e14ed01",
     "0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 CHECKSIG",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "SigChecks on P2PK ECDSA"
 ],
 [
     "0 0x47 0x3044022007a5b776fff5a7540301e9abbe29198575ce549333b47c90e2949c08d4ecaf8002203f8d71618b7a5cd3e99eeba0fb3c4cad4115e550ea27563d65074899d074a2d301 0x4d0102 0x51210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f8179821038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff46405fae",
     "HASH160 0x14 0xf12c94c5293b608240ce28dc992a3ee1110926c1 EQUAL",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "SigChecks on P2SH CHECKMULTISIG 1-of-15 ECDSA with compressed keys"
 ],
 [
     "0x44 0x210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f817980078ac78ac78ac78ac78ac78ac78ac78ac78ac78ac78ac78ac78ac78ac78ac78ac75",
     "HASH160 0x14 0xe35559f8e010a9efb62973594c029ddc6f52b031 EQUAL",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "Null signatures make no SigChecks (CHECKSIG)"
 ],
 [
     "0x47 0x00210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798000070ba70ba70ba70ba70ba70ba70ba70ba70ba70ba70ba70ba70ba70ba70ba70ba6d77",
     "HASH160 0x14 0x0c01c2ac37ed03194c339b0f9915ae6acd0afeba EQUAL",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "Null signatures make no SigChecks (CHECKDATASIG)"
 ],
 [
     "0 0 0x32 0x766e6f6f6f6f60210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798766e6f6f6f6f60ae91",
     "HASH160 0x14 0x653b2bb5171f68633c8e3437d075e23640fdf4d1 EQUAL",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "Null signatures make no SigChecks (CHECKMULTISIG)"
 ],
 [
     "0 0x47 0x304402200c90f014caff5716cd50749d52c5a4b5f1d6b79c67c96f71713f6fa3e84f3a8a02203ab681add2f4f908c41f083c982d24b62871e6c4f6eaa5d677572fc7c43c5e2201",
     "1 0x21 0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 0x21 0x038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508 0x21 0x03363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640 DUP 4 CHECKMULTISIG",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "INPUT_SIGCHECKS",
     "SigChecks on bare CHECKMULTISIG 1-of-4 ECDSA"
 ],
 [
     "0 0x47 0x30440220418df29b58de691affb63165b3276a3932e80d56eb3392114b438f4f61fc9d2902207270492c16a9c56be78f6d926448038de44dd0de7d4ecea61f04f590be8c321401 0x4de001 0x514f210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f817982103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff46405fae",
     "HASH160 0x14 0x5493830eb1862c448c66236c694e2b3b37d8fd60 EQUAL",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "INPUT_SIGCHECKS",
     "SigChecks on P2SH CHECKMULTISIG 1-of-15 ECDSA with a runt key"
 ],
 [
     "0x02 0x0200 0x41 0xc33a73f6c920c95d79d4abf75a3471daac41cfb76a40a40eac752e0c522d1ce7be10d486c52aad12b1a1802f78f860d20dc6be065bebb672e641d17edc7ea7d501 0x4de001 0x514f210279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f817982103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff464021038282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f515082103363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff46405fae",
     "HASH160 0x14 0x5493830eb1862c448c66236c694e2b3b37d8fd60 EQUAL",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "SigChecks on P2SH CHECKMULTISIG 1-of-15 Schnorr with a runt key"
 ],
 [
     "0 0x0d 0x004f4f4f4f4f4f4f4f4f4f5aae",
     "HASH160 0x14 0xa3ef8a4b54cc4437e684c5072535acbbf1f29598 EQUAL",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "Very short P2SH multisig 0-of-10, spent with legacy mode (0 sigchecks)"
 ],
 [
     "0x02 0x0000 0x0d 0x004f4f4f4f4f4f4f4f4f4f5aae",
     "HASH160 0x14 0xa3ef8a4b54cc4437e684c5072535acbbf1f29598 EQUAL",
     "INPUT_SIGCHECKS,MINIMALDATA,NULLFAIL,P2SH,SCHNORR_MULTISIG,STRICTENC",
     "OK",
     "Very short P2SH multisig 0-of-10, spent with schnorr mode (0 sigchecks)"
 ],
 
 ["CHECKSEQUENCEVERIFY tests"],
 ["", "CHECKSEQUENCEVERIFY", "CHECKSEQUENCEVERIFY", "INVALID_STACK_OPERATION", "CSV automatically fails on an empty stack"],
 ["-1", "CHECKSEQUENCEVERIFY", "CHECKSEQUENCEVERIFY", "NEGATIVE_LOCKTIME", "CSV automatically fails if stack top is negative"],
 ["0x0100", "CHECKSEQUENCEVERIFY", "CHECKSEQUENCEVERIFY,MINIMALDATA", "UNKNOWN_ERROR", "CSV fails if stack top is not minimally encoded"],
 ["0", "CHECKSEQUENCEVERIFY", "CHECKSEQUENCEVERIFY", "UNSATISFIED_LOCKTIME", "CSV fails if stack top bit 1 << 31 is set and the tx version < 2"],
 ["4294967296", "CHECKSEQUENCEVERIFY", "CHECKSEQUENCEVERIFY", "UNSATISFIED_LOCKTIME",
   "CSV fails if stack top bit 1 << 31 is not set, and tx version < 2"],
 
 ["MINIMALIF tests"],
 ["MINIMALIF is not applied if the flag is passed"],
 ["1", "IF 1 ENDIF", "P2SH,MINIMALIF", "OK"],
 ["2", "IF 1 ENDIF", "P2SH", "OK"],
 ["2", "IF 1 ENDIF", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0x02 0x0100", "IF 1 ENDIF", "P2SH", "OK"],
 ["0x02 0x0100", "IF 1 ENDIF", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0", "IF 1 ENDIF", "P2SH,MINIMALIF", "EVAL_FALSE"],
 ["0x01 0x00", "IF 1 ENDIF", "P2SH", "EVAL_FALSE"],
 ["0x01 0x00", "IF 1 ENDIF", "P2SH,MINIMALIF", "MINIMALIF"],
 ["1", "NOTIF 1 ENDIF", "P2SH,MINIMALIF", "EVAL_FALSE"],
 ["2", "NOTIF 1 ENDIF", "P2SH", "EVAL_FALSE"],
 ["2", "NOTIF 1 ENDIF", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0x02 0x0100", "NOTIF 1 ENDIF", "P2SH", "EVAL_FALSE"],
 ["0x02 0x0100", "NOTIF 1 ENDIF", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0", "NOTIF 1 ENDIF", "P2SH,MINIMALIF", "OK"],
 ["0x01 0x00", "NOTIF 1 ENDIF", "P2SH", "OK"],
 ["0x01 0x00", "NOTIF 1 ENDIF", "P2SH,MINIMALIF", "MINIMALIF"],
 ["Normal P2SH IF 1 ENDIF"],
 ["1 0x03 0x635168", "HASH160 0x14 0xe7309652a8e3f600f06f5d8d52d6df03d2176cc3 EQUAL", "P2SH,MINIMALIF", "OK"],
 ["2 0x03 0x635168", "HASH160 0x14 0xe7309652a8e3f600f06f5d8d52d6df03d2176cc3 EQUAL", "P2SH", "OK"],
 ["2 0x03 0x635168", "HASH160 0x14 0xe7309652a8e3f600f06f5d8d52d6df03d2176cc3 EQUAL", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0x02 0x0100 0x03 0x635168", "HASH160 0x14 0xe7309652a8e3f600f06f5d8d52d6df03d2176cc3 EQUAL", "P2SH", "OK"],
 ["0x02 0x0100 0x03 0x635168", "HASH160 0x14 0xe7309652a8e3f600f06f5d8d52d6df03d2176cc3 EQUAL", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0 0x03 0x635168", "HASH160 0x14 0xe7309652a8e3f600f06f5d8d52d6df03d2176cc3 EQUAL", "P2SH,MINIMALIF", "EVAL_FALSE"],
 ["0x01 0x00 0x03 0x635168", "HASH160 0x14 0xe7309652a8e3f600f06f5d8d52d6df03d2176cc3 EQUAL", "P2SH", "EVAL_FALSE"],
 ["0x01 0x00 0x03 0x635168", "HASH160 0x14 0xe7309652a8e3f600f06f5d8d52d6df03d2176cc3 EQUAL", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0x03 0x635168", "HASH160 0x14 0xe7309652a8e3f600f06f5d8d52d6df03d2176cc3 EQUAL", "P2SH,MINIMALIF", "UNBALANCED_CONDITIONAL"],
 ["Normal P2SH NOTIF 1 ENDIF"],
 ["1 0x03 0x645168", "HASH160 0x14 0x0c3f8fe3d6ca266e76311ecda544c67d15fdd5b0 EQUAL", "P2SH,MINIMALIF", "EVAL_FALSE"],
 ["2 0x03 0x645168", "HASH160 0x14 0x0c3f8fe3d6ca266e76311ecda544c67d15fdd5b0 EQUAL", "P2SH", "EVAL_FALSE"],
 ["2 0x03 0x645168", "HASH160 0x14 0x0c3f8fe3d6ca266e76311ecda544c67d15fdd5b0 EQUAL", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0x02 0x0100 0x03 0x645168", "HASH160 0x14 0x0c3f8fe3d6ca266e76311ecda544c67d15fdd5b0 EQUAL", "P2SH", "EVAL_FALSE"],
 ["0x02 0x0100 0x03 0x645168", "HASH160 0x14 0x0c3f8fe3d6ca266e76311ecda544c67d15fdd5b0 EQUAL", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0 0x03 0x645168", "HASH160 0x14 0x0c3f8fe3d6ca266e76311ecda544c67d15fdd5b0 EQUAL", "P2SH,MINIMALIF", "OK"],
 ["0x01 0x00 0x03 0x645168", "HASH160 0x14 0x0c3f8fe3d6ca266e76311ecda544c67d15fdd5b0 EQUAL", "P2SH", "OK"],
 ["0x01 0x00 0x03 0x645168", "HASH160 0x14 0x0c3f8fe3d6ca266e76311ecda544c67d15fdd5b0 EQUAL", "P2SH,MINIMALIF", "MINIMALIF"],
 ["0x03 0x645168", "HASH160 0x14 0x0c3f8fe3d6ca266e76311ecda544c67d15fdd5b0 EQUAL", "P2SH,MINIMALIF", "UNBALANCED_CONDITIONAL"],
 
 ["NULLFAIL should cover all signatures and signatures only"],
 ["0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG", "OK", "BIP66 and NULLFAIL-compliant"],
 ["0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG,NULLFAIL", "OK", "BIP66 and NULLFAIL-compliant"],
 ["1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG,NULLFAIL", "OK", "BIP66 and NULLFAIL-compliant"],
 ["0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x09 0x300602010102010101", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG", "OK", "BIP66-compliant but not NULLFAIL-compliant"],
 ["0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0x09 0x300602010102010101", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG,NULLFAIL", "NULLFAIL", "BIP66-compliant but not NULLFAIL-compliant"],
 ["0 0x09 0x300602010102010101 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG", "OK", "BIP66-compliant but not NULLFAIL-compliant"],
 ["0 0x09 0x300602010102010101 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0", "0x01 0x14 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0x01 0x14 CHECKMULTISIG NOT", "DERSIG,NULLFAIL", "NULLFAIL", "BIP66-compliant but not NULLFAIL-compliant"],
 
 ["SIGHASH_FORKID"],
 ["0x09 0x300602010102010141", "0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 CHECKSIG NOT", "STRICTENC", "ILLEGAL_FORKID"],
 ["0x09 0x300602010102010141", "0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 CHECKSIG NOT", "SIGHASH_FORKID", "OK"],
 ["0 0x09 0x300602010102010141", "1 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 1 CHECKMULTISIG NOT", "STRICTENC", "ILLEGAL_FORKID"],
 ["0 0x09 0x300602010102010141", "1 0x21 0x02865c40293a680cb9c020e7b1e106d8c1916d3cef99aa431a56d253e69256dac0 1 CHECKMULTISIG NOT", "SIGHASH_FORKID", "OK"],
 
 ["The End"]
 ]
diff --git a/src/test/op_reversebytes_tests.cpp b/src/test/op_reversebytes_tests.cpp
index 7998fec595..d6f8c2ca34 100644
--- a/src/test/op_reversebytes_tests.cpp
+++ b/src/test/op_reversebytes_tests.cpp
@@ -1,189 +1,161 @@
 // Copyright (c) 2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <policy/policy.h>
 #include <script/interpreter.h>
 #include <script/script.h>
 
 #include <test/lcg.h>
 #include <test/setup_common.h>
 
 #include <boost/test/unit_test.hpp>
 
 typedef std::vector<uint8_t> valtype;
 typedef std::vector<valtype> stacktype;
 
 BOOST_FIXTURE_TEST_SUITE(op_reversebytes_tests, BasicTestingSetup)
 
 static void CheckErrorWithFlags(const uint32_t flags,
                                 const stacktype &original_stack,
                                 const CScript &script,
                                 const ScriptError expected) {
     BaseSignatureChecker sigchecker;
     ScriptError err = ScriptError::OK;
     stacktype stack{original_stack};
     bool r = EvalScript(stack, script, flags, sigchecker, &err);
     BOOST_CHECK(!r);
     BOOST_CHECK(err == expected);
 }
 
 static void CheckPassWithFlags(const uint32_t flags,
                                const stacktype &original_stack,
                                const CScript &script,
                                const stacktype &expected) {
     BaseSignatureChecker sigchecker;
     ScriptError err = ScriptError::OK;
     stacktype stack{original_stack};
     bool r = EvalScript(stack, script, flags, sigchecker, &err);
     BOOST_CHECK(r);
     BOOST_CHECK(err == ScriptError::OK);
     BOOST_CHECK(stack == expected);
 }
 
-/**
- * Verifies that the given error occurs with OP_REVERSEBYTES enabled
- * and that BAD_OPCODE occurs if disabled.
- */
-static void CheckErrorIfEnabled(const uint32_t flags,
-                                const stacktype &original_stack,
-                                const CScript &script,
-                                const ScriptError expected) {
-    CheckErrorWithFlags(flags | SCRIPT_ENABLE_OP_REVERSEBYTES, original_stack,
-                        script, expected);
-    CheckErrorWithFlags(flags & ~SCRIPT_ENABLE_OP_REVERSEBYTES, original_stack,
-                        script, ScriptError::BAD_OPCODE);
-}
-
-/**
- * Verifies that the given stack results with OP_REVERSEBYTES enabled
- * and that BAD_OPCODE occurs if disabled.
- */
-static void CheckPassIfEnabled(const uint32_t flags,
-                               const stacktype &original_stack,
-                               const CScript &script,
-                               const stacktype &expected) {
-    CheckPassWithFlags(flags | SCRIPT_ENABLE_OP_REVERSEBYTES, original_stack,
-                       script, expected);
-    CheckErrorWithFlags(flags & ~SCRIPT_ENABLE_OP_REVERSEBYTES, original_stack,
-                        script, ScriptError::BAD_OPCODE);
-}
-
 /**
  * Verifies the different combinations of a given test case.
  * Checks if
  * - <item> OP_REVERSEBYTES results in <reversed_item>,
  * - <reversed_item> OP_REVERSEBYTES results in <item>,
  * - <item> {OP_REVERSEBYTES} x 2 results in <item> and
  * - <reversed_item> {OP_REVERSEBYTES} x 2 results in <reversed_item>.
  */
 static void CheckPassForCombinations(const uint32_t flags, const valtype &item,
                                      const valtype &reversed_item) {
-    CheckPassIfEnabled(flags, {item}, CScript() << OP_REVERSEBYTES,
+    CheckPassWithFlags(flags, {item}, CScript() << OP_REVERSEBYTES,
                        {reversed_item});
-    CheckPassIfEnabled(flags, {reversed_item}, CScript() << OP_REVERSEBYTES,
+    CheckPassWithFlags(flags, {reversed_item}, CScript() << OP_REVERSEBYTES,
                        {item});
-    CheckPassIfEnabled(flags, {item},
+    CheckPassWithFlags(flags, {item},
                        CScript() << OP_REVERSEBYTES << OP_REVERSEBYTES, {item});
-    CheckPassIfEnabled(flags, {reversed_item},
+    CheckPassWithFlags(flags, {reversed_item},
                        CScript() << OP_REVERSEBYTES << OP_REVERSEBYTES,
                        {reversed_item});
 }
 
 // Test a few simple manual cases with random flags (proxy for exhaustive
 // testing).
 BOOST_AUTO_TEST_CASE(op_reversebytes_manual_random_flags) {
     MMIXLinearCongruentialGenerator lcg;
     for (size_t i = 0; i < 4096; i++) {
         uint32_t flags = lcg.next();
         CheckPassForCombinations(flags, {}, {});
         CheckPassForCombinations(flags, {99}, {99});
         CheckPassForCombinations(flags, {0xde, 0xad}, {0xad, 0xde});
         CheckPassForCombinations(flags, {0xde, 0xad, 0xa1}, {0xa1, 0xad, 0xde});
         CheckPassForCombinations(flags, {0xde, 0xad, 0xbe, 0xef},
                                  {0xef, 0xbe, 0xad, 0xde});
         CheckPassForCombinations(flags, {0x12, 0x34, 0x56}, {0x56, 0x34, 0x12});
     }
 }
 
 // Test byte strings 0..n (mod 256) with random flags.
 BOOST_AUTO_TEST_CASE(op_reversebytes_iota) {
     MMIXLinearCongruentialGenerator lcg;
     for (uint32_t datasize :
          {0, 1, 2, 10, 16, 32, 50, 128, 300, 400, 512, 519, 520}) {
         valtype iota_data;
         iota_data.reserve(datasize);
         for (size_t item = 0; item < datasize; ++item) {
             iota_data.emplace_back(item % 256);
         }
         valtype iota_data_reversed = {iota_data.rbegin(), iota_data.rend()};
         for (size_t i = 0; i < 4096; i++) {
             uint32_t flags = lcg.next();
             CheckPassForCombinations(flags, iota_data, iota_data_reversed);
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(op_reversebytes_random_and_palindrome) {
     MMIXLinearCongruentialGenerator lcg;
 
     // Prepare a couple of interesting script flags.
     std::vector<uint32_t> flaglist({
         SCRIPT_VERIFY_NONE,
         STANDARD_SCRIPT_VERIFY_FLAGS,
         MANDATORY_SCRIPT_VERIFY_FLAGS,
     });
     for (uint32_t flagindex = 0; flagindex < 32; ++flagindex) {
         uint32_t flags = 1 << flagindex;
         flaglist.push_back(flags);
     }
 
     // Test every possible stack item size.
     for (uint32_t datasize = 0; datasize < MAX_SCRIPT_ELEMENT_SIZE;
          ++datasize) {
         // Generate random data.
         valtype random_data;
         random_data.reserve(datasize);
         for (size_t item = 0; item < datasize; ++item) {
             random_data.emplace_back(lcg.next() % 256);
         }
         valtype random_data_reversed = {random_data.rbegin(),
                                         random_data.rend()};
 
         // Make a palindrome of the form 0..n..0.
         valtype palindrome;
         palindrome.reserve(datasize);
         for (size_t item = 0; item < datasize; ++item) {
             palindrome.emplace_back(
                 (item < (datasize + 1) / 2 ? item : datasize - item - 1) % 256);
         }
 
         for (const uint32_t flags : flaglist) {
             // Verify random data passes.
             CheckPassForCombinations(flags, random_data, random_data_reversed);
             // Verify palindrome check passes.
-            CheckPassIfEnabled(flags, {palindrome},
+            CheckPassWithFlags(flags, {palindrome},
                                CScript() << OP_REVERSEBYTES, {palindrome});
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(op_reversebytes_failures) {
     MMIXLinearCongruentialGenerator lcg;
     // Test for random flags (proxy for exhaustive testing).
     for (size_t i = 0; i < 4096; i++) {
         uint32_t flags = lcg.next();
 
         // Verify non-palindrome fails.
-        CheckErrorIfEnabled(flags, {{0x01, 0x02, 0x03, 0x02, 0x02}},
+        CheckErrorWithFlags(flags, {{0x01, 0x02, 0x03, 0x02, 0x02}},
                             CScript()
                                 << OP_DUP << OP_REVERSEBYTES << OP_EQUALVERIFY,
                             ScriptError::EQUALVERIFY);
 
         // Test empty stack results in INVALID_STACK_OPERATION.
-        CheckErrorIfEnabled(flags, {}, CScript() << OP_REVERSEBYTES,
+        CheckErrorWithFlags(flags, {}, CScript() << OP_REVERSEBYTES,
                             ScriptError::INVALID_STACK_OPERATION);
     }
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/script_tests.cpp b/src/test/script_tests.cpp
index fb878115c3..19c654cc29 100644
--- a/src/test/script_tests.cpp
+++ b/src/test/script_tests.cpp
@@ -1,3230 +1,3230 @@
 // Copyright (c) 2011-2019 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/sighashtype.h>
 #include <script/sign.h>
 
 #include <core_io.h>
 #include <key.h>
 #include <keystore.h>
 #include <rpc/util.h>
 #include <streams.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 
 #if defined(HAVE_CONSENSUS_LIB)
 #include <script/bitcoinconsensus.h>
 #endif
 
 #include <test/data/script_tests.json.h>
 #include <test/jsonutil.h>
 #include <test/lib/transaction_utils.h>
 #include <test/scriptflags.h>
 #include <test/setup_common.h>
 #include <test/sigutil.h>
 
 #include <boost/test/unit_test.hpp>
 
 #include <univalue.h>
 
 #include <cstdint>
 #include <string>
 #include <vector>
 
 // Uncomment if you want to output updated JSON tests.
 // #define UPDATE_JSON_TESTS
 
 static const uint32_t gFlags = SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC;
 
 struct ScriptErrorDesc {
     ScriptError err;
     const char *name;
 };
 
 static ScriptErrorDesc script_errors[] = {
     {ScriptError::OK, "OK"},
     {ScriptError::UNKNOWN, "UNKNOWN_ERROR"},
     {ScriptError::EVAL_FALSE, "EVAL_FALSE"},
     {ScriptError::OP_RETURN, "OP_RETURN"},
     {ScriptError::SCRIPT_SIZE, "SCRIPT_SIZE"},
     {ScriptError::PUSH_SIZE, "PUSH_SIZE"},
     {ScriptError::OP_COUNT, "OP_COUNT"},
     {ScriptError::STACK_SIZE, "STACK_SIZE"},
     {ScriptError::SIG_COUNT, "SIG_COUNT"},
     {ScriptError::PUBKEY_COUNT, "PUBKEY_COUNT"},
     {ScriptError::INPUT_SIGCHECKS, "INPUT_SIGCHECKS"},
     {ScriptError::INVALID_OPERAND_SIZE, "OPERAND_SIZE"},
     {ScriptError::INVALID_NUMBER_RANGE, "INVALID_NUMBER_RANGE"},
     {ScriptError::IMPOSSIBLE_ENCODING, "IMPOSSIBLE_ENCODING"},
     {ScriptError::INVALID_SPLIT_RANGE, "SPLIT_RANGE"},
     {ScriptError::INVALID_BIT_COUNT, "INVALID_BIT_COUNT"},
     {ScriptError::VERIFY, "VERIFY"},
     {ScriptError::EQUALVERIFY, "EQUALVERIFY"},
     {ScriptError::CHECKMULTISIGVERIFY, "CHECKMULTISIGVERIFY"},
     {ScriptError::CHECKSIGVERIFY, "CHECKSIGVERIFY"},
     {ScriptError::CHECKDATASIGVERIFY, "CHECKDATASIGVERIFY"},
     {ScriptError::NUMEQUALVERIFY, "NUMEQUALVERIFY"},
     {ScriptError::BAD_OPCODE, "BAD_OPCODE"},
     {ScriptError::DISABLED_OPCODE, "DISABLED_OPCODE"},
     {ScriptError::INVALID_STACK_OPERATION, "INVALID_STACK_OPERATION"},
     {ScriptError::INVALID_ALTSTACK_OPERATION, "INVALID_ALTSTACK_OPERATION"},
     {ScriptError::UNBALANCED_CONDITIONAL, "UNBALANCED_CONDITIONAL"},
     {ScriptError::NEGATIVE_LOCKTIME, "NEGATIVE_LOCKTIME"},
     {ScriptError::UNSATISFIED_LOCKTIME, "UNSATISFIED_LOCKTIME"},
     {ScriptError::SIG_HASHTYPE, "SIG_HASHTYPE"},
     {ScriptError::SIG_DER, "SIG_DER"},
     {ScriptError::MINIMALDATA, "MINIMALDATA"},
     {ScriptError::SIG_PUSHONLY, "SIG_PUSHONLY"},
     {ScriptError::SIG_HIGH_S, "SIG_HIGH_S"},
     {ScriptError::PUBKEYTYPE, "PUBKEYTYPE"},
     {ScriptError::CLEANSTACK, "CLEANSTACK"},
     {ScriptError::MINIMALIF, "MINIMALIF"},
     {ScriptError::SIG_NULLFAIL, "NULLFAIL"},
     {ScriptError::SIG_BADLENGTH, "SIG_BADLENGTH"},
     {ScriptError::SIG_NONSCHNORR, "SIG_NONSCHNORR"},
     {ScriptError::DISCOURAGE_UPGRADABLE_NOPS, "DISCOURAGE_UPGRADABLE_NOPS"},
     {ScriptError::ILLEGAL_FORKID, "ILLEGAL_FORKID"},
     {ScriptError::MUST_USE_FORKID, "MISSING_FORKID"},
     {ScriptError::DIV_BY_ZERO, "DIV_BY_ZERO"},
     {ScriptError::MOD_BY_ZERO, "MOD_BY_ZERO"},
     {ScriptError::INVALID_BITFIELD_SIZE, "BITFIELD_SIZE"},
     {ScriptError::INVALID_BIT_RANGE, "BIT_RANGE"},
 };
 
 static const char *FormatScriptError(ScriptError err) {
     for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) {
         if (script_errors[i].err == err) {
             return script_errors[i].name;
         }
     }
 
     BOOST_ERROR("Unknown scripterror enumeration value, update script_errors "
                 "in script_tests.cpp.");
     return "";
 }
 
 static ScriptError ParseScriptError(const std::string &name) {
     for (size_t i = 0; i < ARRAYLEN(script_errors); ++i) {
         if (script_errors[i].name == name) {
             return script_errors[i].err;
         }
     }
 
     BOOST_ERROR("Unknown scripterror \"" << name << "\" in test description");
     return ScriptError::UNKNOWN;
 }
 
 BOOST_FIXTURE_TEST_SUITE(script_tests, BasicTestingSetup)
 
 static void DoTest(const CScript &scriptPubKey, const CScript &scriptSig,
                    uint32_t flags, const std::string &message,
                    ScriptError scriptError, const Amount nValue) {
     bool expect = (scriptError == ScriptError::OK);
     if (flags & SCRIPT_VERIFY_CLEANSTACK) {
         flags |= SCRIPT_VERIFY_P2SH;
     }
 
     ScriptError err;
     const CTransaction txCredit{
         BuildCreditingTransaction(scriptPubKey, nValue)};
     CMutableTransaction tx = BuildSpendingTransaction(scriptSig, txCredit);
     CMutableTransaction tx2 = tx;
     BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey, flags,
                                      MutableTransactionSignatureChecker(
                                          &tx, 0, txCredit.vout[0].nValue),
                                      &err) == expect,
                         message);
     BOOST_CHECK_MESSAGE(err == scriptError,
                         std::string(FormatScriptError(err)) + " where " +
                             std::string(FormatScriptError(scriptError)) +
                             " expected: " + message);
 
     // Verify that removing flags from a passing test or adding flags to a
     // failing test does not change the result, except for some special flags.
     for (int i = 0; i < 16; ++i) {
         uint32_t extra_flags = InsecureRandBits(32);
         // Some flags are not purely-restrictive and thus we can't assume
         // anything about what happens when they are flipped. Keep them as-is.
         extra_flags &=
             ~(SCRIPT_ENABLE_SIGHASH_FORKID | SCRIPT_ENABLE_REPLAY_PROTECTION |
-              SCRIPT_ENABLE_SCHNORR_MULTISIG | SCRIPT_ENABLE_OP_REVERSEBYTES);
+              SCRIPT_ENABLE_SCHNORR_MULTISIG);
         uint32_t combined_flags =
             expect ? (flags & ~extra_flags) : (flags | extra_flags);
         // Weed out invalid flag combinations.
         if (combined_flags & SCRIPT_VERIFY_CLEANSTACK) {
             combined_flags |= SCRIPT_VERIFY_P2SH;
         }
 
         BOOST_CHECK_MESSAGE(VerifyScript(scriptSig, scriptPubKey,
                                          combined_flags,
                                          MutableTransactionSignatureChecker(
                                              &tx, 0, txCredit.vout[0].nValue),
                                          &err) == expect,
                             message + strprintf(" (with %s flags %08x)",
                                                 expect ? "removed" : "added",
                                                 combined_flags ^ flags));
     }
 
 #if defined(HAVE_CONSENSUS_LIB)
     CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
     stream << tx2;
     uint32_t libconsensus_flags =
         flags & bitcoinconsensus_SCRIPT_FLAGS_VERIFY_ALL;
     if (libconsensus_flags == flags) {
         if (flags & bitcoinconsensus_SCRIPT_ENABLE_SIGHASH_FORKID) {
             BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(
                                     scriptPubKey.data(), scriptPubKey.size(),
                                     txCredit.vout[0].nValue / SATOSHI,
                                     (const uint8_t *)&stream[0], stream.size(),
                                     0, libconsensus_flags, nullptr) == expect,
                                 message);
         } else {
             BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script_with_amount(
                                     scriptPubKey.data(), scriptPubKey.size(), 0,
                                     (const uint8_t *)&stream[0], stream.size(),
                                     0, libconsensus_flags, nullptr) == expect,
                                 message);
             BOOST_CHECK_MESSAGE(bitcoinconsensus_verify_script(
                                     scriptPubKey.data(), scriptPubKey.size(),
                                     (const uint8_t *)&stream[0], stream.size(),
                                     0, libconsensus_flags, nullptr) == expect,
                                 message);
         }
     }
 #endif
 }
 
 namespace {
 const uint8_t vchKey0[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
 const uint8_t vchKey1[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0};
 const uint8_t vchKey2[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                              0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0};
 
 struct KeyData {
     CKey key0, key0C, key1, key1C, key2, key2C;
     CPubKey pubkey0, pubkey0C, pubkey0H;
     CPubKey pubkey1, pubkey1C;
     CPubKey pubkey2, pubkey2C;
 
     KeyData() {
         key0.Set(vchKey0, vchKey0 + 32, false);
         key0C.Set(vchKey0, vchKey0 + 32, true);
         pubkey0 = key0.GetPubKey();
         pubkey0H = key0.GetPubKey();
         pubkey0C = key0C.GetPubKey();
         *const_cast<uint8_t *>(&pubkey0H[0]) = 0x06 | (pubkey0H[64] & 1);
 
         key1.Set(vchKey1, vchKey1 + 32, false);
         key1C.Set(vchKey1, vchKey1 + 32, true);
         pubkey1 = key1.GetPubKey();
         pubkey1C = key1C.GetPubKey();
 
         key2.Set(vchKey2, vchKey2 + 32, false);
         key2C.Set(vchKey2, vchKey2 + 32, true);
         pubkey2 = key2.GetPubKey();
         pubkey2C = key2C.GetPubKey();
     }
 };
 
 class TestBuilder {
 private:
     //! Actually executed script
     CScript script;
     //! The P2SH redeemscript
     CScript redeemscript;
     CTransactionRef creditTx;
     CMutableTransaction spendTx;
     bool havePush;
     std::vector<uint8_t> push;
     std::string comment;
     uint32_t flags;
     ScriptError scriptError;
     Amount nValue;
 
     void DoPush() {
         if (havePush) {
             spendTx.vin[0].scriptSig << push;
             havePush = false;
         }
     }
 
     void DoPush(const std::vector<uint8_t> &data) {
         DoPush();
         push = data;
         havePush = true;
     }
 
     std::vector<uint8_t> DoSignECDSA(const CKey &key, const uint256 &hash,
                                      unsigned int lenR = 32,
                                      unsigned int lenS = 32) const {
         std::vector<uint8_t> vchSig, r, s;
         uint32_t iter = 0;
         do {
             key.SignECDSA(hash, vchSig, false, iter++);
             if ((lenS == 33) != (vchSig[5 + vchSig[3]] == 33)) {
                 NegateSignatureS(vchSig);
             }
 
             r = std::vector<uint8_t>(vchSig.begin() + 4,
                                      vchSig.begin() + 4 + vchSig[3]);
             s = std::vector<uint8_t>(vchSig.begin() + 6 + vchSig[3],
                                      vchSig.begin() + 6 + vchSig[3] +
                                          vchSig[5 + vchSig[3]]);
         } while (lenR != r.size() || lenS != s.size());
 
         return vchSig;
     }
 
     std::vector<uint8_t> DoSignSchnorr(const CKey &key,
                                        const uint256 &hash) const {
         std::vector<uint8_t> vchSig;
 
         // no need to iterate for size; schnorrs are always same size.
         key.SignSchnorr(hash, vchSig);
 
         return vchSig;
     }
 
 public:
     TestBuilder(const CScript &script_, const std::string &comment_,
                 uint32_t flags_, bool P2SH = false,
                 Amount nValue_ = Amount::zero())
         : script(script_), havePush(false), comment(comment_), flags(flags_),
           scriptError(ScriptError::OK), nValue(nValue_) {
         CScript scriptPubKey = script;
         if (P2SH) {
             redeemscript = scriptPubKey;
             scriptPubKey = CScript()
                            << OP_HASH160
                            << ToByteVector(CScriptID(redeemscript)) << OP_EQUAL;
         }
         creditTx =
             MakeTransactionRef(BuildCreditingTransaction(scriptPubKey, nValue));
         spendTx = BuildSpendingTransaction(CScript(), *creditTx);
     }
 
     TestBuilder &SetScriptError(ScriptError err) {
         scriptError = err;
         return *this;
     }
 
     TestBuilder &Add(const CScript &_script) {
         DoPush();
         spendTx.vin[0].scriptSig += _script;
         return *this;
     }
 
     TestBuilder &Num(int num) {
         DoPush();
         spendTx.vin[0].scriptSig << num;
         return *this;
     }
 
     TestBuilder &Push(const std::string &hex) {
         DoPush(ParseHex(hex));
         return *this;
     }
 
     TestBuilder &Push(const uint256 &hash) {
         DoPush(ToByteVector(hash));
         return *this;
     }
 
     TestBuilder &Push(const CScript &_script) {
         DoPush(std::vector<uint8_t>(_script.begin(), _script.end()));
         return *this;
     }
 
     TestBuilder &
     PushSigECDSA(const CKey &key, SigHashType sigHashType = SigHashType(),
                  unsigned int lenR = 32, unsigned int lenS = 32,
                  Amount amount = Amount::zero(),
                  uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) {
         uint256 hash = SignatureHash(script, CTransaction(spendTx), 0,
                                      sigHashType, amount, nullptr, sigFlags);
         std::vector<uint8_t> vchSig = DoSignECDSA(key, hash, lenR, lenS);
         vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType()));
         DoPush(vchSig);
         return *this;
     }
 
     TestBuilder &
     PushSigSchnorr(const CKey &key, SigHashType sigHashType = SigHashType(),
                    Amount amount = Amount::zero(),
                    uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) {
         uint256 hash = SignatureHash(script, CTransaction(spendTx), 0,
                                      sigHashType, amount, nullptr, sigFlags);
         std::vector<uint8_t> vchSig = DoSignSchnorr(key, hash);
         vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType()));
         DoPush(vchSig);
         return *this;
     }
 
     TestBuilder &PushDataSigECDSA(const CKey &key,
                                   const std::vector<uint8_t> &data,
                                   unsigned int lenR = 32,
                                   unsigned int lenS = 32) {
         std::vector<uint8_t> vchHash(32);
         CSHA256().Write(data.data(), data.size()).Finalize(vchHash.data());
 
         DoPush(DoSignECDSA(key, uint256(vchHash), lenR, lenS));
         return *this;
     }
 
     TestBuilder &PushDataSigSchnorr(const CKey &key,
                                     const std::vector<uint8_t> &data) {
         std::vector<uint8_t> vchHash(32);
         CSHA256().Write(data.data(), data.size()).Finalize(vchHash.data());
 
         DoPush(DoSignSchnorr(key, uint256(vchHash)));
         return *this;
     }
 
     TestBuilder &PushECDSARecoveredPubKey(
         const std::vector<uint8_t> &rdata, const std::vector<uint8_t> &sdata,
         SigHashType sigHashType = SigHashType(), Amount amount = Amount::zero(),
         uint32_t sigFlags = SCRIPT_ENABLE_SIGHASH_FORKID) {
         // This calculates a pubkey to verify with a given ECDSA transaction
         // signature.
         uint256 hash = SignatureHash(script, CTransaction(spendTx), 0,
                                      sigHashType, amount, nullptr, sigFlags);
 
         assert(rdata.size() <= 32);
         assert(sdata.size() <= 32);
 
         // Our strategy: make a 'key recovery' signature, and just try all the
         // recovery IDs. If none of them work then this means the 'r' value
         // doesn't have any corresponding point, and the caller should pick a
         // different r.
         std::vector<uint8_t> vchSig(65, 0);
         std::copy(rdata.begin(), rdata.end(),
                   vchSig.begin() + (33 - rdata.size()));
         std::copy(sdata.begin(), sdata.end(),
                   vchSig.begin() + (65 - sdata.size()));
 
         CPubKey key;
         for (uint8_t recid : {0, 1, 2, 3}) {
             vchSig[0] = 31 + recid;
             if (key.RecoverCompact(hash, vchSig)) {
                 // found a match
                 break;
             }
         }
         if (!key.IsValid()) {
             throw std::runtime_error(
                 std::string("Could not generate pubkey for ") + HexStr(rdata));
         }
         std::vector<uint8_t> vchKey(key.begin(), key.end());
 
         DoPush(vchKey);
         return *this;
     }
 
     TestBuilder &
     PushECDSASigFromParts(const std::vector<uint8_t> &rdata,
                           const std::vector<uint8_t> &sdata,
                           SigHashType sigHashType = SigHashType()) {
         // Constructs a DER signature out of variable-length r and s arrays &
         // adds hashtype byte.
         assert(rdata.size() <= 32);
         assert(sdata.size() <= 32);
         assert(rdata.size() > 0);
         assert(sdata.size() > 0);
         assert(rdata[0] != 0);
         assert(sdata[0] != 0);
         std::vector<uint8_t> vchSig{0x30, 0x00, 0x02};
         if (rdata[0] & 0x80) {
             vchSig.push_back(rdata.size() + 1);
             vchSig.push_back(0);
             vchSig.insert(vchSig.end(), rdata.begin(), rdata.end());
         } else {
             vchSig.push_back(rdata.size());
             vchSig.insert(vchSig.end(), rdata.begin(), rdata.end());
         }
         vchSig.push_back(0x02);
         if (sdata[0] & 0x80) {
             vchSig.push_back(sdata.size() + 1);
             vchSig.push_back(0);
             vchSig.insert(vchSig.end(), sdata.begin(), sdata.end());
         } else {
             vchSig.push_back(sdata.size());
             vchSig.insert(vchSig.end(), sdata.begin(), sdata.end());
         }
         vchSig[1] = vchSig.size() - 2;
         vchSig.push_back(static_cast<uint8_t>(sigHashType.getRawSigHashType()));
         DoPush(vchSig);
         return *this;
     }
 
     TestBuilder &Push(const CPubKey &pubkey) {
         DoPush(std::vector<uint8_t>(pubkey.begin(), pubkey.end()));
         return *this;
     }
 
     TestBuilder &PushRedeem() {
         DoPush(std::vector<uint8_t>(redeemscript.begin(), redeemscript.end()));
         return *this;
     }
 
     TestBuilder &EditPush(unsigned int pos, const std::string &hexin,
                           const std::string &hexout) {
         assert(havePush);
         std::vector<uint8_t> datain = ParseHex(hexin);
         std::vector<uint8_t> dataout = ParseHex(hexout);
         assert(pos + datain.size() <= push.size());
         BOOST_CHECK_MESSAGE(
             std::vector<uint8_t>(push.begin() + pos,
                                  push.begin() + pos + datain.size()) == datain,
             comment);
         push.erase(push.begin() + pos, push.begin() + pos + datain.size());
         push.insert(push.begin() + pos, dataout.begin(), dataout.end());
         return *this;
     }
 
     TestBuilder &DamagePush(unsigned int pos) {
         assert(havePush);
         assert(pos < push.size());
         push[pos] ^= 1;
         return *this;
     }
 
     TestBuilder &Test() {
         // Make a copy so we can rollback the push.
         TestBuilder copy = *this;
         DoPush();
         DoTest(creditTx->vout[0].scriptPubKey, spendTx.vin[0].scriptSig, flags,
                comment, scriptError, nValue);
         *this = copy;
         return *this;
     }
 
     UniValue GetJSON() {
         DoPush();
         UniValue array(UniValue::VARR);
         if (nValue != Amount::zero()) {
             UniValue amount(UniValue::VARR);
             amount.push_back(ValueFromAmount(nValue));
             array.push_back(amount);
         }
 
         array.push_back(FormatScript(spendTx.vin[0].scriptSig));
         array.push_back(FormatScript(creditTx->vout[0].scriptPubKey));
         array.push_back(FormatScriptFlags(flags));
         array.push_back(FormatScriptError(scriptError));
         array.push_back(comment);
         return array;
     }
 
     std::string GetComment() const { return comment; }
 };
 
 std::string JSONPrettyPrint(const UniValue &univalue) {
     std::string ret = univalue.write(4);
     // Workaround for libunivalue pretty printer, which puts a space between
     // commas and newlines
     size_t pos = 0;
     while ((pos = ret.find(" \n", pos)) != std::string::npos) {
         ret.replace(pos, 2, "\n");
         pos++;
     }
 
     return ret;
 }
 } // namespace
 
 BOOST_AUTO_TEST_CASE(script_build) {
     const KeyData keys;
 
     std::vector<TestBuilder> tests;
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK", 0)
             .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK, bad sig", 0)
             .PushSigECDSA(keys.key0)
             .DamagePush(10)
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey1C.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2PKH", 0)
                         .PushSigECDSA(keys.key1)
                         .Push(keys.pubkey1C));
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey2C.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2PKH, bad pubkey", 0)
                         .PushSigECDSA(keys.key2)
                         .Push(keys.pubkey2C)
                         .DamagePush(5)
                         .SetScriptError(ScriptError::EQUALVERIFY));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2PK anyonecanpay", 0)
             .PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2PK anyonecanpay marked with normal hashtype", 0)
             .PushSigECDSA(keys.key1, SigHashType().withAnyoneCanPay())
             .EditPush(70, "81", "01")
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "P2SH(P2PK)", SCRIPT_VERIFY_P2SH, true)
             .PushSigECDSA(keys.key0)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "P2SH(P2PK), bad redeemscript", SCRIPT_VERIFY_P2SH, true)
             .PushSigECDSA(keys.key0)
             .PushRedeem()
             .DamagePush(10)
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey0.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2SH(P2PKH)", SCRIPT_VERIFY_P2SH, true)
                         .PushSigECDSA(keys.key0)
                         .Push(keys.pubkey0)
                         .PushRedeem());
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey1.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2SH(P2PKH), bad sig but no VERIFY_P2SH", 0,
                                 true)
                         .PushSigECDSA(keys.key0)
                         .DamagePush(10)
                         .PushRedeem());
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey1.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2SH(P2PKH), bad sig", SCRIPT_VERIFY_P2SH,
                                 true)
                         .PushSigECDSA(keys.key0)
                         .DamagePush(10)
                         .PushRedeem()
                         .SetScriptError(ScriptError::EQUALVERIFY));
 
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "3-of-3", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .PushSigECDSA(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "3-of-3, 2 sigs", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .Num(0)
                         .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "P2SH(2-of-3)", SCRIPT_VERIFY_P2SH, true)
                         .Num(0)
                         .PushSigECDSA(keys.key1)
                         .PushSigECDSA(keys.key2)
                         .PushRedeem());
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "P2SH(2-of-3), 1 sig", SCRIPT_VERIFY_P2SH, true)
                         .Num(0)
                         .PushSigECDSA(keys.key1)
                         .Num(0)
                         .PushRedeem()
                         .SetScriptError(ScriptError::EVAL_FALSE));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too much R padding but no DERSIG", 0)
             .PushSigECDSA(keys.key1, SigHashType(), 31, 32)
             .EditPush(1, "43021F", "44022000"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too much R padding", SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key1, SigHashType(), 31, 32)
             .EditPush(1, "43021F", "44022000")
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too much S padding but no DERSIG", 0)
             .PushSigECDSA(keys.key1)
             .EditPush(1, "44", "45")
             .EditPush(37, "20", "2100"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too much S padding", SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key1)
             .EditPush(1, "44", "45")
             .EditPush(37, "20", "2100")
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too little R padding but no DERSIG", 0)
             .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
             .EditPush(1, "45022100", "440220"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "P2PK with too little R padding", SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
             .EditPush(1, "45022100", "440220")
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
             "P2PK NOT with bad sig with too much R padding but no DERSIG", 0)
             .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
             .EditPush(1, "43021F", "44022000")
             .DamagePush(10));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with bad sig with too much R padding",
                                 SCRIPT_VERIFY_DERSIG)
                         .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
                         .EditPush(1, "43021F", "44022000")
                         .DamagePush(10)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript()
                         << ToByteVector(keys.pubkey2C) << OP_CHECKSIG << OP_NOT,
                     "P2PK NOT with too much R padding but no DERSIG", 0)
             .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
             .EditPush(1, "43021F", "44022000")
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey2C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with too much R padding",
                                 SCRIPT_VERIFY_DERSIG)
                         .PushSigECDSA(keys.key2, SigHashType(), 31, 32)
                         .EditPush(1, "43021F", "44022000")
                         .SetScriptError(ScriptError::SIG_DER));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 1, without DERSIG", 0)
             .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
             .EditPush(1, "45022100", "440220"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 1, with DERSIG", SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
             .EditPush(1, "45022100", "440220")
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 2, without DERSIG", 0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 2, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 3, without DERSIG", 0)
             .Num(0)
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 3, with DERSIG", SCRIPT_VERIFY_DERSIG)
             .Num(0)
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 4, without DERSIG", 0)
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 4, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG << OP_NOT,
             "BIP66 example 4, with DERSIG, non-null DER-compliant signature",
             SCRIPT_VERIFY_DERSIG)
             .Push("300602010102010101"));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 4, with DERSIG and NULLFAIL",
                                 SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_NULLFAIL)
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 4, with DERSIG and NULLFAIL, "
                                 "non-null DER-compliant signature",
                                 SCRIPT_VERIFY_DERSIG | SCRIPT_VERIFY_NULLFAIL)
                         .Push("300602010102010101")
                         .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 5, without DERSIG", 0)
             .Num(1)
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKSIG,
                     "BIP66 example 5, with DERSIG", SCRIPT_VERIFY_DERSIG)
             .Num(1)
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 6, without DERSIG", 0)
                         .Num(1));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKSIG << OP_NOT,
                                 "BIP66 example 6, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(1)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 7, without DERSIG", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .PushSigECDSA(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 7, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .PushSigECDSA(keys.key2)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 8, without DERSIG", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .PushSigECDSA(keys.key2)
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 8, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .PushSigECDSA(keys.key2)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 9, without DERSIG", 0)
                         .Num(0)
                         .Num(0)
                         .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 9, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .Num(0)
                         .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 10, without DERSIG", 0)
                         .Num(0)
                         .Num(0)
                         .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220"));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 10, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .Num(0)
                         .PushSigECDSA(keys.key2, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 11, without DERSIG", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0)
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "BIP66 example 11, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0)
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 12, without DERSIG", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_2
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "BIP66 example 12, with DERSIG",
                                 SCRIPT_VERIFY_DERSIG)
                         .Num(0)
                         .PushSigECDSA(keys.key1, SigHashType(), 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with multi-byte hashtype, without DERSIG", 0)
             .PushSigECDSA(keys.key2)
             .EditPush(70, "01", "0101"));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with multi-byte hashtype, with DERSIG",
                     SCRIPT_VERIFY_DERSIG)
             .PushSigECDSA(keys.key2)
             .EditPush(70, "01", "0101")
             .SetScriptError(ScriptError::SIG_DER));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with high S but no LOW_S", 0)
             .PushSigECDSA(keys.key2, SigHashType(), 32, 33));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with high S", SCRIPT_VERIFY_LOW_S)
             .PushSigECDSA(keys.key2, SigHashType(), 32, 33)
             .SetScriptError(ScriptError::SIG_HIGH_S));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                     "P2PK with hybrid pubkey but no STRICTENC", 0)
             .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                     "P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC)
             .PushSigECDSA(keys.key0, SigHashType())
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with hybrid pubkey but no STRICTENC",
                                 0)
                         .PushSigECDSA(keys.key0)
                         .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with hybrid pubkey",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigECDSA(keys.key0)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript()
                         << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
                     "P2PK NOT with invalid hybrid pubkey but no STRICTENC", 0)
             .PushSigECDSA(keys.key0)
             .DamagePush(10));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKSIG << OP_NOT,
                                 "P2PK NOT with invalid hybrid pubkey",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigECDSA(keys.key0)
                         .DamagePush(10)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
                               << ToByteVector(keys.pubkey1C) << OP_2
                               << OP_CHECKMULTISIG,
                     "1-of-2 with the second 1 hybrid pubkey and no STRICTENC",
                     0)
             .Num(0)
             .PushSigECDSA(keys.key1));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
                                           << ToByteVector(keys.pubkey1C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "1-of-2 with the second 1 hybrid pubkey",
                                 SCRIPT_VERIFY_STRICTENC)
                         .Num(0)
                         .PushSigECDSA(keys.key1));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey0H) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "1-of-2 with the first 1 hybrid pubkey",
                                 SCRIPT_VERIFY_STRICTENC)
                         .Num(0)
                         .PushSigECDSA(keys.key1)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2PK with undefined hashtype but no STRICTENC", 0)
             .PushSigECDSA(keys.key1, SigHashType(5)));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2PK with undefined hashtype", SCRIPT_VERIFY_STRICTENC)
             .PushSigECDSA(keys.key1, SigHashType(5))
             .SetScriptError(ScriptError::SIG_HASHTYPE));
 
     // Generate P2PKH tests for invalid SigHashType
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey0.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2PKH with invalid sighashtype", 0)
                         .PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32,
                                       Amount::zero(), 0)
                         .Push(keys.pubkey0));
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey0.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "P2PKH with invalid sighashtype and STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigECDSA(keys.key0, SigHashType(0x21), 32, 32,
                                       Amount::zero(), SCRIPT_VERIFY_STRICTENC)
                         .Push(keys.pubkey0)
                         // Should fail for STRICTENC
                         .SetScriptError(ScriptError::SIG_HASHTYPE));
 
     // Generate P2SH tests for invalid SigHashType
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2SH(P2PK) with invalid sighashtype", SCRIPT_VERIFY_P2SH,
                     true)
             .PushSigECDSA(keys.key1, SigHashType(0x21))
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "P2SH(P2PK) with invalid sighashtype and STRICTENC",
                     SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, true)
             .PushSigECDSA(keys.key1, SigHashType(0x21))
             .PushRedeem()
             // Should fail for STRICTENC
             .SetScriptError(ScriptError::SIG_HASHTYPE));
 
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
             "P2PK NOT with invalid sig and undefined hashtype but no STRICTENC",
             0)
             .PushSigECDSA(keys.key1, SigHashType(5))
             .DamagePush(10));
     tests.push_back(
         TestBuilder(CScript()
                         << ToByteVector(keys.pubkey1) << OP_CHECKSIG << OP_NOT,
                     "P2PK NOT with invalid sig and undefined hashtype",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigECDSA(keys.key1, SigHashType(5))
             .DamagePush(10)
             .SetScriptError(ScriptError::SIG_HASHTYPE));
 
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "3-of-3 with nonzero dummy", 0)
                         .Num(1)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .PushSigECDSA(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "3-of-3 NOT with invalid sig and nonzero dummy",
                                 0)
                         .Num(1)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .PushSigECDSA(keys.key2)
                         .DamagePush(10));
 
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey1C) << OP_2
                                           << OP_CHECKMULTISIG,
                                 "2-of-2 with two identical keys and sigs "
                                 "pushed using OP_DUP but no SIGPUSHONLY",
                                 0)
                         .Num(0)
                         .PushSigECDSA(keys.key1)
                         .Add(CScript() << OP_DUP));
     tests.push_back(
         TestBuilder(
             CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                       << ToByteVector(keys.pubkey1C) << OP_2
                       << OP_CHECKMULTISIG,
             "2-of-2 with two identical keys and sigs pushed using OP_DUP",
             SCRIPT_VERIFY_SIGPUSHONLY)
             .Num(0)
             .PushSigECDSA(keys.key1)
             .Add(CScript() << OP_DUP)
             .SetScriptError(ScriptError::SIG_PUSHONLY));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
             "P2SH(P2PK) with non-push scriptSig but no P2SH or SIGPUSHONLY", 0,
             true)
             .PushSigECDSA(keys.key2)
             .Add(CScript() << OP_NOP8)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2PK with non-push scriptSig but with P2SH validation", 0)
             .PushSigECDSA(keys.key2)
             .Add(CScript() << OP_NOP8));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2SH(P2PK) with non-push scriptSig but no SIGPUSHONLY",
                     SCRIPT_VERIFY_P2SH, true)
             .PushSigECDSA(keys.key2)
             .Add(CScript() << OP_NOP8)
             .PushRedeem()
             .SetScriptError(ScriptError::SIG_PUSHONLY));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey2C) << OP_CHECKSIG,
                     "P2SH(P2PK) with non-push scriptSig but not P2SH",
                     SCRIPT_VERIFY_SIGPUSHONLY, true)
             .PushSigECDSA(keys.key2)
             .Add(CScript() << OP_NOP8)
             .PushRedeem()
             .SetScriptError(ScriptError::SIG_PUSHONLY));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey1C) << OP_2
                               << OP_CHECKMULTISIG,
                     "2-of-2 with two identical keys and sigs pushed",
                     SCRIPT_VERIFY_SIGPUSHONLY)
             .Num(0)
             .PushSigECDSA(keys.key1)
             .PushSigECDSA(keys.key1));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK with unnecessary input but no CLEANSTACK",
                     SCRIPT_VERIFY_P2SH)
             .Num(11)
             .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK with unnecessary input",
                     SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH)
             .Num(11)
             .PushSigECDSA(keys.key0)
             .SetScriptError(ScriptError::CLEANSTACK));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2SH with unnecessary input but no CLEANSTACK",
                     SCRIPT_VERIFY_P2SH, true)
             .Num(11)
             .PushSigECDSA(keys.key0)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2SH with unnecessary input",
                     SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true)
             .Num(11)
             .PushSigECDSA(keys.key0)
             .PushRedeem()
             .SetScriptError(ScriptError::CLEANSTACK));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2SH with CLEANSTACK",
                     SCRIPT_VERIFY_CLEANSTACK | SCRIPT_VERIFY_P2SH, true)
             .PushSigECDSA(keys.key0)
             .PushRedeem());
 
     static const Amount TEST_AMOUNT(int64_t(12345000000000) * SATOSHI);
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK FORKID", SCRIPT_ENABLE_SIGHASH_FORKID, false,
                     TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK INVALID AMOUNT", SCRIPT_ENABLE_SIGHASH_FORKID, false,
                     TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT + SATOSHI)
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK INVALID FORKID", SCRIPT_VERIFY_STRICTENC, false,
                     TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT)
             .SetScriptError(ScriptError::ILLEGAL_FORKID));
 
     // Test replay protection
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK REPLAY PROTECTED",
                     SCRIPT_ENABLE_SIGHASH_FORKID |
                         SCRIPT_ENABLE_REPLAY_PROTECTION,
                     false, TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT,
                           SCRIPT_ENABLE_SIGHASH_FORKID |
                               SCRIPT_ENABLE_REPLAY_PROTECTION));
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "P2PK REPLAY PROTECTED",
                     SCRIPT_ENABLE_SIGHASH_FORKID |
                         SCRIPT_ENABLE_REPLAY_PROTECTION,
                     false, TEST_AMOUNT)
             .PushSigECDSA(keys.key0, SigHashType().withForkId(), 32, 32,
                           TEST_AMOUNT, SCRIPT_ENABLE_SIGHASH_FORKID)
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     // Test OP_CHECKDATASIG
     const uint32_t checkdatasigflags =
         SCRIPT_VERIFY_STRICTENC | SCRIPT_VERIFY_NULLFAIL;
 
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "Standard CHECKDATASIG", checkdatasigflags)
             .PushDataSigECDSA(keys.key1, {})
             .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG with NULLFAIL flags",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(1)
                         .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG without NULLFAIL flags",
                                 checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(1));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG empty signature",
                                 checkdatasigflags)
                         .Num(0)
                         .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "CHECKDATASIG with High S but no Low S", checkdatasigflags)
             .PushDataSigECDSA(keys.key1, {}, 32, 33)
             .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "CHECKDATASIG with High S",
                     checkdatasigflags | SCRIPT_VERIFY_LOW_S)
             .PushDataSigECDSA(keys.key1, {}, 32, 33)
             .Num(0)
             .SetScriptError(ScriptError::SIG_HIGH_S));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "CHECKDATASIG with too little R padding but no DERSIG",
                     checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
             .PushDataSigECDSA(keys.key1, {}, 33, 32)
             .EditPush(1, "45022100", "440220")
             .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIG,
                     "CHECKDATASIG with too little R padding", checkdatasigflags)
             .PushDataSigECDSA(keys.key1, {}, 33, 32)
             .EditPush(1, "45022100", "440220")
             .Num(0)
             .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
                     "CHECKDATASIG with hybrid pubkey but no STRICTENC",
                     checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
             .PushDataSigECDSA(keys.key0, {})
             .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
                     "CHECKDATASIG with hybrid pubkey", checkdatasigflags)
             .PushDataSigECDSA(keys.key0, {})
             .Num(0)
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG
                               << OP_NOT,
                     "CHECKDATASIG with invalid hybrid pubkey but no STRICTENC",
                     0)
             .PushDataSigECDSA(keys.key0, {})
             .DamagePush(10)
             .Num(0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIG,
                     "CHECKDATASIG with invalid hybrid pubkey",
                     checkdatasigflags)
             .PushDataSigECDSA(keys.key0, {})
             .DamagePush(10)
             .Num(0)
             .SetScriptError(ScriptError::PUBKEYTYPE));
 
     // Test OP_CHECKDATASIGVERIFY
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "Standard CHECKDATASIGVERIFY",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY with NULLFAIL flags",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(1)
                         .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY without NULLFAIL flags",
                                 checkdatasigflags & ~SCRIPT_VERIFY_NULLFAIL)
                         .PushDataSigECDSA(keys.key1, {})
                         .Num(1)
                         .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY empty signature",
                                 checkdatasigflags)
                         .Num(0)
                         .Num(0)
                         .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIG with High S but no Low S",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {}, 32, 33)
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIG with High S",
                                 checkdatasigflags | SCRIPT_VERIFY_LOW_S)
                         .PushDataSigECDSA(keys.key1, {}, 32, 33)
                         .Num(0)
                         .SetScriptError(ScriptError::SIG_HIGH_S));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey1C) << OP_CHECKDATASIGVERIFY
                       << OP_TRUE,
             "CHECKDATASIGVERIFY with too little R padding but no DERSIG",
             checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
             .PushDataSigECDSA(keys.key1, {}, 33, 32)
             .EditPush(1, "45022100", "440220")
             .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1C)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY with too little R padding",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key1, {}, 33, 32)
                         .EditPush(1, "45022100", "440220")
                         .Num(0)
                         .SetScriptError(ScriptError::SIG_DER));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                               << OP_CHECKDATASIGVERIFY << OP_TRUE,
                     "CHECKDATASIGVERIFY with hybrid pubkey but no STRICTENC",
                     checkdatasigflags & ~SCRIPT_VERIFY_STRICTENC)
             .PushDataSigECDSA(keys.key0, {})
             .Num(0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY with hybrid pubkey",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key0, {})
                         .Num(0)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKDATASIGVERIFY
                       << OP_TRUE,
             "CHECKDATASIGVERIFY with invalid hybrid pubkey but no STRICTENC", 0)
             .PushDataSigECDSA(keys.key0, {})
             .DamagePush(10)
             .Num(0)
             .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0H)
                                           << OP_CHECKDATASIGVERIFY << OP_TRUE,
                                 "CHECKDATASIGVERIFY with invalid hybrid pubkey",
                                 checkdatasigflags)
                         .PushDataSigECDSA(keys.key0, {})
                         .DamagePush(10)
                         .Num(0)
                         .SetScriptError(ScriptError::PUBKEYTYPE));
 
     // Test all six CHECK*SIG* opcodes with Schnorr signatures.
     // - STRICTENC flag on/off.
     // - test with different key / mismatching key
 
     // CHECKSIG and Schnorr
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "CHECKSIG Schnorr", 0)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "CHECKSIG Schnorr w/ STRICTENC", SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "CHECKSIG Schnorr other key", SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key1));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIG << OP_NOT,
                                 "CHECKSIG Schnorr mismatched key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key1));
 
     // CHECKSIGVERIFY and Schnorr
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIGVERIFY << OP_1,
                                 "CHECKSIGVERIFY Schnorr", 0)
                         .PushSigSchnorr(keys.key0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIGVERIFY << OP_1,
                                 "CHECKSIGVERIFY Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key0));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey1)
                                           << OP_CHECKSIGVERIFY << OP_1,
                                 "CHECKSIGVERIFY Schnorr other key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key1));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIGVERIFY << OP_1,
                                 "CHECKSIGVERIFY Schnorr mismatched key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key1)
                         .SetScriptError(ScriptError::CHECKSIGVERIFY));
 
     // CHECKDATASIG and Schnorr
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIG,
                                 "CHECKDATASIG Schnorr", 0)
                         .PushDataSigSchnorr(keys.key0, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIG,
                                 "CHECKDATASIG Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key0, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIG,
                                 "CHECKDATASIG Schnorr other key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG Schnorr mismatched key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {}));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIG,
                                 "CHECKDATASIG Schnorr other message",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {1}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIG << OP_NOT,
                                 "CHECKDATASIG Schnorr wrong message",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {1}));
 
     // CHECKDATASIGVERIFY and Schnorr
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr", 0)
                         .PushDataSigSchnorr(keys.key0, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key0, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr other key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey0)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr mismatched key",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {})
                         .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr other message",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {1}));
     tests.push_back(TestBuilder(CScript() << OP_0 << ToByteVector(keys.pubkey1)
                                           << OP_CHECKDATASIGVERIFY << OP_1,
                                 "CHECKDATASIGVERIFY Schnorr wrong message",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushDataSigSchnorr(keys.key1, {1})
                         .SetScriptError(ScriptError::CHECKDATASIGVERIFY));
 
     // CHECKMULTISIG 1-of-1 and Schnorr
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG Schnorr w/ no STRICTENC", 0)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
 
     // Test multisig with multiple Schnorr signatures
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "Schnorr 3-of-3", 0)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "Schnorr-ECDSA-mixed 3-of-3", 0)
                         .Num(0)
                         .PushSigECDSA(keys.key0)
                         .PushSigECDSA(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
 
     // CHECKMULTISIGVERIFY 1-of-1 and Schnorr
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
                               << OP_CHECKMULTISIGVERIFY << OP_1,
                     "CHECKMULTISIGVERIFY Schnorr w/ no STRICTENC", 0)
             .Num(0)
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript()
                                     << OP_1 << ToByteVector(keys.pubkey0)
                                     << OP_1 << OP_CHECKMULTISIGVERIFY << OP_1,
                                 "CHECKMULTISIGVERIFY Schnorr w/ STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
 
     // Test damaged Schnorr signatures
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIG << OP_NOT,
                                 "Schnorr P2PK, bad sig", 0)
                         .PushSigSchnorr(keys.key0)
                         .DamagePush(10));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIG << OP_NOT,
                                 "Schnorr P2PK, bad sig STRICTENC",
                                 SCRIPT_VERIFY_STRICTENC)
                         .PushSigSchnorr(keys.key0)
                         .DamagePush(10));
     tests.push_back(TestBuilder(CScript() << ToByteVector(keys.pubkey0)
                                           << OP_CHECKSIG << OP_NOT,
                                 "Schnorr P2PK, bad sig NULLFAIL",
                                 SCRIPT_VERIFY_NULLFAIL)
                         .PushSigSchnorr(keys.key0)
                         .DamagePush(10)
                         .SetScriptError(ScriptError::SIG_NULLFAIL));
 
     // Make sure P2PKH works with Schnorr
     tests.push_back(TestBuilder(CScript() << OP_DUP << OP_HASH160
                                           << ToByteVector(keys.pubkey1C.GetID())
                                           << OP_EQUALVERIFY << OP_CHECKSIG,
                                 "Schnorr P2PKH", 0)
                         .PushSigSchnorr(keys.key1)
                         .Push(keys.pubkey1C));
 
     // Test of different pubkey encodings with Schnorr
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "Schnorr P2PK with compressed pubkey",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0, SigHashType()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0) << OP_CHECKSIG,
                     "Schnorr P2PK with uncompressed pubkey",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0, SigHashType()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                     "Schnorr P2PK with hybrid pubkey", SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0, SigHashType())
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG,
                     "Schnorr P2PK with hybrid pubkey but no STRICTENC", 0)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(
             CScript() << ToByteVector(keys.pubkey0H) << OP_CHECKSIG << OP_NOT,
             "Schnorr P2PK NOT with damaged hybrid pubkey but no STRICTENC", 0)
             .PushSigSchnorr(keys.key0)
             .DamagePush(10));
 
     // Ensure sighash types get checked with schnorr
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK with undefined basehashtype and STRICTENC",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key1, SigHashType(5))
             .SetScriptError(ScriptError::SIG_HASHTYPE));
     tests.push_back(
         TestBuilder(CScript() << OP_DUP << OP_HASH160
                               << ToByteVector(keys.pubkey0.GetID())
                               << OP_EQUALVERIFY << OP_CHECKSIG,
                     "Schnorr P2PKH with invalid sighashtype but no STRICTENC",
                     0)
             .PushSigSchnorr(keys.key0, SigHashType(0x21), Amount::zero(), 0)
             .Push(keys.pubkey0));
     tests.push_back(
         TestBuilder(CScript() << OP_DUP << OP_HASH160
                               << ToByteVector(keys.pubkey0.GetID())
                               << OP_EQUALVERIFY << OP_CHECKSIG,
                     "Schnorr P2PKH with invalid sighashtype and STRICTENC",
                     SCRIPT_VERIFY_STRICTENC)
             .PushSigSchnorr(keys.key0, SigHashType(0x21), Amount::zero(),
                             SCRIPT_VERIFY_STRICTENC)
             .Push(keys.pubkey0)
             .SetScriptError(ScriptError::SIG_HASHTYPE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK anyonecanpay", 0)
             .PushSigSchnorr(keys.key1, SigHashType().withAnyoneCanPay()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK anyonecanpay marked with normal hashtype", 0)
             .PushSigSchnorr(keys.key1, SigHashType().withAnyoneCanPay())
             .EditPush(64, "81", "01")
             .SetScriptError(ScriptError::EVAL_FALSE));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK with forkID",
                     SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID)
             .PushSigSchnorr(keys.key1, SigHashType().withForkId()));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK with non-forkID sig",
                     SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::MUST_USE_FORKID));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey1) << OP_CHECKSIG,
                     "Schnorr P2PK with cheater forkID bit",
                     SCRIPT_VERIFY_STRICTENC | SCRIPT_ENABLE_SIGHASH_FORKID)
             .PushSigSchnorr(keys.key1)
             .EditPush(64, "01", "41")
             .SetScriptError(ScriptError::EVAL_FALSE));
 
     {
         // There is a point with x = 7 + order but not x = 7.
         // Since r = x mod order, this can have valid signatures, as
         // demonstrated here.
         std::vector<uint8_t> rdata{7};
         std::vector<uint8_t> sdata{7};
         tests.push_back(TestBuilder(CScript() << OP_CHECKSIG,
                                     "recovered-pubkey CHECKSIG 7,7 (wrapped r)",
                                     SCRIPT_VERIFY_STRICTENC)
                             .PushECDSASigFromParts(rdata, sdata)
                             .PushECDSARecoveredPubKey(rdata, sdata));
     }
     {
         // Arbitrary r value that is 29 bytes long, to give room for varying
         // the length of s:
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size() - 1, 33);
         tests.push_back(
             TestBuilder(CScript() << OP_CHECKSIG,
                         "recovered-pubkey CHECKSIG with 63-byte DER",
                         SCRIPT_VERIFY_STRICTENC)
                 .PushECDSASigFromParts(rdata, sdata)
                 .PushECDSARecoveredPubKey(rdata, sdata));
     }
     {
         // 64-byte ECDSA sig does not work.
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size(), 33);
         tests.push_back(
             TestBuilder(CScript() << OP_CHECKSIG,
                         "recovered-pubkey CHECKSIG with 64-byte DER",
                         SCRIPT_VERIFY_STRICTENC)
                 .PushECDSASigFromParts(rdata, sdata)
                 .PushECDSARecoveredPubKey(rdata, sdata)
                 .SetScriptError(ScriptError::EVAL_FALSE));
     }
     {
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size() + 1, 33);
         tests.push_back(
             TestBuilder(CScript() << OP_CHECKSIG,
                         "recovered-pubkey CHECKSIG with 65-byte DER",
                         SCRIPT_VERIFY_STRICTENC)
                 .PushECDSASigFromParts(rdata, sdata)
                 .PushECDSARecoveredPubKey(rdata, sdata));
     }
     {
         // Try 64-byte ECDSA sig again, in multisig.
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size(), 33);
         tests.push_back(
             TestBuilder(CScript()
                             << OP_1 << OP_SWAP << OP_1 << OP_CHECKMULTISIG,
                         "recovered-pubkey CHECKMULTISIG with 64-byte DER",
                         SCRIPT_VERIFY_STRICTENC)
                 .Num(0)
                 .PushECDSASigFromParts(rdata, sdata)
                 .PushECDSARecoveredPubKey(rdata, sdata)
                 .SetScriptError(ScriptError::SIG_BADLENGTH));
     }
 
     // New-multisig tests follow. New multisig will activate with a bunch of
     // related flags active from other upgrades, so we do tests with this group
     // of flags turned on:
     uint32_t newmultisigflags =
         SCRIPT_ENABLE_SCHNORR_MULTISIG | SCRIPT_VERIFY_NULLFAIL |
         SCRIPT_VERIFY_MINIMALDATA | SCRIPT_VERIFY_STRICTENC;
 
     // Tests of the legacy multisig (null dummy element), but with the
     // SCRIPT_ENABLE_SCHNORR_MULTISIG flag turned on. These show the desired
     // legacy behaviour that should be retained.
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0H)
                               << ToByteVector(keys.pubkey1C) << OP_2
                               << OP_CHECKMULTISIG,
                     "1-of-2 with unchecked hybrid pubkey with SCHNORR_MULTISIG",
                     newmultisigflags)
             .Num(0)
             .PushSigECDSA(keys.key1));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey0H) << OP_2
                               << OP_CHECKMULTISIG,
                     "1-of-2 with checked hybrid pubkey with SCHNORR_MULTISIG",
                     newmultisigflags)
             .Num(0)
             .PushSigECDSA(keys.key1)
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(
             CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
                       << OP_CHECKMULTISIG,
             "Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG but no STRICTENC",
             newmultisigflags & ~SCRIPT_VERIFY_STRICTENC)
             .Num(0)
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "Legacy 1-of-1 Schnorr w/ SCHNORR_MULTISIG",
                                 newmultisigflags)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "Legacy 3-of-3 Schnorr w/ SCHNORR_MULTISIG",
                                 newmultisigflags)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(
         TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "Legacy 3-of-3 mixed Schnorr-ECDSA w/ SCHNORR_MULTISIG",
                     newmultisigflags)
             .Num(0)
             .PushSigECDSA(keys.key0)
             .PushSigECDSA(keys.key1)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::SIG_BADLENGTH));
     {
         // Try valid 64-byte ECDSA sig in multisig.
         std::vector<uint8_t> rdata = ParseHex(
             "776879206d757374207765207375666665722077697468206563647361");
         std::vector<uint8_t> sdata(58 - rdata.size(), 33);
         tests.push_back(TestBuilder(CScript() << OP_1 << OP_SWAP << OP_1
                                               << OP_CHECKMULTISIG,
                                     "recovered-pubkey CHECKMULTISIG with "
                                     "64-byte DER w/ SCHNORR_MULTISIG",
                                     newmultisigflags)
                             .Num(0)
                             .PushECDSASigFromParts(rdata, sdata)
                             .PushECDSARecoveredPubKey(rdata, sdata)
                             .SetScriptError(ScriptError::SIG_BADLENGTH));
     }
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG << OP_NOT,
                                 "CHECKMULTISIG 2-of-3 w/ SCHNORR_MULTISIG "
                                 "(return-false still valid via legacy mode)",
                                 newmultisigflags)
                         .Num(0)
                         .Num(0)
                         .Num(0));
     tests.push_back(TestBuilder(CScript() << OP_0 << OP_0 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 0-of-0 w/ SCHNORR_MULTISIG",
                                 newmultisigflags)
                         .Num(0));
     tests.push_back(
         TestBuilder(CScript() << OP_0 << ToByteVector(ParseHex("BEEF")) << OP_1
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 0-of-1 w/ SCHNORR_MULTISIG, null dummy",
                     newmultisigflags)
             .Num(0));
 
     // Tests of schnorr checkmultisig actually turned on (flag on & dummy
     // element is not null).
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 1-of-1 Schnorr",
                                 newmultisigflags)
                         .Num(0b1)
                         .PushSigSchnorr(keys.key0));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0)
                                           << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 1-of-1 Schnorr, nonminimal bits",
                                 newmultisigflags)
                         .Push("0100")
                         .PushSigSchnorr(keys.key0)
                         .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(TestBuilder(CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 3-of-3 Schnorr",
                                 newmultisigflags)
                         .Num(0b111)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_4 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 4-of-3 Schnorr",
                                 newmultisigflags)
                         .Num(0b1111)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::SIG_COUNT));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 2-of-3 (110) Schnorr",
                                 newmultisigflags)
                         .Num(0b110)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 2-of-3 (101) Schnorr",
                                 newmultisigflags)
                         .Num(0b101)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key2));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 2-of-3 (011) Schnorr",
                                 newmultisigflags)
                         .Num(0b011)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, mismatched bits Schnorr",
                     newmultisigflags)
             .Num(0b011)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 2-of-3 Schnorr, all bits set",
                                 newmultisigflags)
                         .Num(0b111)
                         .PushSigSchnorr(keys.key1)
                         .PushSigSchnorr(keys.key2)
                         .SetScriptError(ScriptError::INVALID_BIT_COUNT));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, extra high bit set",
                     newmultisigflags)
             .Num(0b1110)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::INVALID_BIT_RANGE));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, too high bit set",
                     newmultisigflags)
             .Num(0b1010)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::INVALID_BIT_RANGE));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, too few bits set",
                     newmultisigflags)
             .Num(0b010)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::INVALID_BIT_COUNT));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, with no bits set "
                     "(attempt to malleate return-false)",
                     newmultisigflags)
             .Push("00")
             .Num(0)
             .Num(0)
             .SetScriptError(ScriptError::INVALID_BIT_COUNT));
     tests.push_back(TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << OP_3
                                           << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG null dummy with schnorr sigs "
                                 "(with SCHNORR_MULTISIG on)",
                                 newmultisigflags)
                         .Num(0)
                         .PushSigSchnorr(keys.key0)
                         .PushSigSchnorr(keys.key1)
                         .SetScriptError(ScriptError::SIG_BADLENGTH));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 Schnorr, misordered signatures",
                     newmultisigflags)
             .Num(0b011)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(
         TestBuilder(
             CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C) << OP_DUP << OP_2DUP
                       << OP_2DUP << ToByteVector(keys.pubkey2C) << OP_8
                       << OP_CHECKMULTISIG,
             "CHECKMULTISIG 2-of-8 Schnorr, right way to represent 0b10000001",
             newmultisigflags)
             .Num(-1)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key2));
     tests.push_back(
         TestBuilder(
             CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C) << OP_DUP << OP_2DUP
                       << OP_2DUP << ToByteVector(keys.pubkey2C) << OP_8
                       << OP_CHECKMULTISIG,
             "CHECKMULTISIG 2-of-8 Schnorr, wrong way to represent 0b10000001",
             newmultisigflags)
             .Num(0b10000001)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << -1 << -1 << -1 << -1 << -1
                               << ToByteVector(keys.pubkey0C) << -1 << 7
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-7 Schnorr, second-to-last key",
                     newmultisigflags)
             .Push("20")
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << -1 << -1 << -1 << -1 << -1 << -1 << -1
                               << -1 << -1 << -1 << ToByteVector(keys.pubkey0C)
                               << -1 << -1 << 13 << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-13 Schnorr, third-to-last key",
                     newmultisigflags)
             .Push("0004")
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript()
                         << OP_OVER << OP_DUP << OP_DUP << OP_2DUP << OP_3DUP
                         << OP_3DUP << OP_3DUP << OP_3DUP << 20
                         << ToByteVector(keys.pubkey0C)
                         << ToByteVector(keys.pubkey1C)
                         << ToByteVector(keys.pubkey2C) << OP_OVER << OP_DUP
                         << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << 20 << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 20-of-20 Schnorr", newmultisigflags)
             .Push("ffff0f")
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2));
     tests.push_back(
         TestBuilder(
             CScript() << OP_OVER << OP_DUP << OP_DUP << OP_2DUP << OP_3DUP
                       << OP_3DUP << OP_3DUP << OP_3DUP << 20
                       << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C)
                       << ToByteVector(keys.pubkey2C) << OP_OVER << OP_DUP
                       << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP
                       << OP_3DUP << 20 << OP_CHECKMULTISIG,
             "CHECKMULTISIG 20-of-20 Schnorr, checkbits +1", newmultisigflags)
             .Push("000010")
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::INVALID_BIT_RANGE));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0C) << OP_DUP
                               << ToByteVector(keys.pubkey1C) << OP_3DUP
                               << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                               << OP_3DUP << 21 << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-21 Schnorr", newmultisigflags)
             .Push("000010")
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::PUBKEY_COUNT));
     tests.push_back(TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << OP_DUP << OP_2DUP << OP_3DUP
                                           << OP_3DUP << OP_3DUP << OP_3DUP
                                           << OP_3DUP << 20 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 1-of-20 Schnorr, first key",
                                 newmultisigflags)
                         .Push("010000")
                         .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(
             CScript() << OP_1 << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C) << OP_DUP << OP_2DUP
                       << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                       << 20 << OP_CHECKMULTISIG,
             "CHECKMULTISIG 1-of-20 Schnorr, first key, wrong endianness",
             newmultisigflags)
             .Push("000001")
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(
         TestBuilder(
             CScript() << OP_1 << ToByteVector(keys.pubkey0C) << OP_2DUP
                       << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                       << OP_3DUP << 20 << OP_CHECKMULTISIG,
             "CHECKMULTISIG 1-of-20 Schnorr, truncating zeros not allowed",
             newmultisigflags)
             .Num(1)
             .PushSigSchnorr(keys.key0)
             .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(
         TestBuilder(CScript()
                         << OP_1 << ToByteVector(keys.pubkey0C) << OP_DUP
                         << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << ToByteVector(keys.pubkey1C) << 20
                         << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-20 Schnorr, last key", newmultisigflags)
             .Push("000008")
             .PushSigSchnorr(keys.key1));
     tests.push_back(
         TestBuilder(CScript()
                         << OP_1 << ToByteVector(keys.pubkey0C) << OP_DUP
                         << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << ToByteVector(keys.pubkey1C) << 20
                         << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-20 Schnorr, last key, wrong endianness",
                     newmultisigflags)
             .Push("080000")
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::SIG_NULLFAIL));
     tests.push_back(TestBuilder(CScript()
                                     << OP_1 << ToByteVector(keys.pubkey0C)
                                     << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP
                                     << OP_3DUP << OP_3DUP << OP_3DUP
                                     << ToByteVector(keys.pubkey1C) << 20
                                     << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 1-of-20 Schnorr, last key, "
                                 "truncating zeros not allowed",
                                 newmultisigflags)
                         .Push("0800")
                         .PushSigSchnorr(keys.key1)
                         .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(ParseHex("BEEF"))
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 (110) Schnorr, first key garbage",
                     newmultisigflags)
             .Num(0b110)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(ParseHex("BEEF"))
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(keys.pubkey2C) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 (011) Schnorr, first key garbage",
                     newmultisigflags)
             .Num(0b011)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1)
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(ParseHex("BEEF")) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 (011) Schnorr, last key garbage",
                     newmultisigflags)
             .Num(0b011)
             .PushSigSchnorr(keys.key0)
             .PushSigSchnorr(keys.key1));
     tests.push_back(
         TestBuilder(CScript() << OP_2 << ToByteVector(keys.pubkey0C)
                               << ToByteVector(keys.pubkey1C)
                               << ToByteVector(ParseHex("BEEF")) << OP_3
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 2-of-3 (110) Schnorr, last key garbage",
                     newmultisigflags)
             .Num(0b110)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::PUBKEYTYPE));
     tests.push_back(
         TestBuilder(
             CScript() << OP_0 << OP_0 << OP_CHECKMULTISIG,
             "CHECKMULTISIG 0-of-0 with SCHNORR_MULTISIG, dummy must be null",
             newmultisigflags)
             .Push("00")
             .SetScriptError(ScriptError::INVALID_BITFIELD_SIZE));
     tests.push_back(TestBuilder(CScript()
                                     << OP_0 << ToByteVector(ParseHex("BEEF"))
                                     << OP_1 << OP_CHECKMULTISIG,
                                 "CHECKMULTISIG 0-of-1 with SCHNORR_MULTISIG, "
                                 "dummy need not be null",
                                 newmultisigflags)
                         .Push("00"));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
                               << OP_CHECKMULTISIGVERIFY << OP_1,
                     "OP_CHECKMULTISIGVERIFY Schnorr", newmultisigflags)
             .Num(0b1)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << OP_1 << ToByteVector(keys.pubkey0) << OP_1
                               << OP_CHECKMULTISIG,
                     "CHECKMULTISIG 1-of-1 ECDSA signature in Schnorr mode",
                     newmultisigflags)
             .Num(0b1)
             .PushSigECDSA(keys.key0)
             .SetScriptError(ScriptError::SIG_NONSCHNORR));
     tests.push_back(
         TestBuilder(
             CScript() << OP_3 << ToByteVector(keys.pubkey0C)
                       << ToByteVector(keys.pubkey1C)
                       << ToByteVector(keys.pubkey2C) << OP_3
                       << OP_CHECKMULTISIG,
             "CHECKMULTISIG 3-of-3 Schnorr with mixed-in ECDSA signature",
             newmultisigflags)
             .Num(0b111)
             .PushSigECDSA(keys.key0)
             .PushSigSchnorr(keys.key1)
             .PushSigSchnorr(keys.key2)
             .SetScriptError(ScriptError::SIG_NONSCHNORR));
 
     // SigChecks tests follow. We want to primarily focus on behaviour with
     // the modern set of (relevant) flags.
     uint32_t sigchecksflags =
         SCRIPT_ENABLE_SCHNORR_MULTISIG | SCRIPT_VERIFY_NULLFAIL |
         SCRIPT_VERIFY_MINIMALDATA | SCRIPT_VERIFY_STRICTENC |
         SCRIPT_VERIFY_INPUT_SIGCHECKS | SCRIPT_VERIFY_P2SH;
     // First, try some important use cases that we want to make sure are
     // supported but that have high density of sigchecks.
     tests.push_back(TestBuilder(CScript() << 1 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C) << 3
                                           << OP_CHECKMULTISIG,
                                 "SigChecks on bare CHECKMULTISIG 1-of-3 ECDSA",
                                 sigchecksflags)
                         .Num(0)
                         .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << 1 << ToByteVector(keys.pubkey0C) << -1 << -1
                               << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1
                               << -1 << -1 << -1 << -1 << -1 << -1 << -1 << -1
                               << -1 << 20 << OP_CHECKMULTISIG,
                     "SigChecks on bare CHECKMULTISIG 1-of-20 Schnorr",
                     sigchecksflags)
             .Push("010000")
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "SigChecks on P2PK Schnorr", sigchecksflags)
             .PushSigSchnorr(keys.key0));
     tests.push_back(
         TestBuilder(CScript() << ToByteVector(keys.pubkey0C) << OP_CHECKSIG,
                     "SigChecks on P2PK ECDSA", sigchecksflags)
             .PushSigECDSA(keys.key0));
     tests.push_back(
         TestBuilder(
             CScript()
                 << 1 << ToByteVector(keys.pubkey0C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << ToByteVector(keys.pubkey1C) << ToByteVector(keys.pubkey2C)
                 << 15 << OP_CHECKMULTISIG,
             "SigChecks on P2SH CHECKMULTISIG 1-of-15 ECDSA with compressed "
             "keys",
             sigchecksflags, true)
             .Num(0)
             .PushSigECDSA(keys.key0)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript()
                         << ToByteVector(keys.pubkey0C) << 0 << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_OVER
                         << OP_CHECKSIG << OP_OVER << OP_CHECKSIG << OP_DROP,
                     "Null signatures make no SigChecks (CHECKSIG)",
                     sigchecksflags, true)
             .PushRedeem());
     tests.push_back(
         TestBuilder(CScript()
                         << 0 << ToByteVector(keys.pubkey0C) << 0 << 0
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2OVER
                         << OP_CHECKDATASIG << OP_2OVER << OP_CHECKDATASIG
                         << OP_2OVER << OP_CHECKDATASIG << OP_2DROP << OP_NIP,
                     "Null signatures make no SigChecks (CHECKDATASIG)",
                     sigchecksflags, true)
             .PushRedeem());
     // Note that the following test case is "legacy-only", there is no schnorr
     // counterpart since schnorr mode does not permit any null signatures nor
     // an incorrect popcount in checkbits.
     tests.push_back(
         TestBuilder(CScript()
                         << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << 16 << ToByteVector(keys.pubkey0C)
                         << OP_DUP << OP_2DUP << OP_3DUP << OP_3DUP << OP_3DUP
                         << OP_3DUP << 16 << OP_CHECKMULTISIG << OP_NOT,
                     "Null signatures make no SigChecks (CHECKMULTISIG)",
                     sigchecksflags, true)
             .Num(0)
             .Num(0)
             .PushRedeem());
 
     // Now some unusual use cases (some are unsupported behaviour)
     tests.push_back(TestBuilder(CScript() << 1 << ToByteVector(keys.pubkey0C)
                                           << ToByteVector(keys.pubkey1C)
                                           << ToByteVector(keys.pubkey2C)
                                           << OP_DUP << 4 << OP_CHECKMULTISIG,
                                 "SigChecks on bare CHECKMULTISIG 1-of-4 ECDSA",
                                 sigchecksflags)
                         .Num(0)
                         .PushSigECDSA(keys.key0)
                         .SetScriptError(ScriptError::INPUT_SIGCHECKS));
     tests.push_back(
         TestBuilder(
             CScript()
                 << 1 << -1 << ToByteVector(keys.pubkey0C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << 15 << OP_CHECKMULTISIG,
             "SigChecks on P2SH CHECKMULTISIG 1-of-15 ECDSA with a runt key",
             sigchecksflags, true)
             .Num(0)
             .PushSigECDSA(keys.key0)
             .PushRedeem()
             .SetScriptError(ScriptError::INPUT_SIGCHECKS));
     tests.push_back(
         TestBuilder(
             CScript()
                 << 1 << -1 << ToByteVector(keys.pubkey0C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << ToByteVector(keys.pubkey1C)
                 << ToByteVector(keys.pubkey2C) << 15 << OP_CHECKMULTISIG,
             "SigChecks on P2SH CHECKMULTISIG 1-of-15 Schnorr with a runt key",
             sigchecksflags, true)
             .Push("0200")
             .PushSigSchnorr(keys.key0)
             .PushRedeem());
     tests.push_back(TestBuilder(CScript() << 0 << -1 << -1 << -1 << -1 << -1
                                           << -1 << -1 << -1 << -1 << -1 << 10
                                           << OP_CHECKMULTISIG,
                                 "Very short P2SH multisig 0-of-10, spent with "
                                 "legacy mode (0 sigchecks)",
                                 sigchecksflags, true)
                         .Num(0)
                         .PushRedeem());
     tests.push_back(TestBuilder(CScript() << 0 << -1 << -1 << -1 << -1 << -1
                                           << -1 << -1 << -1 << -1 << -1 << 10
                                           << OP_CHECKMULTISIG,
                                 "Very short P2SH multisig 0-of-10, spent with "
                                 "schnorr mode (0 sigchecks)",
                                 sigchecksflags, true)
                         .Push("0000")
                         .PushRedeem());
 
     std::set<std::string> tests_set;
 
     {
         UniValue json_tests = read_json(std::string(
             json_tests::script_tests,
             json_tests::script_tests + sizeof(json_tests::script_tests)));
 
         for (unsigned int idx = 0; idx < json_tests.size(); idx++) {
             const UniValue &tv = json_tests[idx];
             tests_set.insert(JSONPrettyPrint(tv.get_array()));
         }
     }
 
 #ifdef UPDATE_JSON_TESTS
     std::string strGen;
 #endif
 
     for (TestBuilder &test : tests) {
         test.Test();
         std::string str = JSONPrettyPrint(test.GetJSON());
 #ifdef UPDATE_JSON_TESTS
         strGen += str + ",\n";
 #else
         if (tests_set.count(str) == 0) {
             BOOST_CHECK_MESSAGE(false, "Missing auto script_valid test: " +
                                            test.GetComment());
         }
 #endif
     }
 
 #ifdef UPDATE_JSON_TESTS
     FILE *file = fopen("script_tests.json.gen", "w");
     fputs(strGen.c_str(), file);
     fclose(file);
 #endif
 }
 
 BOOST_AUTO_TEST_CASE(script_json_test) {
     // Read tests from test/data/script_tests.json
     // Format is an array of arrays
     // Inner arrays are [ ["wit"..., nValue]?, "scriptSig", "scriptPubKey",
     // "flags", "expected_scripterror" ]
     // ... where scriptSig and scriptPubKey are stringified
     // scripts.
     UniValue tests = read_json(std::string(
         json_tests::script_tests,
         json_tests::script_tests + sizeof(json_tests::script_tests)));
 
     for (unsigned int idx = 0; idx < tests.size(); idx++) {
         UniValue test = tests[idx];
         std::string strTest = test.write();
         Amount nValue = Amount::zero();
         unsigned int pos = 0;
         if (test.size() > 0 && test[pos].isArray()) {
             nValue = AmountFromValue(test[pos][0]);
             pos++;
         }
 
         // Allow size > 3; extra stuff ignored (useful for comments)
         if (test.size() < 4 + pos) {
             if (test.size() != 1) {
                 BOOST_ERROR("Bad test: " << strTest);
             }
             continue;
         }
 
         std::string scriptSigString = test[pos++].get_str();
         std::string scriptPubKeyString = test[pos++].get_str();
         try {
             CScript scriptSig = ParseScript(scriptSigString);
             CScript scriptPubKey = ParseScript(scriptPubKeyString);
             unsigned int scriptflags = ParseScriptFlags(test[pos++].get_str());
             ScriptError scriptError = ParseScriptError(test[pos++].get_str());
 
             DoTest(scriptPubKey, scriptSig, scriptflags, strTest, scriptError,
                    nValue);
         } catch (std::runtime_error &e) {
             BOOST_TEST_MESSAGE("Script test failed.  scriptSig:  "
                                << scriptSigString
                                << " scriptPubKey: " << scriptPubKeyString);
             BOOST_TEST_MESSAGE("Exception: " << e.what());
             throw;
         }
     }
 }
 
 BOOST_AUTO_TEST_CASE(script_PushData) {
     // Check that PUSHDATA1, PUSHDATA2, and PUSHDATA4 create the same value on
     // the stack as the 1-75 opcodes do.
     static const uint8_t direct[] = {1, 0x5a};
     static const uint8_t pushdata1[] = {OP_PUSHDATA1, 1, 0x5a};
     static const uint8_t pushdata2[] = {OP_PUSHDATA2, 1, 0, 0x5a};
     static const uint8_t pushdata4[] = {OP_PUSHDATA4, 1, 0, 0, 0, 0x5a};
 
     ScriptError err;
     std::vector<std::vector<uint8_t>> directStack;
     BOOST_CHECK(EvalScript(directStack,
                            CScript(direct, direct + sizeof(direct)),
                            SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     std::vector<std::vector<uint8_t>> pushdata1Stack;
     BOOST_CHECK(EvalScript(pushdata1Stack,
                            CScript(pushdata1, pushdata1 + sizeof(pushdata1)),
                            SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK(pushdata1Stack == directStack);
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     std::vector<std::vector<uint8_t>> pushdata2Stack;
     BOOST_CHECK(EvalScript(pushdata2Stack,
                            CScript(pushdata2, pushdata2 + sizeof(pushdata2)),
                            SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK(pushdata2Stack == directStack);
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     std::vector<std::vector<uint8_t>> pushdata4Stack;
     BOOST_CHECK(EvalScript(pushdata4Stack,
                            CScript(pushdata4, pushdata4 + sizeof(pushdata4)),
                            SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK(pushdata4Stack == directStack);
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     const std::vector<uint8_t> pushdata1_trunc{OP_PUSHDATA1, 1};
     const std::vector<uint8_t> pushdata2_trunc{OP_PUSHDATA2, 1, 0};
     const std::vector<uint8_t> pushdata4_trunc{OP_PUSHDATA4, 1, 0, 0, 0};
 
     std::vector<std::vector<uint8_t>> stack_ignore;
     BOOST_CHECK(!EvalScript(
         stack_ignore, CScript(pushdata1_trunc.begin(), pushdata1_trunc.end()),
         SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK_EQUAL(err, ScriptError::BAD_OPCODE);
     BOOST_CHECK(!EvalScript(
         stack_ignore, CScript(pushdata2_trunc.begin(), pushdata2_trunc.end()),
         SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK_EQUAL(err, ScriptError::BAD_OPCODE);
     BOOST_CHECK(!EvalScript(
         stack_ignore, CScript(pushdata4_trunc.begin(), pushdata4_trunc.end()),
         SCRIPT_VERIFY_P2SH, BaseSignatureChecker(), &err));
     BOOST_CHECK_EQUAL(err, ScriptError::BAD_OPCODE);
 }
 
 BOOST_AUTO_TEST_CASE(script_cltv_truncated) {
     const auto script_cltv_trunc = CScript() << OP_CHECKLOCKTIMEVERIFY;
 
     std::vector<std::vector<uint8_t>> stack_ignore;
     ScriptError err;
     BOOST_CHECK(!EvalScript(stack_ignore, script_cltv_trunc,
                             SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY,
                             BaseSignatureChecker(), &err));
     BOOST_CHECK_EQUAL(err, ScriptError::INVALID_STACK_OPERATION);
 }
 
 static CScript sign_multisig(const CScript &scriptPubKey,
                              const std::vector<CKey> &keys,
                              const CTransaction &transaction) {
     uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SigHashType(),
                                  Amount::zero());
 
     CScript result;
     //
     // NOTE: CHECKMULTISIG has an unfortunate bug; it requires one extra item on
     // the stack, before the signatures. Putting OP_0 on the stack is the
     // workaround; fixing the bug would mean splitting the block chain (old
     // clients would not accept new CHECKMULTISIG transactions, and vice-versa)
     //
     result << OP_0;
     for (const CKey &key : keys) {
         std::vector<uint8_t> vchSig;
         BOOST_CHECK(key.SignECDSA(hash, vchSig));
         vchSig.push_back(uint8_t(SIGHASH_ALL));
         result << vchSig;
     }
 
     return result;
 }
 
 static CScript sign_multisig(const CScript &scriptPubKey, const CKey &key,
                              const CTransaction &transaction) {
     std::vector<CKey> keys;
     keys.push_back(key);
     return sign_multisig(scriptPubKey, keys, transaction);
 }
 
 BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12) {
     ScriptError err;
     CKey key1, key2, key3;
     key1.MakeNewKey(true);
     key2.MakeNewKey(false);
     key3.MakeNewKey(true);
 
     CScript scriptPubKey12;
     scriptPubKey12 << OP_1 << ToByteVector(key1.GetPubKey())
                    << ToByteVector(key2.GetPubKey()) << OP_2
                    << OP_CHECKMULTISIG;
 
     const CTransaction txFrom12{
         BuildCreditingTransaction(scriptPubKey12, Amount::zero())};
     CMutableTransaction txTo12 = BuildSpendingTransaction(CScript(), txFrom12);
 
     CScript goodsig1 =
         sign_multisig(scriptPubKey12, key1, CTransaction(txTo12));
     BOOST_CHECK(VerifyScript(
         goodsig1, scriptPubKey12, gFlags,
         MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
     txTo12.vout[0].nValue = 2 * SATOSHI;
     BOOST_CHECK(!VerifyScript(
         goodsig1, scriptPubKey12, gFlags,
         MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     CScript goodsig2 =
         sign_multisig(scriptPubKey12, key2, CTransaction(txTo12));
     BOOST_CHECK(VerifyScript(
         goodsig2, scriptPubKey12, gFlags,
         MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     CScript badsig1 = sign_multisig(scriptPubKey12, key3, CTransaction(txTo12));
     BOOST_CHECK(!VerifyScript(
         badsig1, scriptPubKey12, gFlags,
         MutableTransactionSignatureChecker(&txTo12, 0, txFrom12.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 }
 
 BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23) {
     ScriptError err;
     CKey key1, key2, key3, key4;
     key1.MakeNewKey(true);
     key2.MakeNewKey(false);
     key3.MakeNewKey(true);
     key4.MakeNewKey(false);
 
     CScript scriptPubKey23;
     scriptPubKey23 << OP_2 << ToByteVector(key1.GetPubKey())
                    << ToByteVector(key2.GetPubKey())
                    << ToByteVector(key3.GetPubKey()) << OP_3
                    << OP_CHECKMULTISIG;
 
     const CTransaction txFrom23{
         BuildCreditingTransaction(scriptPubKey23, Amount::zero())};
     CMutableTransaction mutableTxTo23 =
         BuildSpendingTransaction(CScript(), txFrom23);
 
     // after it has been set up, mutableTxTo23 does not change in this test, so
     // we can convert it to readonly transaction and use
     // TransactionSignatureChecker instead of MutableTransactionSignatureChecker
     const CTransaction txTo23(mutableTxTo23);
 
     std::vector<CKey> keys;
     keys.push_back(key1);
     keys.push_back(key2);
     CScript goodsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(VerifyScript(
         goodsig1, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key1);
     keys.push_back(key3);
     CScript goodsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(VerifyScript(
         goodsig2, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key2);
     keys.push_back(key3);
     CScript goodsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(VerifyScript(
         goodsig3, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key2);
     keys.push_back(key2); // Can't re-use sig
     CScript badsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig1, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key2);
     keys.push_back(key1); // sigs must be in correct order
     CScript badsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig2, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key3);
     keys.push_back(key2); // sigs must be in correct order
     CScript badsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig3, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key4);
     keys.push_back(key2); // sigs must match pubkeys
     CScript badsig4 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig4, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear();
     keys.push_back(key1);
     keys.push_back(key4); // sigs must match pubkeys
     CScript badsig5 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig5, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::EVAL_FALSE, ScriptErrorString(err));
 
     keys.clear(); // Must have signatures
     CScript badsig6 = sign_multisig(scriptPubKey23, keys, txTo23);
     BOOST_CHECK(!VerifyScript(
         badsig6, scriptPubKey23, gFlags,
         TransactionSignatureChecker(&txTo23, 0, txFrom23.vout[0].nValue),
         &err));
     BOOST_CHECK_MESSAGE(err == ScriptError::INVALID_STACK_OPERATION,
                         ScriptErrorString(err));
 }
 
 /* Wrapper around ProduceSignature to combine two scriptsigs */
 SignatureData CombineSignatures(const CTxOut &txout,
                                 const CMutableTransaction &tx,
                                 const SignatureData &scriptSig1,
                                 const SignatureData &scriptSig2) {
     SignatureData data;
     data.MergeSignatureData(scriptSig1);
     data.MergeSignatureData(scriptSig2);
     ProduceSignature(DUMMY_SIGNING_PROVIDER,
                      MutableTransactionSignatureCreator(&tx, 0, txout.nValue),
                      txout.scriptPubKey, data);
     return data;
 }
 
 BOOST_AUTO_TEST_CASE(script_combineSigs) {
     // Test the ProduceSignature's ability to combine signatures function
     CBasicKeyStore keystore;
     std::vector<CKey> keys;
     std::vector<CPubKey> pubkeys;
     for (int i = 0; i < 3; i++) {
         CKey key;
         key.MakeNewKey(i % 2 == 1);
         keys.push_back(key);
         pubkeys.push_back(key.GetPubKey());
         keystore.AddKey(key);
     }
 
     CMutableTransaction txFrom = BuildCreditingTransaction(
         GetScriptForDestination(keys[0].GetPubKey().GetID()), Amount::zero());
     CMutableTransaction txTo =
         BuildSpendingTransaction(CScript(), CTransaction(txFrom));
     CScript &scriptPubKey = txFrom.vout[0].scriptPubKey;
     SignatureData scriptSig;
 
     SignatureData empty;
     SignatureData combined =
         CombineSignatures(txFrom.vout[0], txTo, empty, empty);
     BOOST_CHECK(combined.scriptSig.empty());
 
     // Single signature case:
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     SignatureData scriptSigCopy = scriptSig;
     // Signing again will give a different, valid signature:
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig ||
                 combined.scriptSig == scriptSig.scriptSig);
 
     // P2SH, single-signature case:
     CScript pkSingle;
     pkSingle << ToByteVector(keys[0].GetPubKey()) << OP_CHECKSIG;
     keystore.AddCScript(pkSingle);
     scriptPubKey = GetScriptForDestination(CScriptID(pkSingle));
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     scriptSigCopy = scriptSig;
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, scriptSigCopy, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSigCopy.scriptSig ||
                 combined.scriptSig == scriptSig.scriptSig);
 
     // Hardest case:  Multisig 2-of-3
     scriptPubKey = GetScriptForMultisig(2, pubkeys);
     keystore.AddCScript(scriptPubKey);
     SignSignature(keystore, CTransaction(txFrom), txTo, 0,
                   SigHashType().withForkId());
     scriptSig = DataFromTransaction(txTo, 0, txFrom.vout[0]);
     combined = CombineSignatures(txFrom.vout[0], txTo, scriptSig, empty);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
     combined = CombineSignatures(txFrom.vout[0], txTo, empty, scriptSig);
     BOOST_CHECK(combined.scriptSig == scriptSig.scriptSig);
 
     // A couple of partially-signed versions:
     std::vector<uint8_t> sig1;
     uint256 hash1 = SignatureHash(scriptPubKey, CTransaction(txTo), 0,
                                   SigHashType().withForkId(), Amount::zero());
     BOOST_CHECK(keys[0].SignECDSA(hash1, sig1));
     sig1.push_back(SIGHASH_ALL | SIGHASH_FORKID);
     std::vector<uint8_t> sig2;
     uint256 hash2 = SignatureHash(
         scriptPubKey, CTransaction(txTo), 0,
         SigHashType().withBaseType(BaseSigHashType::NONE).withForkId(),
         Amount::zero());
     BOOST_CHECK(keys[1].SignECDSA(hash2, sig2));
     sig2.push_back(SIGHASH_NONE | SIGHASH_FORKID);
     std::vector<uint8_t> sig3;
     uint256 hash3 = SignatureHash(
         scriptPubKey, CTransaction(txTo), 0,
         SigHashType().withBaseType(BaseSigHashType::SINGLE).withForkId(),
         Amount::zero());
     BOOST_CHECK(keys[2].SignECDSA(hash3, sig3));
     sig3.push_back(SIGHASH_SINGLE | SIGHASH_FORKID);
 
     // Not fussy about order (or even existence) of placeholders or signatures:
     CScript partial1a = CScript() << OP_0 << sig1 << OP_0;
     CScript partial1b = CScript() << OP_0 << OP_0 << sig1;
     CScript partial2a = CScript() << OP_0 << sig2;
     CScript partial2b = CScript() << sig2 << OP_0;
     CScript partial3a = CScript() << sig3;
     CScript partial3b = CScript() << OP_0 << OP_0 << sig3;
     CScript partial3c = CScript() << OP_0 << sig3 << OP_0;
     CScript complete12 = CScript() << OP_0 << sig1 << sig2;
     CScript complete13 = CScript() << OP_0 << sig1 << sig3;
     CScript complete23 = CScript() << OP_0 << sig2 << sig3;
     SignatureData partial1_sigs;
     partial1_sigs.signatures.emplace(keys[0].GetPubKey().GetID(),
                                      SigPair(keys[0].GetPubKey(), sig1));
     SignatureData partial2_sigs;
     partial2_sigs.signatures.emplace(keys[1].GetPubKey().GetID(),
                                      SigPair(keys[1].GetPubKey(), sig2));
     SignatureData partial3_sigs;
     partial3_sigs.signatures.emplace(keys[2].GetPubKey().GetID(),
                                      SigPair(keys[2].GetPubKey(), sig3));
 
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial1_sigs);
     BOOST_CHECK(combined.scriptSig == partial1a);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
     BOOST_CHECK(combined.scriptSig == complete12);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial1_sigs);
     BOOST_CHECK(combined.scriptSig == complete12);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial1_sigs, partial2_sigs);
     BOOST_CHECK(combined.scriptSig == complete12);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial1_sigs);
     BOOST_CHECK(combined.scriptSig == complete13);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial2_sigs, partial3_sigs);
     BOOST_CHECK(combined.scriptSig == complete23);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial2_sigs);
     BOOST_CHECK(combined.scriptSig == complete23);
     combined =
         CombineSignatures(txFrom.vout[0], txTo, partial3_sigs, partial3_sigs);
     BOOST_CHECK(combined.scriptSig == partial3c);
 }
 
 BOOST_AUTO_TEST_CASE(script_standard_push) {
     ScriptError err;
     for (int i = 0; i < 67000; i++) {
         CScript script;
         script << i;
         BOOST_CHECK_MESSAGE(script.IsPushOnly(),
                             "Number " << i << " is not pure push.");
         BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1,
                                          SCRIPT_VERIFY_MINIMALDATA,
                                          BaseSignatureChecker(), &err),
                             "Number " << i << " push is not minimal data.");
         BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
     }
 
     for (unsigned int i = 0; i <= MAX_SCRIPT_ELEMENT_SIZE; i++) {
         std::vector<uint8_t> data(i, '\111');
         CScript script;
         script << data;
         BOOST_CHECK_MESSAGE(script.IsPushOnly(),
                             "Length " << i << " is not pure push.");
         BOOST_CHECK_MESSAGE(VerifyScript(script, CScript() << OP_1,
                                          SCRIPT_VERIFY_MINIMALDATA,
                                          BaseSignatureChecker(), &err),
                             "Length " << i << " push is not minimal data.");
         BOOST_CHECK_MESSAGE(err == ScriptError::OK, ScriptErrorString(err));
     }
 }
 
 BOOST_AUTO_TEST_CASE(script_IsPushOnly_on_invalid_scripts) {
     // IsPushOnly returns false when given a script containing only pushes that
     // are invalid due to truncation. IsPushOnly() is consensus critical because
     // P2SH evaluation uses it, although this specific behavior should not be
     // consensus critical as the P2SH evaluation would fail first due to the
     // invalid push. Still, it doesn't hurt to test it explicitly.
     static const uint8_t direct[] = {1};
     BOOST_CHECK(!CScript(direct, direct + sizeof(direct)).IsPushOnly());
 }
 
 BOOST_AUTO_TEST_CASE(script_GetScriptAsm) {
     BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY",
                       ScriptToAsmStr(CScript() << OP_NOP2, true));
     BOOST_CHECK_EQUAL(
         "OP_CHECKLOCKTIMEVERIFY",
         ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY, true));
     BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY",
                       ScriptToAsmStr(CScript() << OP_NOP2));
     BOOST_CHECK_EQUAL("OP_CHECKLOCKTIMEVERIFY",
                       ScriptToAsmStr(CScript() << OP_CHECKLOCKTIMEVERIFY));
 
     std::string derSig("304502207fa7a6d1e0ee81132a269ad84e68d695483745cde8b541e"
                        "3bf630749894e342a022100c1f7ab20e13e22fb95281a870f3dcf38"
                        "d782e53023ee313d741ad0cfbc0c5090");
     std::string pubKey(
         "03b0da749730dc9b4b1f4a14d6902877a92541f5368778853d9c4a0cb7802dcfb2");
     std::vector<uint8_t> vchPubKey = ToByteVector(ParseHex(pubKey));
 
     BOOST_CHECK_EQUAL(
         derSig + "00 " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "00"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "80 " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "80"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[ALL] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "01"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[ALL|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "81"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[ALL|FORKID] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "41"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[ALL|FORKID|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "c1"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[NONE] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "02"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[NONE|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "82"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[NONE|FORKID] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "42"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[NONE|FORKID|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "c2"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[SINGLE] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "03"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[SINGLE|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "83"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[SINGLE|FORKID] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "43"))
                                  << vchPubKey,
                        true));
     BOOST_CHECK_EQUAL(
         derSig + "[SINGLE|FORKID|ANYONECANPAY] " + pubKey,
         ScriptToAsmStr(CScript() << ToByteVector(ParseHex(derSig + "c3"))
                                  << vchPubKey,
                        true));
 
     BOOST_CHECK_EQUAL(derSig + "00 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "00"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "80 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "80"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "01 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "01"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "02 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "02"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "03 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "03"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "81 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "81"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "82 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "82"))
                                      << vchPubKey));
     BOOST_CHECK_EQUAL(derSig + "83 " + pubKey,
                       ScriptToAsmStr(CScript()
                                      << ToByteVector(ParseHex(derSig + "83"))
                                      << vchPubKey));
 }
 
 static CScript ScriptFromHex(const char *hex) {
     std::vector<uint8_t> data = ParseHex(hex);
     return CScript(data.begin(), data.end());
 }
 
 BOOST_AUTO_TEST_CASE(script_FindAndDelete) {
     // Exercise the FindAndDelete functionality
     CScript s;
     CScript d;
     CScript expect;
 
     s = CScript() << OP_1 << OP_2;
     // delete nothing should be a no-op
     d = CScript();
     expect = s;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     s = CScript() << OP_1 << OP_2 << OP_3;
     d = CScript() << OP_2;
     expect = CScript() << OP_1 << OP_3;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = CScript() << OP_3 << OP_1 << OP_3 << OP_3 << OP_4 << OP_3;
     d = CScript() << OP_3;
     expect = CScript() << OP_1 << OP_4;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 4);
     BOOST_CHECK(s == expect);
 
     // PUSH 0x02ff03 onto stack
     s = ScriptFromHex("0302ff03");
     d = ScriptFromHex("0302ff03");
     expect = CScript();
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     // PUSH 0x2ff03 PUSH 0x2ff03
     s = ScriptFromHex("0302ff030302ff03");
     d = ScriptFromHex("0302ff03");
     expect = CScript();
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("0302ff030302ff03");
     d = ScriptFromHex("02");
     expect = s; // FindAndDelete matches entire opcodes
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("0302ff030302ff03");
     d = ScriptFromHex("ff");
     expect = s;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     // This is an odd edge case: strip of the push-three-bytes prefix, leaving
     // 02ff03 which is push-two-bytes:
     s = ScriptFromHex("0302ff030302ff03");
     d = ScriptFromHex("03");
     expect = CScript() << ParseHex("ff03") << ParseHex("ff03");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
     BOOST_CHECK(s == expect);
 
     // Byte sequence that spans multiple opcodes:
     // PUSH(0xfeed) OP_1 OP_VERIFY
     s = ScriptFromHex("02feed5169");
     d = ScriptFromHex("feed51");
     expect = s;
     // doesn't match 'inside' opcodes
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     // PUSH(0xfeed) OP_1 OP_VERIFY
     s = ScriptFromHex("02feed5169");
     d = ScriptFromHex("02feed51");
     expect = ScriptFromHex("69");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("516902feed5169");
     d = ScriptFromHex("feed51");
     expect = s;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 0);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("516902feed5169");
     d = ScriptFromHex("02feed51");
     expect = ScriptFromHex("516969");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = CScript() << OP_0 << OP_0 << OP_1 << OP_1;
     d = CScript() << OP_0 << OP_1;
     // FindAndDelete is single-pass
     expect = CScript() << OP_0 << OP_1;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = CScript() << OP_0 << OP_0 << OP_1 << OP_0 << OP_1 << OP_1;
     d = CScript() << OP_0 << OP_1;
     // FindAndDelete is single-pass
     expect = CScript() << OP_0 << OP_1;
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 2);
     BOOST_CHECK(s == expect);
 
     // Another weird edge case:
     // End with invalid push (not enough data)...
     s = ScriptFromHex("0003feed");
     // ... can remove the invalid push
     d = ScriptFromHex("03feed");
     expect = ScriptFromHex("00");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 
     s = ScriptFromHex("0003feed");
     d = ScriptFromHex("00");
     expect = ScriptFromHex("03feed");
     BOOST_CHECK_EQUAL(FindAndDelete(s, d), 1);
     BOOST_CHECK(s == expect);
 }
 
 BOOST_AUTO_TEST_CASE(IsWitnessProgram) {
     // Valid version: [0,16]
     // Valid program_len: [2,40]
     for (int version = -1; version <= 17; version++) {
         for (unsigned int program_len = 1; program_len <= 41; program_len++) {
             CScript script;
             std::vector<uint8_t> program(program_len, '\42');
             int parsed_version;
             std::vector<uint8_t> parsed_program;
             script << version << program;
             bool result =
                 script.IsWitnessProgram(parsed_version, parsed_program);
             bool expected = version >= 0 && version <= 16 && program_len >= 2 &&
                             program_len <= 40;
             BOOST_CHECK_EQUAL(result, expected);
             if (result) {
                 BOOST_CHECK_EQUAL(version, parsed_version);
                 BOOST_CHECK(program == parsed_program);
             }
         }
     }
     // Tests with 1 and 3 stack elements
     {
         CScript script;
         script << OP_0;
         BOOST_CHECK_MESSAGE(
             !script.IsWitnessProgram(),
             "Failed IsWitnessProgram check with 1 stack element");
     }
     {
         CScript script;
         script << OP_0 << std::vector<uint8_t>(20, '\42') << OP_1;
         BOOST_CHECK_MESSAGE(
             !script.IsWitnessProgram(),
             "Failed IsWitnessProgram check with 3 stack elements");
     }
 }
 
 BOOST_AUTO_TEST_CASE(script_HasValidOps) {
     // Exercise the HasValidOps functionality
     CScript script;
     // Normal script
     script =
         ScriptFromHex("76a9141234567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac");
     BOOST_CHECK(script.HasValidOps());
     script =
         ScriptFromHex("76a914ff34567890abcdefa1a2a3a4a5a6a7a8a9a0aaab88ac");
     BOOST_CHECK(script.HasValidOps());
     // Script with OP_INVALIDOPCODE explicit
     script = ScriptFromHex("ff88ac");
     BOOST_CHECK(!script.HasValidOps());
     // Script with undefined opcode
     script = ScriptFromHex("88acc0");
     BOOST_CHECK(!script.HasValidOps());
 
     // Check all non push opcodes.
     for (uint8_t opcode = OP_1NEGATE; opcode < FIRST_UNDEFINED_OP_VALUE;
          opcode++) {
         script = CScript() << opcode;
         BOOST_CHECK(script.HasValidOps());
     }
 
     script = CScript() << FIRST_UNDEFINED_OP_VALUE;
     BOOST_CHECK(!script.HasValidOps());
 }
 
 BOOST_AUTO_TEST_CASE(script_can_append_self) {
     CScript s, d;
 
     s = ScriptFromHex("00");
     s += s;
     d = ScriptFromHex("0000");
     BOOST_CHECK(s == d);
 
     // check doubling a script that's large enough to require reallocation
     static const char hex[] =
         "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6"
         "bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f";
     s = CScript() << ParseHex(hex) << OP_CHECKSIG;
     d = CScript() << ParseHex(hex) << OP_CHECKSIG << ParseHex(hex)
                   << OP_CHECKSIG;
     s += s;
     BOOST_CHECK(s == d);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/src/test/scriptflags.cpp b/src/test/scriptflags.cpp
index 789e41d1ab..580f2187f0 100644
--- a/src/test/scriptflags.cpp
+++ b/src/test/scriptflags.cpp
@@ -1,73 +1,72 @@
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <script/interpreter.h>
 
 #include <test/scriptflags.h>
 
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string/split.hpp>
 #include <boost/test/unit_test.hpp>
 
 #include <map>
 #include <vector>
 
 static std::map<std::string, uint32_t> mapFlagNames = {
     {"NONE", SCRIPT_VERIFY_NONE},
     {"P2SH", SCRIPT_VERIFY_P2SH},
     {"STRICTENC", SCRIPT_VERIFY_STRICTENC},
     {"DERSIG", SCRIPT_VERIFY_DERSIG},
     {"LOW_S", SCRIPT_VERIFY_LOW_S},
     {"SIGPUSHONLY", SCRIPT_VERIFY_SIGPUSHONLY},
     {"MINIMALDATA", SCRIPT_VERIFY_MINIMALDATA},
     {"DISCOURAGE_UPGRADABLE_NOPS", SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS},
     {"CLEANSTACK", SCRIPT_VERIFY_CLEANSTACK},
     {"MINIMALIF", SCRIPT_VERIFY_MINIMALIF},
     {"NULLFAIL", SCRIPT_VERIFY_NULLFAIL},
     {"CHECKLOCKTIMEVERIFY", SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY},
     {"CHECKSEQUENCEVERIFY", SCRIPT_VERIFY_CHECKSEQUENCEVERIFY},
     {"SIGHASH_FORKID", SCRIPT_ENABLE_SIGHASH_FORKID},
     {"REPLAY_PROTECTION", SCRIPT_ENABLE_REPLAY_PROTECTION},
     {"CHECKDATASIG", SCRIPT_VERIFY_CHECKDATASIG_SIGOPS},
     {"DISALLOW_SEGWIT_RECOVERY", SCRIPT_DISALLOW_SEGWIT_RECOVERY},
     {"SCHNORR_MULTISIG", SCRIPT_ENABLE_SCHNORR_MULTISIG},
     {"INPUT_SIGCHECKS", SCRIPT_VERIFY_INPUT_SIGCHECKS},
-    {"REVERSEBYTES", SCRIPT_ENABLE_OP_REVERSEBYTES},
 };
 
 uint32_t ParseScriptFlags(std::string strFlags) {
     if (strFlags.empty()) {
         return 0;
     }
 
     uint32_t flags = 0;
     std::vector<std::string> words;
     boost::algorithm::split(words, strFlags, boost::algorithm::is_any_of(","));
 
     for (std::string &word : words) {
         if (!mapFlagNames.count(word)) {
             BOOST_ERROR("Bad test: unknown verification flag '" << word << "'");
         }
         flags |= mapFlagNames[word];
     }
 
     return flags;
 }
 
 std::string FormatScriptFlags(uint32_t flags) {
     if (flags == 0) {
         return "";
     }
 
     std::string ret;
     std::map<std::string, uint32_t>::const_iterator it = mapFlagNames.begin();
     while (it != mapFlagNames.end()) {
         if (flags & it->second) {
             ret += it->first + ",";
         }
         it++;
     }
 
     return ret.substr(0, ret.size() - 1);
 }
diff --git a/src/validation.cpp b/src/validation.cpp
index 23b5efd514..8ca430dcb5 100644
--- a/src/validation.cpp
+++ b/src/validation.cpp
@@ -1,5662 +1,5645 @@
 // Copyright (c) 2009-2010 Satoshi Nakamoto
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Copyright (c) 2017-2020 The Bitcoin developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <validation.h>
 
 #include <arith_uint256.h>
 #include <avalanche.h>
 #include <blockvalidity.h>
 #include <chainparams.h>
 #include <checkpoints.h>
 #include <checkqueue.h>
 #include <config.h>
 #include <consensus/activation.h>
 #include <consensus/consensus.h>
 #include <consensus/merkle.h>
 #include <consensus/tx_check.h>
 #include <consensus/tx_verify.h>
 #include <consensus/validation.h>
 #include <flatfile.h>
 #include <fs.h>
 #include <hash.h>
 #include <index/txindex.h>
 #include <minerfund.h>
 #include <policy/fees.h>
 #include <policy/mempool.h>
 #include <policy/policy.h>
 #include <policy/settings.h>
 #include <pow.h>
 #include <primitives/block.h>
 #include <primitives/transaction.h>
 #include <random.h>
 #include <reverse_iterator.h>
 #include <script/script.h>
 #include <script/scriptcache.h>
 #include <script/sigcache.h>
 #include <script/standard.h>
 #include <shutdown.h>
 #include <timedata.h>
 #include <tinyformat.h>
 #include <txdb.h>
 #include <txmempool.h>
 #include <ui_interface.h>
 #include <undo.h>
 #include <util/moneystr.h>
 #include <util/strencodings.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <util/validation.h>
 #include <validationinterface.h>
 #include <warnings.h>
 
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/thread.hpp> // boost::this_thread::interruption_point() (mingw)
 
 #include <atomic>
 #include <future>
 #include <sstream>
 #include <string>
 #include <thread>
 
 #define MICRO 0.000001
 #define MILLI 0.001
 
 CChainState g_chainstate;
 
 CChainState &ChainstateActive() {
     return g_chainstate;
 }
 
 CChain &ChainActive() {
     return g_chainstate.m_chain;
 }
 
 /**
  * Global state
  *
  * Mutex to guard access to validation specific variables, such as reading
  * or changing the chainstate.
  *
  * This may also need to be locked when updating the transaction pool, e.g. on
  * AcceptToMemoryPool. See CTxMemPool::cs comment for details.
  *
  * The transaction pool has a separate lock to allow reading from it and the
  * chainstate at the same time.
  */
 RecursiveMutex cs_main;
 
 BlockMap &mapBlockIndex = ::ChainstateActive().mapBlockIndex;
 CBlockIndex *pindexBestHeader = nullptr;
 Mutex g_best_block_mutex;
 std::condition_variable g_best_block_cv;
 uint256 g_best_block;
 int nScriptCheckThreads = 0;
 std::atomic_bool fImporting(false);
 std::atomic_bool fReindex(false);
 bool fHavePruned = false;
 bool fPruneMode = false;
 bool fRequireStandard = true;
 bool fCheckBlockIndex = false;
 bool fCheckpointsEnabled = DEFAULT_CHECKPOINTS_ENABLED;
 size_t nCoinCacheUsage = 5000 * 300;
 uint64_t nPruneTarget = 0;
 int64_t nMaxTipAge = DEFAULT_MAX_TIP_AGE;
 
 BlockHash hashAssumeValid;
 arith_uint256 nMinimumChainWork;
 
 CFeeRate minRelayTxFee = CFeeRate(DEFAULT_MIN_RELAY_TX_FEE_PER_KB);
 Amount maxTxFee = DEFAULT_TRANSACTION_MAXFEE;
 
 CTxMemPool g_mempool;
 
 /** Constant stuff for coinbase transactions we create: */
 CScript COINBASE_FLAGS;
 
 // Internal stuff
 namespace {
 CBlockIndex *&pindexBestInvalid = ::ChainstateActive().pindexBestInvalid;
 CBlockIndex *&pindexBestParked = ::ChainstateActive().pindexBestParked;
 
 /**
  * The best finalized block.
  * This block cannot be reorged in any way, shape or form.
  */
 CBlockIndex const *&pindexFinalized = ::ChainstateActive().pindexFinalized;
 
 /**
  * All pairs A->B, where A (or one of its ancestors) misses transactions, but B
  * has transactions. Pruned nodes may have entries where B is missing data.
  */
 std::multimap<CBlockIndex *, CBlockIndex *> &mapBlocksUnlinked =
     ::ChainstateActive().mapBlocksUnlinked;
 
 RecursiveMutex cs_LastBlockFile;
 std::vector<CBlockFileInfo> vinfoBlockFile;
 int nLastBlockFile = 0;
 /**
  * Global flag to indicate we should check to see if there are block/undo files
  * that should be deleted. Set on startup or if we allocate more file space when
  * we're in prune mode.
  */
 bool fCheckForPruning = false;
 
 /** Dirty block index entries. */
 std::set<const CBlockIndex *> setDirtyBlockIndex;
 
 /** Dirty block file entries. */
 std::set<int> setDirtyFileInfo;
 } // namespace
 
 BlockValidationOptions::BlockValidationOptions(const Config &config)
     : excessiveBlockSize(config.GetMaxBlockSize()), checkPoW(true),
       checkMerkleRoot(true) {}
 
 CBlockIndex *FindForkInGlobalIndex(const CChain &chain,
                                    const CBlockLocator &locator) {
     AssertLockHeld(cs_main);
 
     // Find the first block the caller has in the main chain
     for (const BlockHash &hash : locator.vHave) {
         CBlockIndex *pindex = LookupBlockIndex(hash);
         if (pindex) {
             if (chain.Contains(pindex)) {
                 return pindex;
             }
             if (pindex->GetAncestor(chain.Height()) == chain.Tip()) {
                 return chain.Tip();
             }
         }
     }
     return chain.Genesis();
 }
 
 std::unique_ptr<CCoinsViewDB> pcoinsdbview;
 std::unique_ptr<CCoinsViewCache> pcoinsTip;
 std::unique_ptr<CBlockTreeDB> pblocktree;
 
 // See definition for documentation
 static void FindFilesToPruneManual(std::set<int> &setFilesToPrune,
                                    int nManualPruneHeight);
 static void FindFilesToPrune(std::set<int> &setFilesToPrune,
                              uint64_t nPruneAfterHeight);
 static FILE *OpenUndoFile(const FlatFilePos &pos, bool fReadOnly = false);
 static FlatFileSeq BlockFileSeq();
 static FlatFileSeq UndoFileSeq();
 static uint32_t GetNextBlockScriptFlags(const Consensus::Params &params,
                                         const CBlockIndex *pindex);
 
 bool TestLockPointValidity(const LockPoints *lp) {
     AssertLockHeld(cs_main);
     assert(lp);
     // If there are relative lock times then the maxInputBlock will be set
     // If there are no relative lock times, the LockPoints don't depend on the
     // chain
     if (lp->maxInputBlock) {
         // Check whether ::ChainActive() is an extension of the block at which
         // the LockPoints calculation was valid. If not LockPoints are no longer
         // valid.
         if (!::ChainActive().Contains(lp->maxInputBlock)) {
             return false;
         }
     }
 
     // LockPoints still valid
     return true;
 }
 
 bool CheckSequenceLocks(const CTxMemPool &pool, const CTransaction &tx,
                         int flags, LockPoints *lp, bool useExistingLockPoints) {
     AssertLockHeld(cs_main);
     AssertLockHeld(pool.cs);
 
     CBlockIndex *tip = ::ChainActive().Tip();
     assert(tip != nullptr);
 
     CBlockIndex index;
     index.pprev = tip;
     // CheckSequenceLocks() uses ::ChainActive().Height()+1 to evaluate height
     // based locks because when SequenceLocks() is called within ConnectBlock(),
     // the height of the block *being* evaluated is what is used. Thus if we
     // want to know if a transaction can be part of the *next* block, we need to
     // use one more than ::ChainActive().Height()
     index.nHeight = tip->nHeight + 1;
 
     std::pair<int, int64_t> lockPair;
     if (useExistingLockPoints) {
         assert(lp);
         lockPair.first = lp->height;
         lockPair.second = lp->time;
     } else {
         // pcoinsTip contains the UTXO set for ::ChainActive().Tip()
         CCoinsViewMemPool viewMemPool(pcoinsTip.get(), pool);
         std::vector<int> prevheights;
         prevheights.resize(tx.vin.size());
         for (size_t txinIndex = 0; txinIndex < tx.vin.size(); txinIndex++) {
             const CTxIn &txin = tx.vin[txinIndex];
             Coin coin;
             if (!viewMemPool.GetCoin(txin.prevout, coin)) {
                 return error("%s: Missing input", __func__);
             }
             if (coin.GetHeight() == MEMPOOL_HEIGHT) {
                 // Assume all mempool transaction confirm in the next block
                 prevheights[txinIndex] = tip->nHeight + 1;
             } else {
                 prevheights[txinIndex] = coin.GetHeight();
             }
         }
         lockPair = CalculateSequenceLocks(tx, flags, &prevheights, index);
         if (lp) {
             lp->height = lockPair.first;
             lp->time = lockPair.second;
             // Also store the hash of the block with the highest height of all
             // the blocks which have sequence locked prevouts. This hash needs
             // to still be on the chain for these LockPoint calculations to be
             // valid.
             // Note: It is impossible to correctly calculate a maxInputBlock if
             // any of the sequence locked inputs depend on unconfirmed txs,
             // except in the special case where the relative lock time/height is
             // 0, which is equivalent to no sequence lock. Since we assume input
             // height of tip+1 for mempool txs and test the resulting lockPair
             // from CalculateSequenceLocks against tip+1. We know
             // EvaluateSequenceLocks will fail if there was a non-zero sequence
             // lock on a mempool input, so we can use the return value of
             // CheckSequenceLocks to indicate the LockPoints validity.
             int maxInputHeight = 0;
             for (const int height : prevheights) {
                 // Can ignore mempool inputs since we'll fail if they had
                 // non-zero locks.
                 if (height != tip->nHeight + 1) {
                     maxInputHeight = std::max(maxInputHeight, height);
                 }
             }
             lp->maxInputBlock = tip->GetAncestor(maxInputHeight);
         }
     }
     return EvaluateSequenceLocks(index, lockPair);
 }
 
 // Command-line argument "-replayprotectionactivationtime=<timestamp>" will
 // cause the node to switch to replay protected SigHash ForkID value when the
 // median timestamp of the previous 11 blocks is greater than or equal to
 // <timestamp>. Defaults to the pre-defined timestamp when not set.
 static bool IsReplayProtectionEnabled(const Consensus::Params &params,
                                       int64_t nMedianTimePast) {
     return nMedianTimePast >= gArgs.GetArg("-replayprotectionactivationtime",
                                            params.axionActivationTime);
 }
 
 static bool IsReplayProtectionEnabled(const Consensus::Params &params,
                                       const CBlockIndex *pindexPrev) {
     if (pindexPrev == nullptr) {
         return false;
     }
 
     return IsReplayProtectionEnabled(params, pindexPrev->GetMedianTimePast());
 }
 
 // Returns the script flags which should be checked for mempool admission when
 // the tip is at the given block.
 static uint32_t GetStandardScriptFlags(const Consensus::Params &params,
                                        const CBlockIndex *pindexTip) {
     // Use the consensus flags for the next block as a basis, and mix in the
     // declared-standard flags.
     uint32_t flags = GetNextBlockScriptFlags(params, pindexTip) |
                      STANDARD_SCRIPT_VERIFY_FLAGS;
 
     // Disable input sigchecks limit for mempool admission, prior to its
     // proper activation.
     flags &= ~SCRIPT_VERIFY_INPUT_SIGCHECKS;
 
     if (IsPhononEnabled(params, pindexTip)) {
         flags |= SCRIPT_VERIFY_INPUT_SIGCHECKS;
     }
 
     return flags;
 }
 
 // Used to avoid mempool polluting consensus critical paths if CCoinsViewMempool
 // were somehow broken and returning the wrong scriptPubKeys
 static bool CheckInputsFromMempoolAndCache(
     const CTransaction &tx, CValidationState &state,
     const CCoinsViewCache &view, const CTxMemPool &pool, const uint32_t flags,
     bool cacheSigStore, PrecomputedTransactionData &txdata, int &nSigChecksOut)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
 
     // pool.cs should be locked already, but go ahead and re-take the lock here
     // to enforce that mempool doesn't change between when we check the view and
     // when we actually call through to CheckInputs
     LOCK(pool.cs);
 
     assert(!tx.IsCoinBase());
     for (const CTxIn &txin : tx.vin) {
         const Coin &coin = view.AccessCoin(txin.prevout);
 
         // At this point we haven't actually checked if the coins are all
         // available (or shouldn't assume we have, since CheckInputs does). So
         // we just return failure if the inputs are not available here, and then
         // only have to check equivalence for available inputs.
         if (coin.IsSpent()) {
             return false;
         }
 
         const CTransactionRef &txFrom = pool.get(txin.prevout.GetTxId());
         if (txFrom) {
             assert(txFrom->GetId() == txin.prevout.GetTxId());
             assert(txFrom->vout.size() > txin.prevout.GetN());
             assert(txFrom->vout[txin.prevout.GetN()] == coin.GetTxOut());
         } else {
             const Coin &coinFromDisk = pcoinsTip->AccessCoin(txin.prevout);
             assert(!coinFromDisk.IsSpent());
             assert(coinFromDisk.GetTxOut() == coin.GetTxOut());
         }
     }
 
     return CheckInputs(tx, state, view, true, flags, cacheSigStore, true,
                        txdata, nSigChecksOut);
 }
 
 static bool
 AcceptToMemoryPoolWorker(const Config &config, CTxMemPool &pool,
                          CValidationState &state, const CTransactionRef &ptx,
                          bool *pfMissingInputs, int64_t nAcceptTime,
                          bool bypass_limits, const Amount nAbsurdFee,
                          std::vector<COutPoint> &coins_to_uncache,
                          bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
 
     const Consensus::Params &consensusParams =
         config.GetChainParams().GetConsensus();
 
     const CTransaction &tx = *ptx;
     const TxId txid = tx.GetId();
 
     // mempool "read lock" (held through
     // GetMainSignals().TransactionAddedToMempool())
     LOCK(pool.cs);
     if (pfMissingInputs) {
         *pfMissingInputs = false;
     }
 
     // Coinbase is only valid in a block, not as a loose transaction.
     if (!CheckRegularTransaction(tx, state)) {
         // state filled in by CheckRegularTransaction.
         return false;
     }
 
     // Rather not work on nonstandard transactions (unless -testnet)
     std::string reason;
     if (fRequireStandard && !IsStandardTx(tx, reason)) {
         return state.DoS(0, false, REJECT_NONSTANDARD, reason);
     }
 
     // Only accept nLockTime-using transactions that can be mined in the next
     // block; we don't want our mempool filled up with transactions that can't
     // be mined yet.
     CValidationState ctxState;
     if (!ContextualCheckTransactionForCurrentBlock(
             consensusParams, tx, ctxState, STANDARD_LOCKTIME_VERIFY_FLAGS)) {
         // We copy the state from a dummy to ensure we don't increase the
         // ban score of peer for transaction that could be valid in the future.
         return state.DoS(
             0, false, REJECT_NONSTANDARD, ctxState.GetRejectReason(),
             ctxState.CorruptionPossible(), ctxState.GetDebugMessage());
     }
 
     // Is it already in the memory pool?
     if (pool.exists(txid)) {
         return state.Invalid(false, REJECT_DUPLICATE, "txn-already-in-mempool");
     }
 
     // Check for conflicts with in-memory transactions
     for (const CTxIn &txin : tx.vin) {
         auto itConflicting = pool.mapNextTx.find(txin.prevout);
         if (itConflicting != pool.mapNextTx.end()) {
             // Disable replacement feature for good
             return state.Invalid(false, REJECT_DUPLICATE,
                                  "txn-mempool-conflict");
         }
     }
 
     {
         CCoinsView dummy;
         CCoinsViewCache view(&dummy);
 
         LockPoints lp;
         CCoinsViewMemPool viewMemPool(pcoinsTip.get(), pool);
         view.SetBackend(viewMemPool);
 
         // Do all inputs exist?
         for (const CTxIn &txin : tx.vin) {
             if (!pcoinsTip->HaveCoinInCache(txin.prevout)) {
                 coins_to_uncache.push_back(txin.prevout);
             }
 
             if (!view.HaveCoin(txin.prevout)) {
                 // Are inputs missing because we already have the tx?
                 for (size_t out = 0; out < tx.vout.size(); out++) {
                     // Optimistically just do efficient check of cache for
                     // outputs.
                     if (pcoinsTip->HaveCoinInCache(COutPoint(txid, out))) {
                         return state.Invalid(false, REJECT_DUPLICATE,
                                              "txn-already-known");
                     }
                 }
 
                 // Otherwise assume this might be an orphan tx for which we just
                 // haven't seen parents yet.
                 if (pfMissingInputs) {
                     *pfMissingInputs = true;
                 }
 
                 // fMissingInputs and !state.IsInvalid() is used to detect this
                 // condition, don't set state.Invalid()
                 return false;
             }
         }
 
         // Are the actual inputs available?
         if (!view.HaveInputs(tx)) {
             return state.Invalid(false, REJECT_DUPLICATE,
                                  "bad-txns-inputs-spent");
         }
 
         // Bring the best block into scope.
         view.GetBestBlock();
 
         // We have all inputs cached now, so switch back to dummy, so we don't
         // need to keep lock on mempool.
         view.SetBackend(dummy);
 
         // Only accept BIP68 sequence locked transactions that can be mined in
         // the next block; we don't want our mempool filled up with transactions
         // that can't be mined yet. Must keep pool.cs for this unless we change
         // CheckSequenceLocks to take a CoinsViewCache instead of create its
         // own.
         if (!CheckSequenceLocks(pool, tx, STANDARD_LOCKTIME_VERIFY_FLAGS,
                                 &lp)) {
             return state.DoS(0, false, REJECT_NONSTANDARD, "non-BIP68-final");
         }
 
         Amount nFees = Amount::zero();
         if (!Consensus::CheckTxInputs(tx, state, view, GetSpendHeight(view),
                                       nFees)) {
             return error("%s: Consensus::CheckTxInputs: %s, %s", __func__,
                          tx.GetId().ToString(), FormatStateMessage(state));
         }
 
         const uint32_t nextBlockScriptVerifyFlags =
             GetNextBlockScriptFlags(consensusParams, ::ChainActive().Tip());
 
         // Check for non-standard pay-to-script-hash in inputs
         if (fRequireStandard &&
             !AreInputsStandard(tx, view, nextBlockScriptVerifyFlags)) {
             return state.Invalid(false, REJECT_NONSTANDARD,
                                  "bad-txns-nonstandard-inputs");
         }
 
         // nModifiedFees includes any fee deltas from PrioritiseTransaction
         Amount nModifiedFees = nFees;
         pool.ApplyDelta(txid, nModifiedFees);
 
         // Keep track of transactions that spend a coinbase, which we re-scan
         // during reorgs to ensure COINBASE_MATURITY is still met.
         bool fSpendsCoinbase = false;
         for (const CTxIn &txin : tx.vin) {
             const Coin &coin = view.AccessCoin(txin.prevout);
             if (coin.IsCoinBase()) {
                 fSpendsCoinbase = true;
                 break;
             }
         }
 
         unsigned int nSize = tx.GetTotalSize();
 
         // No transactions are allowed below minRelayTxFee except from
         // disconnected blocks.
         // Do not change this to use virtualsize without coordinating a network
         // policy upgrade.
         if (!bypass_limits && nModifiedFees < minRelayTxFee.GetFee(nSize)) {
             return state.DoS(0, false, REJECT_INSUFFICIENTFEE,
                              "min relay fee not met");
         }
 
         if (nAbsurdFee != Amount::zero() && nFees > nAbsurdFee) {
             return state.Invalid(false, REJECT_HIGHFEE, "absurdly-high-fee",
                                  strprintf("%d > %d", nFees, nAbsurdFee));
         }
 
         // Validate input scripts against standard script flags.
         const uint32_t scriptVerifyFlags =
             GetStandardScriptFlags(consensusParams, ::ChainActive().Tip());
         PrecomputedTransactionData txdata(tx);
         int nSigChecksStandard;
         if (!CheckInputs(tx, state, view, true, scriptVerifyFlags, true, false,
                          txdata, nSigChecksStandard)) {
             // State filled in by CheckInputs.
             return false;
         }
 
         CTxMemPoolEntry entry(ptx, nFees, nAcceptTime, ::ChainActive().Height(),
                               fSpendsCoinbase, nSigChecksStandard, lp);
 
         unsigned int nVirtualSize = entry.GetTxVirtualSize();
 
         Amount mempoolRejectFee =
             pool.GetMinFee(
                     gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) *
                     1000000)
                 .GetFee(nVirtualSize);
         if (!bypass_limits && mempoolRejectFee > Amount::zero() &&
             nModifiedFees < mempoolRejectFee) {
             return state.DoS(
                 0, false, REJECT_INSUFFICIENTFEE, "mempool min fee not met",
                 false, strprintf("%d < %d", nModifiedFees, mempoolRejectFee));
         }
 
         // Calculate in-mempool ancestors, up to a limit.
         CTxMemPool::setEntries setAncestors;
         size_t nLimitAncestors = gArgs.GetArg(
             "-limitancestorcount",
             GetDefaultAncestorLimit(consensusParams, ::ChainActive().Tip()));
         size_t nLimitAncestorSize =
             gArgs.GetArg("-limitancestorsize", DEFAULT_ANCESTOR_SIZE_LIMIT) *
             1000;
         size_t nLimitDescendants = gArgs.GetArg(
             "-limitdescendantcount",
             GetDefaultDescendantLimit(consensusParams, ::ChainActive().Tip()));
         size_t nLimitDescendantSize =
             gArgs.GetArg("-limitdescendantsize",
                          DEFAULT_DESCENDANT_SIZE_LIMIT) *
             1000;
         std::string errString;
         if (!pool.CalculateMemPoolAncestors(
                 entry, setAncestors, nLimitAncestors, nLimitAncestorSize,
                 nLimitDescendants, nLimitDescendantSize, errString)) {
             return state.DoS(0, false, REJECT_NONSTANDARD,
                              "too-long-mempool-chain", false, errString);
         }
 
         // Check again against the next block's script verification flags
         // to cache our script execution flags.
         //
         // This is also useful in case of bugs in the standard flags that cause
         // transactions to pass as valid when they're actually invalid. For
         // instance the STRICTENC flag was incorrectly allowing certain CHECKSIG
         // NOT scripts to pass, even though they were invalid.
         //
         // There is a similar check in CreateNewBlock() to prevent creating
         // invalid blocks (using TestBlockValidity), however allowing such
         // transactions into the mempool can be exploited as a DoS attack.
         int nSigChecksConsensus;
         if (!CheckInputsFromMempoolAndCache(tx, state, view, pool,
                                             nextBlockScriptVerifyFlags, true,
                                             txdata, nSigChecksConsensus)) {
             // This can occur under some circumstances, if the node receives an
             // unrequested tx which is invalid due to new consensus rules not
             // being activated yet (during IBD).
             return error("%s: BUG! PLEASE REPORT THIS! CheckInputs failed "
                          "against next-block but not STANDARD flags %s, %s",
                          __func__, txid.ToString(), FormatStateMessage(state));
         }
 
         if (nSigChecksStandard != nSigChecksConsensus) {
             // We can't accept this transaction as we've used the standard count
             // for the mempool/mining, but the consensus count will be enforced
             // in validation (we don't want to produce bad block templates).
             return error(
                 "%s: BUG! PLEASE REPORT THIS! SigChecks count differed between "
                 "standard and consensus flags in %s",
                 __func__, txid.ToString());
         }
 
         if (test_accept) {
             // Tx was accepted, but not added
             return true;
         }
 
         // Store transaction in memory.
         pool.addUnchecked(entry, setAncestors);
 
         // Trim mempool and check if tx was trimmed.
         if (!bypass_limits) {
             pool.LimitSize(
                 gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000,
                 gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 *
                     60);
             if (!pool.exists(txid)) {
                 return state.DoS(0, false, REJECT_INSUFFICIENTFEE,
                                  "mempool full");
             }
         }
     }
 
     GetMainSignals().TransactionAddedToMempool(ptx);
     return true;
 }
 
 /**
  * (try to) add transaction to memory pool with a specified acceptance time.
  */
 static bool
 AcceptToMemoryPoolWithTime(const Config &config, CTxMemPool &pool,
                            CValidationState &state, const CTransactionRef &tx,
                            bool *pfMissingInputs, int64_t nAcceptTime,
                            bool bypass_limits, const Amount nAbsurdFee,
                            bool test_accept) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
     std::vector<COutPoint> coins_to_uncache;
     bool res = AcceptToMemoryPoolWorker(
         config, pool, state, tx, pfMissingInputs, nAcceptTime, bypass_limits,
         nAbsurdFee, coins_to_uncache, test_accept);
     if (!res) {
         for (const COutPoint &outpoint : coins_to_uncache) {
             pcoinsTip->Uncache(outpoint);
         }
     }
 
     // After we've (potentially) uncached entries, ensure our coins cache is
     // still within its size limits
     CValidationState stateDummy;
     ::ChainstateActive().FlushStateToDisk(config.GetChainParams(), stateDummy,
                                           FlushStateMode::PERIODIC);
     return res;
 }
 
 bool AcceptToMemoryPool(const Config &config, CTxMemPool &pool,
                         CValidationState &state, const CTransactionRef &tx,
                         bool *pfMissingInputs, bool bypass_limits,
                         const Amount nAbsurdFee, bool test_accept) {
     return AcceptToMemoryPoolWithTime(config, pool, state, tx, pfMissingInputs,
                                       GetTime(), bypass_limits, nAbsurdFee,
                                       test_accept);
 }
 
 /**
  * Return transaction in txOut, and if it was found inside a block, its hash is
  * placed in hashBlock. If blockIndex is provided, the transaction is fetched
  * from the corresponding block.
  */
 bool GetTransaction(const TxId &txid, CTransactionRef &txOut,
                     const Consensus::Params &params, BlockHash &hashBlock,
                     const CBlockIndex *const block_index) {
     LOCK(cs_main);
 
     if (block_index == nullptr) {
         CTransactionRef ptx = g_mempool.get(txid);
         if (ptx) {
             txOut = ptx;
             return true;
         }
 
         if (g_txindex) {
             return g_txindex->FindTx(txid, hashBlock, txOut);
         }
     } else {
         CBlock block;
         if (ReadBlockFromDisk(block, block_index, params)) {
             for (const auto &tx : block.vtx) {
                 if (tx->GetId() == txid) {
                     txOut = tx;
                     hashBlock = block_index->GetBlockHash();
                     return true;
                 }
             }
         }
     }
 
     return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //
 // CBlock and CBlockIndex
 //
 
 static bool WriteBlockToDisk(const CBlock &block, FlatFilePos &pos,
                              const CMessageHeader::MessageMagic &messageStart) {
     // Open history file to append
     CAutoFile fileout(OpenBlockFile(pos), SER_DISK, CLIENT_VERSION);
     if (fileout.IsNull()) {
         return error("WriteBlockToDisk: OpenBlockFile failed");
     }
 
     // Write index header
     unsigned int nSize = GetSerializeSize(block, fileout.GetVersion());
     fileout << messageStart << nSize;
 
     // Write block
     long fileOutPos = ftell(fileout.Get());
     if (fileOutPos < 0) {
         return error("WriteBlockToDisk: ftell failed");
     }
 
     pos.nPos = (unsigned int)fileOutPos;
     fileout << block;
 
     return true;
 }
 
 bool ReadBlockFromDisk(CBlock &block, const FlatFilePos &pos,
                        const Consensus::Params &params) {
     block.SetNull();
 
     // Open history file to read
     CAutoFile filein(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION);
     if (filein.IsNull()) {
         return error("ReadBlockFromDisk: OpenBlockFile failed for %s",
                      pos.ToString());
     }
 
     // Read block
     try {
         filein >> block;
     } catch (const std::exception &e) {
         return error("%s: Deserialize or I/O error - %s at %s", __func__,
                      e.what(), pos.ToString());
     }
 
     // Check the header
     if (!CheckProofOfWork(block.GetHash(), block.nBits, params)) {
         return error("ReadBlockFromDisk: Errors in block header at %s",
                      pos.ToString());
     }
 
     return true;
 }
 
 bool ReadBlockFromDisk(CBlock &block, const CBlockIndex *pindex,
                        const Consensus::Params &params) {
     FlatFilePos blockPos;
     {
         LOCK(cs_main);
         blockPos = pindex->GetBlockPos();
     }
 
     if (!ReadBlockFromDisk(block, blockPos, params)) {
         return false;
     }
 
     if (block.GetHash() != pindex->GetBlockHash()) {
         return error("ReadBlockFromDisk(CBlock&, CBlockIndex*): GetHash() "
                      "doesn't match index for %s at %s",
                      pindex->ToString(), pindex->GetBlockPos().ToString());
     }
 
     return true;
 }
 
 Amount GetBlockSubsidy(int nHeight, const Consensus::Params &consensusParams) {
     int halvings = nHeight / consensusParams.nSubsidyHalvingInterval;
     // Force block reward to zero when right shift is undefined.
     if (halvings >= 64) {
         return Amount::zero();
     }
 
     Amount nSubsidy = 50 * COIN;
     // Subsidy is cut in half every 210,000 blocks which will occur
     // approximately every 4 years.
     return ((nSubsidy / SATOSHI) >> halvings) * SATOSHI;
 }
 
 // Note that though this is marked const, we may end up modifying
 // `m_cached_finished_ibd`, which is a performance-related implementation
 // detail. This function must be marked `const` so that `CValidationInterface`
 // clients (which are given a `const CChainState*`) can call it.
 //
 bool CChainState::IsInitialBlockDownload() const {
     // Optimization: pre-test latch before taking the lock.
     if (m_cached_finished_ibd.load(std::memory_order_relaxed)) {
         return false;
     }
 
     LOCK(cs_main);
     if (m_cached_finished_ibd.load(std::memory_order_relaxed)) {
         return false;
     }
     if (fImporting || fReindex) {
         return true;
     }
     if (m_chain.Tip() == nullptr) {
         return true;
     }
     if (m_chain.Tip()->nChainWork < nMinimumChainWork) {
         return true;
     }
     if (m_chain.Tip()->GetBlockTime() < (GetTime() - nMaxTipAge)) {
         return true;
     }
     LogPrintf("Leaving InitialBlockDownload (latching to false)\n");
     m_cached_finished_ibd.store(true, std::memory_order_relaxed);
     return false;
 }
 
 CBlockIndex const *pindexBestForkTip = nullptr;
 CBlockIndex const *pindexBestForkBase = nullptr;
 
 static void AlertNotify(const std::string &strMessage) {
     uiInterface.NotifyAlertChanged();
     std::string strCmd = gArgs.GetArg("-alertnotify", "");
     if (strCmd.empty()) {
         return;
     }
 
     // Alert text should be plain ascii coming from a trusted source, but to be
     // safe we first strip anything not in safeChars, then add single quotes
     // around the whole string before passing it to the shell:
     std::string singleQuote("'");
     std::string safeStatus = SanitizeString(strMessage);
     safeStatus = singleQuote + safeStatus + singleQuote;
     boost::replace_all(strCmd, "%s", safeStatus);
 
     std::thread t(runCommand, strCmd);
     // thread runs free
     t.detach();
 }
 
 static void CheckForkWarningConditions() EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
     // Before we get past initial download, we cannot reliably alert about forks
     // (we assume we don't get stuck on a fork before finishing our initial
     // sync)
     if (::ChainstateActive().IsInitialBlockDownload()) {
         return;
     }
 
     // If our best fork is no longer within 72 blocks (+/- 12 hours if no one
     // mines it) of our head, drop it
     if (pindexBestForkTip &&
         ::ChainActive().Height() - pindexBestForkTip->nHeight >= 72) {
         pindexBestForkTip = nullptr;
     }
 
     if (pindexBestForkTip ||
         (pindexBestInvalid &&
          pindexBestInvalid->nChainWork >
              ::ChainActive().Tip()->nChainWork +
                  (GetBlockProof(*::ChainActive().Tip()) * 6))) {
         if (!GetfLargeWorkForkFound() && pindexBestForkBase) {
             std::string warning =
                 std::string("'Warning: Large-work fork detected, forking after "
                             "block ") +
                 pindexBestForkBase->phashBlock->ToString() + std::string("'");
             AlertNotify(warning);
         }
 
         if (pindexBestForkTip && pindexBestForkBase) {
             LogPrintf("%s: Warning: Large fork found\n  forking the "
                       "chain at height %d (%s)\n  lasting to height %d "
                       "(%s).\nChain state database corruption likely.\n",
                       __func__, pindexBestForkBase->nHeight,
                       pindexBestForkBase->phashBlock->ToString(),
                       pindexBestForkTip->nHeight,
                       pindexBestForkTip->phashBlock->ToString());
             SetfLargeWorkForkFound(true);
         } else {
             LogPrintf("%s: Warning: Found invalid chain at least ~6 blocks "
                       "longer than our best chain.\nChain state database "
                       "corruption likely.\n",
                       __func__);
             SetfLargeWorkInvalidChainFound(true);
         }
     } else {
         SetfLargeWorkForkFound(false);
         SetfLargeWorkInvalidChainFound(false);
     }
 }
 
 static void CheckForkWarningConditionsOnNewFork(CBlockIndex *pindexNewForkTip)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
     // If we are on a fork that is sufficiently large, set a warning flag.
     const CBlockIndex *pfork = ::ChainActive().FindFork(pindexNewForkTip);
 
     // We define a condition where we should warn the user about as a fork of at
     // least 7 blocks with a tip within 72 blocks (+/- 12 hours if no one mines
     // it) of ours. We use 7 blocks rather arbitrarily as it represents just
     // under 10% of sustained network hash rate operating on the fork, or a
     // chain that is entirely longer than ours and invalid (note that this
     // should be detected by both). We define it this way because it allows us
     // to only store the highest fork tip (+ base) which meets the 7-block
     // condition and from this always have the most-likely-to-cause-warning fork
     if (pfork &&
         (!pindexBestForkTip ||
          pindexNewForkTip->nHeight > pindexBestForkTip->nHeight) &&
         pindexNewForkTip->nChainWork - pfork->nChainWork >
             (GetBlockProof(*pfork) * 7) &&
         ::ChainActive().Height() - pindexNewForkTip->nHeight < 72) {
         pindexBestForkTip = pindexNewForkTip;
         pindexBestForkBase = pfork;
     }
 
     CheckForkWarningConditions();
 }
 
 static void InvalidChainFound(CBlockIndex *pindexNew)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
     if (!pindexBestInvalid ||
         pindexNew->nChainWork > pindexBestInvalid->nChainWork) {
         pindexBestInvalid = pindexNew;
     }
 
     // If the invalid chain found is supposed to be finalized, we need to move
     // back the finalization point.
     if (IsBlockFinalized(pindexNew)) {
         pindexFinalized = pindexNew->pprev;
     }
 
     LogPrintf("%s: invalid block=%s  height=%d  log2_work=%.8g  date=%s\n",
               __func__, pindexNew->GetBlockHash().ToString(),
               pindexNew->nHeight,
               log(pindexNew->nChainWork.getdouble()) / log(2.0),
               FormatISO8601DateTime(pindexNew->GetBlockTime()));
     CBlockIndex *tip = ::ChainActive().Tip();
     assert(tip);
     LogPrintf("%s:  current best=%s  height=%d  log2_work=%.8g  date=%s\n",
               __func__, tip->GetBlockHash().ToString(),
               ::ChainActive().Height(),
               log(tip->nChainWork.getdouble()) / log(2.0),
               FormatISO8601DateTime(tip->GetBlockTime()));
 }
 
 void CChainState::InvalidBlockFound(CBlockIndex *pindex,
                                     const CValidationState &state) {
     if (!state.CorruptionPossible()) {
         pindex->nStatus = pindex->nStatus.withFailed();
         m_failed_blocks.insert(pindex);
         setDirtyBlockIndex.insert(pindex);
         InvalidChainFound(pindex);
     }
 }
 
 void SpendCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                 int nHeight) {
     // Mark inputs spent.
     if (tx.IsCoinBase()) {
         return;
     }
 
     txundo.vprevout.reserve(tx.vin.size());
     for (const CTxIn &txin : tx.vin) {
         txundo.vprevout.emplace_back();
         bool is_spent = view.SpendCoin(txin.prevout, &txundo.vprevout.back());
         assert(is_spent);
     }
 }
 
 void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, CTxUndo &txundo,
                  int nHeight) {
     SpendCoins(view, tx, txundo, nHeight);
     AddCoins(view, tx, nHeight);
 }
 
 void UpdateCoins(CCoinsViewCache &view, const CTransaction &tx, int nHeight) {
     // Mark inputs spent.
     if (!tx.IsCoinBase()) {
         for (const CTxIn &txin : tx.vin) {
             bool is_spent = view.SpendCoin(txin.prevout);
             assert(is_spent);
         }
     }
 
     // Add outputs.
     AddCoins(view, tx, nHeight);
 }
 
 bool CScriptCheck::operator()() {
     const CScript &scriptSig = ptxTo->vin[nIn].scriptSig;
     if (!VerifyScript(scriptSig, scriptPubKey, nFlags,
                       CachingTransactionSignatureChecker(ptxTo, nIn, amount,
                                                          cacheStore, txdata),
                       metrics, &error)) {
         return false;
     }
     if ((pTxLimitSigChecks &&
          !pTxLimitSigChecks->consume_and_check(metrics.nSigChecks)) ||
         (pBlockLimitSigChecks &&
          !pBlockLimitSigChecks->consume_and_check(metrics.nSigChecks))) {
         // we can't assign a meaningful script error (since the script
         // succeeded), but remove the ScriptError::OK which could be
         // misinterpreted.
         error = ScriptError::SIGCHECKS_LIMIT_EXCEEDED;
         return false;
     }
     return true;
 }
 
 int GetSpendHeight(const CCoinsViewCache &inputs) {
     LOCK(cs_main);
     CBlockIndex *pindexPrev = LookupBlockIndex(inputs.GetBestBlock());
     return pindexPrev->nHeight + 1;
 }
 
 bool CheckInputs(const CTransaction &tx, CValidationState &state,
                  const CCoinsViewCache &inputs, bool fScriptChecks,
                  const uint32_t flags, bool sigCacheStore,
                  bool scriptCacheStore,
                  const PrecomputedTransactionData &txdata, int &nSigChecksOut,
                  TxSigCheckLimiter &txLimitSigChecks,
                  CheckInputsLimiter *pBlockLimitSigChecks,
                  std::vector<CScriptCheck> *pvChecks) {
     AssertLockHeld(cs_main);
     assert(!tx.IsCoinBase());
 
     if (pvChecks) {
         pvChecks->reserve(tx.vin.size());
     }
 
     // Skip script verification when connecting blocks under the assumevalid
     // block. Assuming the assumevalid block is valid this is safe because
     // block merkle hashes are still computed and checked, of course, if an
     // assumed valid block is invalid due to false scriptSigs this optimization
     // would allow an invalid chain to be accepted.
     if (!fScriptChecks) {
         return true;
     }
 
     // First check if script executions have been cached with the same flags.
     // Note that this assumes that the inputs provided are correct (ie that the
     // transaction hash which is in tx's prevouts properly commits to the
     // scriptPubKey in the inputs view of that transaction).
     ScriptCacheKey hashCacheEntry(tx, flags);
     if (IsKeyInScriptCache(hashCacheEntry, !scriptCacheStore, nSigChecksOut)) {
         if (!txLimitSigChecks.consume_and_check(nSigChecksOut) ||
             (pBlockLimitSigChecks &&
              !pBlockLimitSigChecks->consume_and_check(nSigChecksOut))) {
             return state.Invalid(false, REJECT_NONSTANDARD,
                                  strprintf("too-many-sigchecks"));
         }
         return true;
     }
 
     int nSigChecksTotal = 0;
 
     for (size_t i = 0; i < tx.vin.size(); i++) {
         const COutPoint &prevout = tx.vin[i].prevout;
         const Coin &coin = inputs.AccessCoin(prevout);
         assert(!coin.IsSpent());
 
         // We very carefully only pass in things to CScriptCheck which are
         // clearly committed to by tx's hash. This provides a sanity
         // check that our caching is not introducing consensus failures through
         // additional data in, eg, the coins being spent being checked as a part
         // of CScriptCheck.
         const CScript &scriptPubKey = coin.GetTxOut().scriptPubKey;
         const Amount amount = coin.GetTxOut().nValue;
 
         // Verify signature
         CScriptCheck check(scriptPubKey, amount, tx, i, flags, sigCacheStore,
                            txdata, &txLimitSigChecks, pBlockLimitSigChecks);
         if (pvChecks) {
             pvChecks->push_back(std::move(check));
         } else if (!check()) {
             ScriptError scriptError = check.GetScriptError();
             // Compute flags without the optional standardness flags.
             // This differs from MANDATORY_SCRIPT_VERIFY_FLAGS as it contains
             // additional upgrade flags (see AcceptToMemoryPoolWorker variable
             // extraFlags).
             uint32_t mandatoryFlags =
                 flags & ~STANDARD_NOT_MANDATORY_VERIFY_FLAGS;
             if (flags != mandatoryFlags) {
                 // Check whether the failure was caused by a non-mandatory
                 // script verification check. If so, don't trigger DoS
                 // protection to avoid splitting the network on the basis of
                 // relay policy disagreements.
                 CScriptCheck check2(scriptPubKey, amount, tx, i, mandatoryFlags,
                                     sigCacheStore, txdata);
                 if (check2()) {
                     return state.Invalid(
                         false, REJECT_NONSTANDARD,
                         strprintf("non-mandatory-script-verify-flag (%s)",
                                   ScriptErrorString(scriptError)));
                 }
                 // update the error message to reflect the mandatory violation.
                 scriptError = check2.GetScriptError();
             }
 
-            // Before banning, we need to check whether the transaction would
-            // be valid on the other side of the upgrade, so as to avoid
-            // splitting the network between upgraded and non-upgraded nodes.
-            // Note that this will create strange error messages like
-            // "upgrade-conditional-script-failure (Opcode missing or not
-            // understood)".
-            CScriptCheck check3(scriptPubKey, amount, tx, i,
-                                mandatoryFlags ^ SCRIPT_ENABLE_OP_REVERSEBYTES,
-                                sigCacheStore, txdata);
-            if (check3()) {
-                return state.Invalid(
-                    false, REJECT_INVALID,
-                    strprintf("upgrade-conditional-script-failure (%s)",
-                              ScriptErrorString(check.GetScriptError())));
-            }
-
             // Failures of other flags indicate a transaction that is invalid in
             // new blocks, e.g. a invalid P2SH. We DoS ban such nodes as they
             // are not following the protocol. That said during an upgrade
             // careful thought should be taken as to the correct behavior - we
             // may want to continue peering with non-upgraded nodes even after
             // soft-fork super-majority signaling has occurred.
             return state.DoS(
                 100, false, REJECT_INVALID,
                 strprintf("mandatory-script-verify-flag-failed (%s)",
                           ScriptErrorString(scriptError)));
         }
 
         nSigChecksTotal += check.GetScriptExecutionMetrics().nSigChecks;
     }
 
     nSigChecksOut = nSigChecksTotal;
 
     if (scriptCacheStore && !pvChecks) {
         // We executed all of the provided scripts, and were told to cache the
         // result. Do so now.
         AddKeyInScriptCache(hashCacheEntry, nSigChecksTotal);
     }
 
     return true;
 }
 
 namespace {
 
 bool UndoWriteToDisk(const CBlockUndo &blockundo, FlatFilePos &pos,
                      const uint256 &hashBlock,
                      const CMessageHeader::MessageMagic &messageStart) {
     // Open history file to append
     CAutoFile fileout(OpenUndoFile(pos), SER_DISK, CLIENT_VERSION);
     if (fileout.IsNull()) {
         return error("%s: OpenUndoFile failed", __func__);
     }
 
     // Write index header
     unsigned int nSize = GetSerializeSize(blockundo, fileout.GetVersion());
     fileout << messageStart << nSize;
 
     // Write undo data
     long fileOutPos = ftell(fileout.Get());
     if (fileOutPos < 0) {
         return error("%s: ftell failed", __func__);
     }
     pos.nPos = (unsigned int)fileOutPos;
     fileout << blockundo;
 
     // calculate & write checksum
     CHashWriter hasher(SER_GETHASH, PROTOCOL_VERSION);
     hasher << hashBlock;
     hasher << blockundo;
     fileout << hasher.GetHash();
 
     return true;
 }
 
 static bool UndoReadFromDisk(CBlockUndo &blockundo, const CBlockIndex *pindex) {
     FlatFilePos pos = pindex->GetUndoPos();
     if (pos.IsNull()) {
         return error("%s: no undo data available", __func__);
     }
 
     // Open history file to read
     CAutoFile filein(OpenUndoFile(pos, true), SER_DISK, CLIENT_VERSION);
     if (filein.IsNull()) {
         return error("%s: OpenUndoFile failed", __func__);
     }
 
     // Read block
     uint256 hashChecksum;
     // We need a CHashVerifier as reserializing may lose data
     CHashVerifier<CAutoFile> verifier(&filein);
     try {
         verifier << pindex->pprev->GetBlockHash();
         verifier >> blockundo;
         filein >> hashChecksum;
     } catch (const std::exception &e) {
         return error("%s: Deserialize or I/O error - %s", __func__, e.what());
     }
 
     // Verify checksum
     if (hashChecksum != verifier.GetHash()) {
         return error("%s: Checksum mismatch", __func__);
     }
 
     return true;
 }
 
 /** Abort with a message */
 static bool AbortNode(const std::string &strMessage,
                       const std::string &userMessage = "") {
     SetMiscWarning(strMessage);
     LogPrintf("*** %s\n", strMessage);
     uiInterface.ThreadSafeMessageBox(
         userMessage.empty() ? _("Error: A fatal internal error occurred, see "
                                 "debug.log for details")
                                   .translated
                             : userMessage,
         "", CClientUIInterface::MSG_ERROR);
     StartShutdown();
     return false;
 }
 
 static bool AbortNode(CValidationState &state, const std::string &strMessage,
                       const std::string &userMessage = "") {
     AbortNode(strMessage, userMessage);
     return state.Error(strMessage);
 }
 
 } // namespace
 
 /** Restore the UTXO in a Coin at a given COutPoint. */
 DisconnectResult UndoCoinSpend(const Coin &undo, CCoinsViewCache &view,
                                const COutPoint &out) {
     bool fClean = true;
 
     if (view.HaveCoin(out)) {
         // Overwriting transaction output.
         fClean = false;
     }
 
     if (undo.GetHeight() == 0) {
         // Missing undo metadata (height and coinbase). Older versions included
         // this information only in undo records for the last spend of a
         // transactions' outputs. This implies that it must be present for some
         // other output of the same tx.
         const Coin &alternate = AccessByTxid(view, out.GetTxId());
         if (alternate.IsSpent()) {
             // Adding output for transaction without known metadata
             return DisconnectResult::FAILED;
         }
 
         // This is somewhat ugly, but hopefully utility is limited. This is only
         // useful when working from legacy on disck data. In any case, putting
         // the correct information in there doesn't hurt.
         const_cast<Coin &>(undo) = Coin(undo.GetTxOut(), alternate.GetHeight(),
                                         alternate.IsCoinBase());
     }
 
     // The potential_overwrite parameter to AddCoin is only allowed to be false
     // if we know for sure that the coin did not already exist in the cache. As
     // we have queried for that above using HaveCoin, we don't need to guess.
     // When fClean is false, a coin already existed and it is an overwrite.
     view.AddCoin(out, std::move(undo), !fClean);
 
     return fClean ? DisconnectResult::OK : DisconnectResult::UNCLEAN;
 }
 
 /**
  * Undo the effects of this block (with given index) on the UTXO set represented
  * by coins. When FAILED is returned, view is left in an indeterminate state.
  */
 DisconnectResult CChainState::DisconnectBlock(const CBlock &block,
                                               const CBlockIndex *pindex,
                                               CCoinsViewCache &view) {
     CBlockUndo blockUndo;
     if (!UndoReadFromDisk(blockUndo, pindex)) {
         error("DisconnectBlock(): failure reading undo data");
         return DisconnectResult::FAILED;
     }
 
     return ApplyBlockUndo(blockUndo, block, pindex, view);
 }
 
 DisconnectResult ApplyBlockUndo(const CBlockUndo &blockUndo,
                                 const CBlock &block, const CBlockIndex *pindex,
                                 CCoinsViewCache &view) {
     bool fClean = true;
 
     if (blockUndo.vtxundo.size() + 1 != block.vtx.size()) {
         error("DisconnectBlock(): block and undo data inconsistent");
         return DisconnectResult::FAILED;
     }
 
     // First, restore inputs.
     for (size_t i = 1; i < block.vtx.size(); i++) {
         const CTransaction &tx = *(block.vtx[i]);
         const CTxUndo &txundo = blockUndo.vtxundo[i - 1];
         if (txundo.vprevout.size() != tx.vin.size()) {
             error("DisconnectBlock(): transaction and undo data inconsistent");
             return DisconnectResult::FAILED;
         }
 
         for (size_t j = 0; j < tx.vin.size(); j++) {
             const COutPoint &out = tx.vin[j].prevout;
             const Coin &undo = txundo.vprevout[j];
             DisconnectResult res = UndoCoinSpend(undo, view, out);
             if (res == DisconnectResult::FAILED) {
                 return DisconnectResult::FAILED;
             }
             fClean = fClean && res != DisconnectResult::UNCLEAN;
         }
     }
 
     // Second, revert created outputs.
     for (const auto &ptx : block.vtx) {
         const CTransaction &tx = *ptx;
         const TxId &txid = tx.GetId();
         const bool is_coinbase = tx.IsCoinBase();
 
         // Check that all outputs are available and match the outputs in the
         // block itself exactly.
         for (size_t o = 0; o < tx.vout.size(); o++) {
             if (tx.vout[o].scriptPubKey.IsUnspendable()) {
                 continue;
             }
 
             COutPoint out(txid, o);
             Coin coin;
             bool is_spent = view.SpendCoin(out, &coin);
             if (!is_spent || tx.vout[o] != coin.GetTxOut() ||
                 uint32_t(pindex->nHeight) != coin.GetHeight() ||
                 is_coinbase != coin.IsCoinBase()) {
                 // transaction output mismatch
                 fClean = false;
             }
         }
     }
 
     // Move best block pointer to previous block.
     view.SetBestBlock(block.hashPrevBlock);
 
     return fClean ? DisconnectResult::OK : DisconnectResult::UNCLEAN;
 }
 
 static void FlushBlockFile(bool fFinalize = false) {
     LOCK(cs_LastBlockFile);
 
     FlatFilePos block_pos_old(nLastBlockFile,
                               vinfoBlockFile[nLastBlockFile].nSize);
     FlatFilePos undo_pos_old(nLastBlockFile,
                              vinfoBlockFile[nLastBlockFile].nUndoSize);
 
     bool status = true;
     status &= BlockFileSeq().Flush(block_pos_old, fFinalize);
     status &= UndoFileSeq().Flush(undo_pos_old, fFinalize);
     if (!status) {
         AbortNode("Flushing block file to disk failed. This is likely the "
                   "result of an I/O error.");
     }
 }
 
 static bool FindUndoPos(CValidationState &state, int nFile, FlatFilePos &pos,
                         unsigned int nAddSize);
 
 static bool WriteUndoDataForBlock(const CBlockUndo &blockundo,
                                   CValidationState &state, CBlockIndex *pindex,
                                   const CChainParams &chainparams) {
     // Write undo information to disk
     if (pindex->GetUndoPos().IsNull()) {
         FlatFilePos _pos;
         if (!FindUndoPos(state, pindex->nFile, _pos,
                          ::GetSerializeSize(blockundo, CLIENT_VERSION) + 40)) {
             return error("ConnectBlock(): FindUndoPos failed");
         }
         if (!UndoWriteToDisk(blockundo, _pos, pindex->pprev->GetBlockHash(),
                              chainparams.DiskMagic())) {
             return AbortNode(state, "Failed to write undo data");
         }
 
         // update nUndoPos in block index
         pindex->nUndoPos = _pos.nPos;
         pindex->nStatus = pindex->nStatus.withUndo();
         setDirtyBlockIndex.insert(pindex);
     }
 
     return true;
 }
 
 static CCheckQueue<CScriptCheck> scriptcheckqueue(128);
 
 void ThreadScriptCheck(int worker_num) {
     util::ThreadRename(strprintf("scriptch.%i", worker_num));
     scriptcheckqueue.Thread();
 }
 
 VersionBitsCache versionbitscache GUARDED_BY(cs_main);
 
 int32_t ComputeBlockVersion(const CBlockIndex *pindexPrev,
                             const Consensus::Params &params) {
     LOCK(cs_main);
     int32_t nVersion = VERSIONBITS_TOP_BITS;
 
     for (int i = 0; i < (int)Consensus::MAX_VERSION_BITS_DEPLOYMENTS; i++) {
         ThresholdState state = VersionBitsState(
             pindexPrev, params, static_cast<Consensus::DeploymentPos>(i),
             versionbitscache);
         if (state == ThresholdState::LOCKED_IN ||
             state == ThresholdState::STARTED) {
             nVersion |= VersionBitsMask(
                 params, static_cast<Consensus::DeploymentPos>(i));
         }
     }
 
     // Clear the last 4 bits (miner fund activation).
     return nVersion & ~uint32_t(0x0f);
 }
 
 // Returns the script flags which should be checked for the block after
 // the given block.
 static uint32_t GetNextBlockScriptFlags(const Consensus::Params &params,
                                         const CBlockIndex *pindex) {
     uint32_t flags = SCRIPT_VERIFY_NONE;
 
     // Start enforcing P2SH (BIP16)
     if ((pindex->nHeight + 1) >= params.BIP16Height) {
         flags |= SCRIPT_VERIFY_P2SH;
     }
 
     // Start enforcing the DERSIG (BIP66) rule.
     if ((pindex->nHeight + 1) >= params.BIP66Height) {
         flags |= SCRIPT_VERIFY_DERSIG;
     }
 
     // Start enforcing CHECKLOCKTIMEVERIFY (BIP65) rule.
     if ((pindex->nHeight + 1) >= params.BIP65Height) {
         flags |= SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY;
     }
 
     // Start enforcing CSV (BIP68, BIP112 and BIP113) rule.
     if ((pindex->nHeight + 1) >= params.CSVHeight) {
         flags |= SCRIPT_VERIFY_CHECKSEQUENCEVERIFY;
     }
 
     // If the UAHF is enabled, we start accepting replay protected txns
     if (IsUAHFenabled(params, pindex)) {
         flags |= SCRIPT_VERIFY_STRICTENC;
         flags |= SCRIPT_ENABLE_SIGHASH_FORKID;
     }
 
     // If the DAA HF is enabled, we start rejecting transaction that use a high
     // s in their signature. We also make sure that signature that are supposed
     // to fail (for instance in multisig or other forms of smart contracts) are
     // null.
     if (IsDAAEnabled(params, pindex)) {
         flags |= SCRIPT_VERIFY_LOW_S;
         flags |= SCRIPT_VERIFY_NULLFAIL;
     }
 
     // When the magnetic anomaly fork is enabled, we start accepting
     // transactions using the OP_CHECKDATASIG opcode and it's verify
     // alternative. We also start enforcing push only signatures and
     // clean stack.
     if (IsMagneticAnomalyEnabled(params, pindex)) {
         flags |= SCRIPT_VERIFY_CHECKDATASIG_SIGOPS;
         flags |= SCRIPT_VERIFY_SIGPUSHONLY;
         flags |= SCRIPT_VERIFY_CLEANSTACK;
     }
 
     if (IsGravitonEnabled(params, pindex)) {
         flags |= SCRIPT_ENABLE_SCHNORR_MULTISIG;
         flags |= SCRIPT_VERIFY_MINIMALDATA;
     }
 
     if (IsPhononEnabled(params, pindex)) {
-        flags |= SCRIPT_ENABLE_OP_REVERSEBYTES;
         flags |= SCRIPT_REPORT_SIGCHECKS;
     }
 
     // We make sure this node will have replay protection during the next hard
     // fork.
     if (IsReplayProtectionEnabled(params, pindex)) {
         flags |= SCRIPT_ENABLE_REPLAY_PROTECTION;
     }
 
     return flags;
 }
 
 static int64_t nTimeCheck = 0;
 static int64_t nTimeForks = 0;
 static int64_t nTimeVerify = 0;
 static int64_t nTimeConnect = 0;
 static int64_t nTimeIndex = 0;
 static int64_t nTimeCallbacks = 0;
 static int64_t nTimeTotal = 0;
 static int64_t nBlocksTotal = 0;
 
 /**
  * Apply the effects of this block (with given index) on the UTXO set
  * represented by coins. Validity checks that depend on the UTXO set are also
  * done; ConnectBlock() can fail if those validity checks fail (among other
  * reasons).
  */
 bool CChainState::ConnectBlock(const CBlock &block, CValidationState &state,
                                CBlockIndex *pindex, CCoinsViewCache &view,
                                const CChainParams &params,
                                BlockValidationOptions options,
                                bool fJustCheck) {
     AssertLockHeld(cs_main);
     assert(pindex);
     assert(*pindex->phashBlock == block.GetHash());
     int64_t nTimeStart = GetTimeMicros();
 
     const Consensus::Params &consensusParams = params.GetConsensus();
 
     // Check it again in case a previous version let a bad block in
     // NOTE: We don't currently (re-)invoke ContextualCheckBlock() or
     // ContextualCheckBlockHeader() here. This means that if we add a new
     // consensus rule that is enforced in one of those two functions, then we
     // may have let in a block that violates the rule prior to updating the
     // software, and we would NOT be enforcing the rule here. Fully solving
     // upgrade from one software version to the next after a consensus rule
     // change is potentially tricky and issue-specific.
     // Also, currently the rule against blocks more than 2 hours in the future
     // is enforced in ContextualCheckBlockHeader(); we wouldn't want to
     // re-enforce that rule here (at least until we make it impossible for
     // GetAdjustedTime() to go backward).
     if (!CheckBlock(block, state, consensusParams,
                     options.withCheckPoW(!fJustCheck)
                         .withCheckMerkleRoot(!fJustCheck))) {
         if (state.CorruptionPossible()) {
             // We don't write down blocks to disk if they may have been
             // corrupted, so this should be impossible unless we're having
             // hardware problems.
             return AbortNode(state, "Corrupt block found indicating potential "
                                     "hardware failure; shutting down");
         }
         return error("%s: Consensus::CheckBlock: %s", __func__,
                      FormatStateMessage(state));
     }
 
     // Verify that the view's current state corresponds to the previous block
     BlockHash hashPrevBlock =
         pindex->pprev == nullptr ? BlockHash() : pindex->pprev->GetBlockHash();
     assert(hashPrevBlock == view.GetBestBlock());
 
     // Special case for the genesis block, skipping connection of its
     // transactions (its coinbase is unspendable)
     if (block.GetHash() == consensusParams.hashGenesisBlock) {
         if (!fJustCheck) {
             view.SetBestBlock(pindex->GetBlockHash());
         }
 
         return true;
     }
 
     nBlocksTotal++;
 
     bool fScriptChecks = true;
     if (!hashAssumeValid.IsNull()) {
         // We've been configured with the hash of a block which has been
         // externally verified to have a valid history. A suitable default value
         // is included with the software and updated from time to time. Because
         // validity relative to a piece of software is an objective fact these
         // defaults can be easily reviewed. This setting doesn't force the
         // selection of any particular chain but makes validating some faster by
         // effectively caching the result of part of the verification.
         BlockMap::const_iterator it = mapBlockIndex.find(hashAssumeValid);
         if (it != mapBlockIndex.end()) {
             if (it->second->GetAncestor(pindex->nHeight) == pindex &&
                 pindexBestHeader->GetAncestor(pindex->nHeight) == pindex &&
                 pindexBestHeader->nChainWork >= nMinimumChainWork) {
                 // This block is a member of the assumed verified chain and an
                 // ancestor of the best header. The equivalent time check
                 // discourages hash power from extorting the network via DOS
                 // attack into accepting an invalid block through telling users
                 // they must manually set assumevalid. Requiring a software
                 // change or burying the invalid block, regardless of the
                 // setting, makes it hard to hide the implication of the demand.
                 // This also avoids having release candidates that are hardly
                 // doing any signature verification at all in testing without
                 // having to artificially set the default assumed verified block
                 // further back. The test against nMinimumChainWork prevents the
                 // skipping when denied access to any chain at least as good as
                 // the expected chain.
                 fScriptChecks =
                     (GetBlockProofEquivalentTime(
                          *pindexBestHeader, *pindex, *pindexBestHeader,
                          consensusParams) <= 60 * 60 * 24 * 7 * 2);
             }
         }
     }
 
     int64_t nTime1 = GetTimeMicros();
     nTimeCheck += nTime1 - nTimeStart;
     LogPrint(BCLog::BENCH, "    - Sanity checks: %.2fms [%.2fs (%.2fms/blk)]\n",
              MILLI * (nTime1 - nTimeStart), nTimeCheck * MICRO,
              nTimeCheck * MILLI / nBlocksTotal);
 
     // Do not allow blocks that contain transactions which 'overwrite' older
     // transactions, unless those are already completely spent. If such
     // overwrites are allowed, coinbases and transactions depending upon those
     // can be duplicated to remove the ability to spend the first instance --
     // even after being sent to another address. See BIP30 and
     // http://r6.ca/blog/20120206T005236Z.html for more information. This logic
     // is not necessary for memory pool transactions, as AcceptToMemoryPool
     // already refuses previously-known transaction ids entirely. This rule was
     // originally applied to all blocks with a timestamp after March 15, 2012,
     // 0:00 UTC. Now that the whole chain is irreversibly beyond that time it is
     // applied to all blocks except the two in the chain that violate it. This
     // prevents exploiting the issue against nodes during their initial block
     // download.
     bool fEnforceBIP30 = !((pindex->nHeight == 91842 &&
                             pindex->GetBlockHash() ==
                                 uint256S("0x00000000000a4d0a398161ffc163c503763"
                                          "b1f4360639393e0e4c8e300e0caec")) ||
                            (pindex->nHeight == 91880 &&
                             pindex->GetBlockHash() ==
                                 uint256S("0x00000000000743f190a18c5577a3c2d2a1f"
                                          "610ae9601ac046a38084ccb7cd721")));
 
     // Once BIP34 activated it was not possible to create new duplicate
     // coinbases and thus other than starting with the 2 existing duplicate
     // coinbase pairs, not possible to create overwriting txs. But by the time
     // BIP34 activated, in each of the existing pairs the duplicate coinbase had
     // overwritten the first before the first had been spent. Since those
     // coinbases are sufficiently buried it's no longer possible to create
     // further duplicate transactions descending from the known pairs either. If
     // we're on the known chain at height greater than where BIP34 activated, we
     // can save the db accesses needed for the BIP30 check.
     assert(pindex->pprev);
     CBlockIndex *pindexBIP34height =
         pindex->pprev->GetAncestor(consensusParams.BIP34Height);
     // Only continue to enforce if we're below BIP34 activation height or the
     // block hash at that height doesn't correspond.
     fEnforceBIP30 =
         fEnforceBIP30 &&
         (!pindexBIP34height ||
          !(pindexBIP34height->GetBlockHash() == consensusParams.BIP34Hash));
 
     if (fEnforceBIP30) {
         for (const auto &tx : block.vtx) {
             for (size_t o = 0; o < tx->vout.size(); o++) {
                 if (view.HaveCoin(COutPoint(tx->GetId(), o))) {
                     return state.DoS(
                         100,
                         error("ConnectBlock(): tried to overwrite transaction"),
                         REJECT_INVALID, "bad-txns-BIP30");
                 }
             }
         }
     }
 
     // Start enforcing BIP68 (sequence locks).
     int nLockTimeFlags = 0;
     if (pindex->nHeight >= consensusParams.CSVHeight) {
         nLockTimeFlags |= LOCKTIME_VERIFY_SEQUENCE;
     }
 
     const uint32_t flags =
         GetNextBlockScriptFlags(consensusParams, pindex->pprev);
 
     int64_t nTime2 = GetTimeMicros();
     nTimeForks += nTime2 - nTime1;
     LogPrint(BCLog::BENCH, "    - Fork checks: %.2fms [%.2fs (%.2fms/blk)]\n",
              MILLI * (nTime2 - nTime1), nTimeForks * MICRO,
              nTimeForks * MILLI / nBlocksTotal);
 
     std::vector<int> prevheights;
     Amount nFees = Amount::zero();
     int nInputs = 0;
 
     // Limit the total executed signature operations in the block, a consensus
     // rule. Tracking during the CPU-consuming part (validation of uncached
     // inputs) is per-input atomic and validation in each thread stops very
     // quickly after the limit is exceeded, so an adversary cannot cause us to
     // exceed the limit by much at all.
     CheckInputsLimiter nSigChecksBlockLimiter(
         GetMaxBlockSigChecksCount(options.getExcessiveBlockSize()));
 
     std::vector<TxSigCheckLimiter> nSigChecksTxLimiters;
     nSigChecksTxLimiters.resize(block.vtx.size() - 1);
 
     CBlockUndo blockundo;
     blockundo.vtxundo.resize(block.vtx.size() - 1);
 
     CCheckQueueControl<CScriptCheck> control(fScriptChecks ? &scriptcheckqueue
                                                            : nullptr);
 
     // Add all outputs
     try {
         for (const auto &ptx : block.vtx) {
             AddCoins(view, *ptx, pindex->nHeight);
         }
     } catch (const std::logic_error &e) {
         // This error will be thrown from AddCoin if we try to connect a block
         // containing duplicate transactions. Such a thing should normally be
         // caught early nowadays (due to ContextualCheckBlock's CTOR
         // enforcement) however some edge cases can escape that:
         // - ContextualCheckBlock does not get re-run after saving the block to
         // disk, and older versions may have saved a weird block.
         // - its checks are not applied to pre-CTOR chains, which we might visit
         // with checkpointing off.
         return state.DoS(
             100, error("ConnectBlock(): tried to overwrite transaction"),
             REJECT_INVALID, "tx-duplicate");
     }
 
     size_t txIndex = 0;
     for (const auto &ptx : block.vtx) {
         const CTransaction &tx = *ptx;
         const bool isCoinBase = tx.IsCoinBase();
         nInputs += tx.vin.size();
 
         Amount txfee = Amount::zero();
         if (!isCoinBase && !Consensus::CheckTxInputs(tx, state, view,
                                                      pindex->nHeight, txfee)) {
             return error("%s: Consensus::CheckTxInputs: %s, %s", __func__,
                          tx.GetId().ToString(), FormatStateMessage(state));
         }
         nFees += txfee;
         if (!MoneyRange(nFees)) {
             return state.DoS(
                 100,
                 error("%s: accumulated fee in the block out of range.",
                       __func__),
                 REJECT_INVALID, "bad-txns-accumulated-fee-outofrange");
         }
 
         // The following checks do not apply to the coinbase.
         if (isCoinBase) {
             continue;
         }
 
         // Check that transaction is BIP68 final BIP68 lock checks (as
         // opposed to nLockTime checks) must be in ConnectBlock because they
         // require the UTXO set.
         prevheights.resize(tx.vin.size());
         for (size_t j = 0; j < tx.vin.size(); j++) {
             prevheights[j] = view.AccessCoin(tx.vin[j].prevout).GetHeight();
         }
 
         if (!SequenceLocks(tx, nLockTimeFlags, &prevheights, *pindex)) {
             return state.DoS(
                 100,
                 error("%s: contains a non-BIP68-final transaction", __func__),
                 REJECT_INVALID, "bad-txns-nonfinal");
         }
 
         // Don't cache results if we're actually connecting blocks (still
         // consult the cache, though).
         bool fCacheResults = fJustCheck;
 
         std::vector<CScriptCheck> vChecks;
         // nSigChecksRet may be accurate (found in cache) or 0 (checks were
         // deferred into vChecks).
         int nSigChecksRet;
         if (!CheckInputs(tx, state, view, fScriptChecks, flags, fCacheResults,
                          fCacheResults, PrecomputedTransactionData(tx),
                          nSigChecksRet, nSigChecksTxLimiters.at(txIndex),
                          &nSigChecksBlockLimiter, &vChecks)) {
             // Parallel CheckInputs shouldn't fail except for this reason, which
             // is banworthy. Use "blk-bad-inputs" to mimic the parallel script
             // check error.
             if (!nSigChecksBlockLimiter.check()) {
                 return state.DoS(100, false, REJECT_INVALID, "blk-bad-inputs",
                                  false, "CheckInputs exceeded SigChecks limit");
             }
             return error("ConnectBlock(): CheckInputs on %s failed with %s",
                          tx.GetId().ToString(), FormatStateMessage(state));
         }
 
         control.Add(vChecks);
 
         // Note: this must execute in the same iteration as CheckTxInputs (not
         // in a separate loop) in order to detect double spends. However,
         // this does not prevent double-spending by duplicated transaction
         // inputs in the same transaction (cf. CVE-2018-17144) -- that check is
         // done in CheckBlock (CheckRegularTransaction).
         SpendCoins(view, tx, blockundo.vtxundo.at(txIndex), pindex->nHeight);
         txIndex++;
     }
 
     int64_t nTime3 = GetTimeMicros();
     nTimeConnect += nTime3 - nTime2;
     LogPrint(BCLog::BENCH,
              "      - Connect %u transactions: %.2fms (%.3fms/tx, %.3fms/txin) "
              "[%.2fs (%.2fms/blk)]\n",
              (unsigned)block.vtx.size(), MILLI * (nTime3 - nTime2),
              MILLI * (nTime3 - nTime2) / block.vtx.size(),
              nInputs <= 1 ? 0 : MILLI * (nTime3 - nTime2) / (nInputs - 1),
              nTimeConnect * MICRO, nTimeConnect * MILLI / nBlocksTotal);
 
     Amount blockReward =
         nFees + GetBlockSubsidy(pindex->nHeight, consensusParams);
     if (block.vtx[0]->GetValueOut() > blockReward) {
         return state.DoS(100,
                          error("ConnectBlock(): coinbase pays too much "
                                "(actual=%d vs limit=%d)",
                                block.vtx[0]->GetValueOut(), blockReward),
                          REJECT_INVALID, "bad-cb-amount");
     }
 
     const std::vector<CTxDestination> whitelist =
         GetMinerFundWhitelist(consensusParams, pindex->pprev);
     if (!whitelist.empty()) {
         const Amount required = blockReward / MINER_FUND_RATIO;
 
         for (auto &o : block.vtx[0]->vout) {
             if (o.nValue < required) {
                 // This output doesn't qualify because its amount is too low.
                 continue;
             }
 
             CTxDestination address;
             if (!ExtractDestination(o.scriptPubKey, address)) {
                 // Cannot decode address.
                 continue;
             }
 
             if (std::find(whitelist.begin(), whitelist.end(), address) !=
                 whitelist.end()) {
                 goto MinerFundSuccess;
             }
         }
 
         // We did not find an output that match the miner fund requirements.
         return state.DoS(100, false, REJECT_INVALID, "bad-cb-minerfund");
     }
 
 MinerFundSuccess:
 
     if (!control.Wait()) {
         return state.DoS(100, false, REJECT_INVALID, "blk-bad-inputs", false,
                          "parallel script check failed");
     }
 
     int64_t nTime4 = GetTimeMicros();
     nTimeVerify += nTime4 - nTime2;
     LogPrint(
         BCLog::BENCH,
         "    - Verify %u txins: %.2fms (%.3fms/txin) [%.2fs (%.2fms/blk)]\n",
         nInputs - 1, MILLI * (nTime4 - nTime2),
         nInputs <= 1 ? 0 : MILLI * (nTime4 - nTime2) / (nInputs - 1),
         nTimeVerify * MICRO, nTimeVerify * MILLI / nBlocksTotal);
 
     if (fJustCheck) {
         return true;
     }
 
     if (!WriteUndoDataForBlock(blockundo, state, pindex, params)) {
         return false;
     }
 
     if (!pindex->IsValid(BlockValidity::SCRIPTS)) {
         pindex->RaiseValidity(BlockValidity::SCRIPTS);
         setDirtyBlockIndex.insert(pindex);
     }
 
     assert(pindex->phashBlock);
     // add this block to the view's block chain
     view.SetBestBlock(pindex->GetBlockHash());
 
     int64_t nTime5 = GetTimeMicros();
     nTimeIndex += nTime5 - nTime4;
     LogPrint(BCLog::BENCH, "    - Index writing: %.2fms [%.2fs (%.2fms/blk)]\n",
              MILLI * (nTime5 - nTime4), nTimeIndex * MICRO,
              nTimeIndex * MILLI / nBlocksTotal);
 
     int64_t nTime6 = GetTimeMicros();
     nTimeCallbacks += nTime6 - nTime5;
     LogPrint(BCLog::BENCH, "    - Callbacks: %.2fms [%.2fs (%.2fms/blk)]\n",
              MILLI * (nTime6 - nTime5), nTimeCallbacks * MICRO,
              nTimeCallbacks * MILLI / nBlocksTotal);
 
     return true;
 }
 
 bool CChainState::FlushStateToDisk(const CChainParams &chainparams,
                                    CValidationState &state, FlushStateMode mode,
                                    int nManualPruneHeight) {
     int64_t nMempoolUsage = g_mempool.DynamicMemoryUsage();
     LOCK(cs_main);
     static int64_t nLastWrite = 0;
     static int64_t nLastFlush = 0;
     std::set<int> setFilesToPrune;
     bool full_flush_completed = false;
     try {
         {
             bool fFlushForPrune = false;
             bool fDoFullFlush = false;
             LOCK(cs_LastBlockFile);
             if (fPruneMode && (fCheckForPruning || nManualPruneHeight > 0) &&
                 !fReindex) {
                 if (nManualPruneHeight > 0) {
                     FindFilesToPruneManual(setFilesToPrune, nManualPruneHeight);
                 } else {
                     FindFilesToPrune(setFilesToPrune,
                                      chainparams.PruneAfterHeight());
                     fCheckForPruning = false;
                 }
                 if (!setFilesToPrune.empty()) {
                     fFlushForPrune = true;
                     if (!fHavePruned) {
                         pblocktree->WriteFlag("prunedblockfiles", true);
                         fHavePruned = true;
                     }
                 }
             }
             int64_t nNow = GetTimeMicros();
             // Avoid writing/flushing immediately after startup.
             if (nLastWrite == 0) {
                 nLastWrite = nNow;
             }
             if (nLastFlush == 0) {
                 nLastFlush = nNow;
             }
             int64_t nMempoolSizeMax =
                 gArgs.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000;
             int64_t cacheSize = pcoinsTip->DynamicMemoryUsage();
             int64_t nTotalSpace =
                 nCoinCacheUsage +
                 std::max<int64_t>(nMempoolSizeMax - nMempoolUsage, 0);
             // The cache is large and we're within 10% and 10 MiB of the limit,
             // but we have time now (not in the middle of a block processing).
             bool fCacheLarge =
                 mode == FlushStateMode::PERIODIC &&
                 cacheSize > std::max((9 * nTotalSpace) / 10,
                                      nTotalSpace -
                                          MAX_BLOCK_COINSDB_USAGE * 1024 * 1024);
             // The cache is over the limit, we have to write now.
             bool fCacheCritical =
                 mode == FlushStateMode::IF_NEEDED && cacheSize > nTotalSpace;
             // It's been a while since we wrote the block index to disk. Do this
             // frequently, so we don't need to redownload after a crash.
             bool fPeriodicWrite =
                 mode == FlushStateMode::PERIODIC &&
                 nNow > nLastWrite + (int64_t)DATABASE_WRITE_INTERVAL * 1000000;
             // It's been very long since we flushed the cache. Do this
             // infrequently, to optimize cache usage.
             bool fPeriodicFlush =
                 mode == FlushStateMode::PERIODIC &&
                 nNow > nLastFlush + (int64_t)DATABASE_FLUSH_INTERVAL * 1000000;
             // Combine all conditions that result in a full cache flush.
             fDoFullFlush = (mode == FlushStateMode::ALWAYS) || fCacheLarge ||
                            fCacheCritical || fPeriodicFlush || fFlushForPrune;
             // Write blocks and block index to disk.
             if (fDoFullFlush || fPeriodicWrite) {
                 // Depend on nMinDiskSpace to ensure we can write block index
                 if (!CheckDiskSpace(GetBlocksDir())) {
                     return AbortNode(state, "Disk space is low!",
                                      _("Error: Disk space is low!").translated);
                 }
 
                 // First make sure all block and undo data is flushed to disk.
                 FlushBlockFile();
                 // Then update all block file information (which may refer to
                 // block and undo files).
                 {
                     std::vector<std::pair<int, const CBlockFileInfo *>> vFiles;
                     vFiles.reserve(setDirtyFileInfo.size());
                     for (int i : setDirtyFileInfo) {
                         vFiles.push_back(std::make_pair(i, &vinfoBlockFile[i]));
                     }
 
                     setDirtyFileInfo.clear();
 
                     std::vector<const CBlockIndex *> vBlocks;
                     vBlocks.reserve(setDirtyBlockIndex.size());
                     for (const CBlockIndex *cbi : setDirtyBlockIndex) {
                         vBlocks.push_back(cbi);
                     }
 
                     setDirtyBlockIndex.clear();
 
                     if (!pblocktree->WriteBatchSync(vFiles, nLastBlockFile,
                                                     vBlocks)) {
                         return AbortNode(
                             state, "Failed to write to block index database");
                     }
                 }
 
                 // Finally remove any pruned files
                 if (fFlushForPrune) {
                     UnlinkPrunedFiles(setFilesToPrune);
                 }
                 nLastWrite = nNow;
             }
             // Flush best chain related state. This can only be done if the
             // blocks / block index write was also done.
             if (fDoFullFlush && !pcoinsTip->GetBestBlock().IsNull()) {
                 // Typical Coin structures on disk are around 48 bytes in size.
                 // Pushing a new one to the database can cause it to be written
                 // twice (once in the log, and once in the tables). This is
                 // already an overestimation, as most will delete an existing
                 // entry or overwrite one. Still, use a conservative safety
                 // factor of 2.
                 if (!CheckDiskSpace(GetDataDir(),
                                     48 * 2 * 2 * pcoinsTip->GetCacheSize())) {
                     return AbortNode(state, "Disk space is low!",
                                      _("Error: Disk space is low!").translated);
                 }
 
                 // Flush the chainstate (which may refer to block index
                 // entries).
                 if (!pcoinsTip->Flush()) {
                     return AbortNode(state, "Failed to write to coin database");
                 }
                 nLastFlush = nNow;
                 full_flush_completed = true;
             }
         }
 
         if (full_flush_completed) {
             // Update best block in wallet (so we can detect restored wallets).
             GetMainSignals().ChainStateFlushed(m_chain.GetLocator());
         }
     } catch (const std::runtime_error &e) {
         return AbortNode(state, std::string("System error while flushing: ") +
                                     e.what());
     }
     return true;
 }
 
 void CChainState::ForceFlushStateToDisk() {
     CValidationState state;
     const CChainParams &chainparams = Params();
     if (!this->FlushStateToDisk(chainparams, state, FlushStateMode::ALWAYS)) {
         LogPrintf("%s: failed to flush state (%s)\n", __func__,
                   FormatStateMessage(state));
     }
 }
 
 void CChainState::PruneAndFlush() {
     CValidationState state;
     fCheckForPruning = true;
     const CChainParams &chainparams = Params();
     if (!this->FlushStateToDisk(chainparams, state, FlushStateMode::NONE)) {
         LogPrintf("%s: failed to flush state (%s)\n", __func__,
                   FormatStateMessage(state));
     }
 }
 
 /** Check warning conditions and do some notifications on new chain tip set. */
 static void UpdateTip(const CChainParams &params, CBlockIndex *pindexNew) {
     // New best block
     g_mempool.AddTransactionsUpdated(1);
 
     {
         LOCK(g_best_block_mutex);
         g_best_block = pindexNew->GetBlockHash();
         g_best_block_cv.notify_all();
     }
 
     LogPrintf("%s: new best=%s height=%d version=0x%08x log2_work=%.8g tx=%lu "
               "date='%s' progress=%f cache=%.1fMiB(%utxo)\n",
               __func__, pindexNew->GetBlockHash().ToString(),
               pindexNew->nHeight, pindexNew->nVersion,
               log(pindexNew->nChainWork.getdouble()) / log(2.0),
               (unsigned long)pindexNew->nChainTx,
               FormatISO8601DateTime(pindexNew->GetBlockTime()),
               GuessVerificationProgress(params.TxData(), pindexNew),
               pcoinsTip->DynamicMemoryUsage() * (1.0 / (1 << 20)),
               pcoinsTip->GetCacheSize());
 }
 
 /**
  * Disconnect m_chain's tip.
  * After calling, the mempool will be in an inconsistent state, with
  * transactions from disconnected blocks being added to disconnectpool. You
  * should make the mempool consistent again by calling updateMempoolForReorg.
  * with cs_main held.
  *
  * If disconnectpool is nullptr, then no disconnected transactions are added to
  * disconnectpool (note that the caller is responsible for mempool consistency
  * in any case).
  */
 bool CChainState::DisconnectTip(const CChainParams &params,
                                 CValidationState &state,
                                 DisconnectedBlockTransactions *disconnectpool) {
     AssertLockHeld(cs_main);
     CBlockIndex *pindexDelete = m_chain.Tip();
     const Consensus::Params &consensusParams = params.GetConsensus();
 
     assert(pindexDelete);
 
     // Read block from disk.
     std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
     CBlock &block = *pblock;
     if (!ReadBlockFromDisk(block, pindexDelete, consensusParams)) {
         return AbortNode(state, "Failed to read block");
     }
 
     // Apply the block atomically to the chain state.
     int64_t nStart = GetTimeMicros();
     {
         CCoinsViewCache view(pcoinsTip.get());
         assert(view.GetBestBlock() == pindexDelete->GetBlockHash());
         if (DisconnectBlock(block, pindexDelete, view) !=
             DisconnectResult::OK) {
             return error("DisconnectTip(): DisconnectBlock %s failed",
                          pindexDelete->GetBlockHash().ToString());
         }
 
         bool flushed = view.Flush();
         assert(flushed);
     }
 
     LogPrint(BCLog::BENCH, "- Disconnect block: %.2fms\n",
              (GetTimeMicros() - nStart) * MILLI);
 
     // Write the chain state to disk, if necessary.
     if (!FlushStateToDisk(params, state, FlushStateMode::IF_NEEDED)) {
         return false;
     }
 
     // If this block is deactivating a fork, we move all mempool transactions
     // in front of disconnectpool for reprocessing in a future
     // updateMempoolForReorg call
     if (pindexDelete->pprev != nullptr &&
         GetNextBlockScriptFlags(consensusParams, pindexDelete) !=
             GetNextBlockScriptFlags(consensusParams, pindexDelete->pprev)) {
         LogPrint(BCLog::MEMPOOL,
                  "Disconnecting mempool due to rewind of upgrade block\n");
         if (disconnectpool) {
             disconnectpool->importMempool(g_mempool);
         }
         g_mempool.clear();
     }
 
     if (disconnectpool) {
         disconnectpool->addForBlock(block.vtx);
     }
 
     // If the tip is finalized, then undo it.
     if (pindexFinalized == pindexDelete) {
         pindexFinalized = pindexDelete->pprev;
     }
 
     m_chain.SetTip(pindexDelete->pprev);
 
     // Update ::ChainActive() and related variables.
     UpdateTip(params, pindexDelete->pprev);
     // Let wallets know transactions went from 1-confirmed to
     // 0-confirmed or conflicted:
     GetMainSignals().BlockDisconnected(pblock);
     return true;
 }
 
 static int64_t nTimeReadFromDisk = 0;
 static int64_t nTimeConnectTotal = 0;
 static int64_t nTimeFlush = 0;
 static int64_t nTimeChainState = 0;
 static int64_t nTimePostConnect = 0;
 
 struct PerBlockConnectTrace {
     CBlockIndex *pindex = nullptr;
     std::shared_ptr<const CBlock> pblock;
     std::shared_ptr<std::vector<CTransactionRef>> conflictedTxs;
     PerBlockConnectTrace()
         : conflictedTxs(std::make_shared<std::vector<CTransactionRef>>()) {}
 };
 
 /**
  * Used to track blocks whose transactions were applied to the UTXO state as a
  * part of a single ActivateBestChainStep call.
  *
  * This class also tracks transactions that are removed from the mempool as
  * conflicts (per block) and can be used to pass all those transactions through
  * SyncTransaction.
  *
  * This class assumes (and asserts) that the conflicted transactions for a given
  * block are added via mempool callbacks prior to the BlockConnected()
  * associated with those transactions. If any transactions are marked
  * conflicted, it is assumed that an associated block will always be added.
  *
  * This class is single-use, once you call GetBlocksConnected() you have to
  * throw it away and make a new one.
  */
 class ConnectTrace {
 private:
     std::vector<PerBlockConnectTrace> blocksConnected;
     CTxMemPool &pool;
     boost::signals2::scoped_connection m_connNotifyEntryRemoved;
 
 public:
     explicit ConnectTrace(CTxMemPool &_pool) : blocksConnected(1), pool(_pool) {
         m_connNotifyEntryRemoved = pool.NotifyEntryRemoved.connect(
             std::bind(&ConnectTrace::NotifyEntryRemoved, this,
                       std::placeholders::_1, std::placeholders::_2));
     }
 
     void BlockConnected(CBlockIndex *pindex,
                         std::shared_ptr<const CBlock> pblock) {
         assert(!blocksConnected.back().pindex);
         assert(pindex);
         assert(pblock);
         blocksConnected.back().pindex = pindex;
         blocksConnected.back().pblock = std::move(pblock);
         blocksConnected.emplace_back();
     }
 
     std::vector<PerBlockConnectTrace> &GetBlocksConnected() {
         // We always keep one extra block at the end of our list because blocks
         // are added after all the conflicted transactions have been filled in.
         // Thus, the last entry should always be an empty one waiting for the
         // transactions from the next block. We pop the last entry here to make
         // sure the list we return is sane.
         assert(!blocksConnected.back().pindex);
         assert(blocksConnected.back().conflictedTxs->empty());
         blocksConnected.pop_back();
         return blocksConnected;
     }
 
     void NotifyEntryRemoved(CTransactionRef txRemoved,
                             MemPoolRemovalReason reason) {
         assert(!blocksConnected.back().pindex);
         if (reason == MemPoolRemovalReason::CONFLICT) {
             blocksConnected.back().conflictedTxs->emplace_back(
                 std::move(txRemoved));
         }
     }
 };
 
 static bool FinalizeBlockInternal(const Config &config, CValidationState &state,
                                   const CBlockIndex *pindex)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
     if (pindex->nStatus.isInvalid()) {
         // We try to finalize an invalid block.
         return state.DoS(100,
                          error("%s: Trying to finalize invalid block %s",
                                __func__, pindex->GetBlockHash().ToString()),
                          REJECT_INVALID, "finalize-invalid-block");
     }
 
     // Check that the request is consistent with current finalization.
     if (pindexFinalized && !AreOnTheSameFork(pindex, pindexFinalized)) {
         return state.DoS(
             20,
             error("%s: Trying to finalize block %s which conflicts "
                   "with already finalized block",
                   __func__, pindex->GetBlockHash().ToString()),
             REJECT_AGAINST_FINALIZED, "bad-fork-prior-finalized");
     }
 
     if (IsBlockFinalized(pindex)) {
         // The block is already finalized.
         return true;
     }
 
     // We have a new block to finalize.
     pindexFinalized = pindex;
     return true;
 }
 
 static const CBlockIndex *FindBlockToFinalize(const Config &config,
                                               CBlockIndex *pindexNew)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     AssertLockHeld(cs_main);
 
     const int32_t maxreorgdepth =
         gArgs.GetArg("-maxreorgdepth", DEFAULT_MAX_REORG_DEPTH);
 
     const int64_t finalizationdelay =
         gArgs.GetArg("-finalizationdelay", DEFAULT_MIN_FINALIZATION_DELAY);
 
     // Find our candidate.
     // If maxreorgdepth is < 0 pindex will be null and auto finalization
     // disabled
     const CBlockIndex *pindex =
         pindexNew->GetAncestor(pindexNew->nHeight - maxreorgdepth);
 
     int64_t now = GetTime();
 
     // If the finalization delay is not expired since the startup time,
     // finalization should be avoided. Header receive time is not saved to disk
     // and so cannot be anterior to startup time.
     if (now < (GetStartupTime() + finalizationdelay)) {
         return nullptr;
     }
 
     // While our candidate is not eligible (finalization delay not expired), try
     // the previous one.
     while (pindex && (pindex != pindexFinalized)) {
         // Check that the block to finalize is known for a long enough time.
         // This test will ensure that an attacker could not cause a block to
         // finalize by forking the chain with a depth > maxreorgdepth.
         // If the block is loaded from disk, header receive time is 0 and the
         // block will be finalized. This is safe because the delay since the
         // node startup is already expired.
         auto headerReceivedTime = pindex->GetHeaderReceivedTime();
 
         // If finalization delay is <= 0, finalization always occurs immediately
         if (now >= (headerReceivedTime + finalizationdelay)) {
             return pindex;
         }
 
         pindex = pindex->pprev;
     }
 
     return nullptr;
 }
 
 /**
  * Connect a new block to m_chain. pblock is either nullptr or a pointer to
  * a CBlock corresponding to pindexNew, to bypass loading it again from disk.
  *
  * The block is always added to connectTrace (either after loading from disk or
  * by copying pblock) - if that is not intended, care must be taken to remove
  * the last entry in blocksConnected in case of failure.
  */
 bool CChainState::ConnectTip(const Config &config, CValidationState &state,
                              CBlockIndex *pindexNew,
                              const std::shared_ptr<const CBlock> &pblock,
                              ConnectTrace &connectTrace,
                              DisconnectedBlockTransactions &disconnectpool) {
     AssertLockHeld(cs_main);
 
     const CChainParams &params = config.GetChainParams();
     const Consensus::Params &consensusParams = params.GetConsensus();
 
     assert(pindexNew->pprev == m_chain.Tip());
     // Read block from disk.
     int64_t nTime1 = GetTimeMicros();
     std::shared_ptr<const CBlock> pthisBlock;
     if (!pblock) {
         std::shared_ptr<CBlock> pblockNew = std::make_shared<CBlock>();
         if (!ReadBlockFromDisk(*pblockNew, pindexNew, consensusParams)) {
             return AbortNode(state, "Failed to read block");
         }
         pthisBlock = pblockNew;
     } else {
         pthisBlock = pblock;
     }
 
     const CBlock &blockConnecting = *pthisBlock;
 
     // Apply the block atomically to the chain state.
     int64_t nTime2 = GetTimeMicros();
     nTimeReadFromDisk += nTime2 - nTime1;
     int64_t nTime3;
     LogPrint(BCLog::BENCH, "  - Load block from disk: %.2fms [%.2fs]\n",
              (nTime2 - nTime1) * MILLI, nTimeReadFromDisk * MICRO);
     {
         CCoinsViewCache view(pcoinsTip.get());
         bool rv = ConnectBlock(blockConnecting, state, pindexNew, view, params,
                                BlockValidationOptions(config));
         GetMainSignals().BlockChecked(blockConnecting, state);
         if (!rv) {
             if (state.IsInvalid()) {
                 InvalidBlockFound(pindexNew, state);
             }
 
             return error("%s: ConnectBlock %s failed, %s", __func__,
                          pindexNew->GetBlockHash().ToString(),
                          FormatStateMessage(state));
         }
 
         // Update the finalized block.
         const CBlockIndex *pindexToFinalize =
             FindBlockToFinalize(config, pindexNew);
         if (pindexToFinalize &&
             !FinalizeBlockInternal(config, state, pindexToFinalize)) {
             state.SetCorruptionPossible();
             return error("ConnectTip(): FinalizeBlock %s failed (%s)",
                          pindexNew->GetBlockHash().ToString(),
                          FormatStateMessage(state));
         }
 
         nTime3 = GetTimeMicros();
         nTimeConnectTotal += nTime3 - nTime2;
         LogPrint(BCLog::BENCH,
                  "  - Connect total: %.2fms [%.2fs (%.2fms/blk)]\n",
                  (nTime3 - nTime2) * MILLI, nTimeConnectTotal * MICRO,
                  nTimeConnectTotal * MILLI / nBlocksTotal);
         bool flushed = view.Flush();
         assert(flushed);
     }
 
     int64_t nTime4 = GetTimeMicros();
     nTimeFlush += nTime4 - nTime3;
     LogPrint(BCLog::BENCH, "  - Flush: %.2fms [%.2fs (%.2fms/blk)]\n",
              (nTime4 - nTime3) * MILLI, nTimeFlush * MICRO,
              nTimeFlush * MILLI / nBlocksTotal);
 
     // Write the chain state to disk, if necessary.
     if (!FlushStateToDisk(config.GetChainParams(), state,
                           FlushStateMode::IF_NEEDED)) {
         return false;
     }
 
     int64_t nTime5 = GetTimeMicros();
     nTimeChainState += nTime5 - nTime4;
     LogPrint(BCLog::BENCH,
              "  - Writing chainstate: %.2fms [%.2fs (%.2fms/blk)]\n",
              (nTime5 - nTime4) * MILLI, nTimeChainState * MICRO,
              nTimeChainState * MILLI / nBlocksTotal);
 
     // Remove conflicting transactions from the mempool.;
     g_mempool.removeForBlock(blockConnecting.vtx, pindexNew->nHeight);
     disconnectpool.removeForBlock(blockConnecting.vtx);
 
     // If this block is activating a fork, we move all mempool transactions
     // in front of disconnectpool for reprocessing in a future
     // updateMempoolForReorg call
     if (pindexNew->pprev != nullptr &&
         GetNextBlockScriptFlags(consensusParams, pindexNew) !=
             GetNextBlockScriptFlags(consensusParams, pindexNew->pprev)) {
         LogPrint(BCLog::MEMPOOL,
                  "Disconnecting mempool due to acceptance of upgrade block\n");
         disconnectpool.importMempool(g_mempool);
     }
 
     // Update m_chain & related variables.
     m_chain.SetTip(pindexNew);
     UpdateTip(params, pindexNew);
 
     int64_t nTime6 = GetTimeMicros();
     nTimePostConnect += nTime6 - nTime5;
     nTimeTotal += nTime6 - nTime1;
     LogPrint(BCLog::BENCH,
              "  - Connect postprocess: %.2fms [%.2fs (%.2fms/blk)]\n",
              (nTime6 - nTime5) * MILLI, nTimePostConnect * MICRO,
              nTimePostConnect * MILLI / nBlocksTotal);
     LogPrint(BCLog::BENCH, "- Connect block: %.2fms [%.2fs (%.2fms/blk)]\n",
              (nTime6 - nTime1) * MILLI, nTimeTotal * MICRO,
              nTimeTotal * MILLI / nBlocksTotal);
 
     connectTrace.BlockConnected(pindexNew, std::move(pthisBlock));
     return true;
 }
 
 /**
  * Return the tip of the chain with the most work in it, that isn't known to be
  * invalid (it's however far from certain to be valid).
  */
 CBlockIndex *CChainState::FindMostWorkChain() {
     AssertLockHeld(cs_main);
     do {
         CBlockIndex *pindexNew = nullptr;
 
         // Find the best candidate header.
         {
             std::set<CBlockIndex *, CBlockIndexWorkComparator>::reverse_iterator
                 it = setBlockIndexCandidates.rbegin();
             if (it == setBlockIndexCandidates.rend()) {
                 return nullptr;
             }
             pindexNew = *it;
         }
 
         // If this block will cause a finalized block to be reorged, then we
         // mark it as invalid.
         if (pindexFinalized && !AreOnTheSameFork(pindexNew, pindexFinalized)) {
             LogPrintf("Mark block %s invalid because it forks prior to the "
                       "finalization point %d.\n",
                       pindexNew->GetBlockHash().ToString(),
                       pindexFinalized->nHeight);
             pindexNew->nStatus = pindexNew->nStatus.withFailed();
             InvalidChainFound(pindexNew);
         }
 
         const CBlockIndex *pindexFork = m_chain.FindFork(pindexNew);
 
         // Check whether all blocks on the path between the currently active
         // chain and the candidate are valid. Just going until the active chain
         // is an optimization, as we know all blocks in it are valid already.
         CBlockIndex *pindexTest = pindexNew;
         bool hasValidAncestor = true;
         while (hasValidAncestor && pindexTest && pindexTest != pindexFork) {
             assert(pindexTest->HaveTxsDownloaded() || pindexTest->nHeight == 0);
 
             // If this is a parked chain, but it has enough PoW, clear the park
             // state.
             bool fParkedChain = pindexTest->nStatus.isOnParkedChain();
             if (fParkedChain && gArgs.GetBoolArg("-automaticunparking", true)) {
                 const CBlockIndex *pindexTip = m_chain.Tip();
 
                 // During initialization, pindexTip and/or pindexFork may be
                 // null. In this case, we just ignore the fact that the chain is
                 // parked.
                 if (!pindexTip || !pindexFork) {
                     UnparkBlock(pindexTest);
                     continue;
                 }
 
                 // A parked chain can be unparked if it has twice as much PoW
                 // accumulated as the main chain has since the fork block.
                 CBlockIndex const *pindexExtraPow = pindexTip;
                 arith_uint256 requiredWork = pindexTip->nChainWork;
                 switch (pindexTip->nHeight - pindexFork->nHeight) {
                     // Limit the penality for depth 1, 2 and 3 to half a block
                     // worth of work to ensure we don't fork accidentally.
                     case 3:
                     case 2:
                         pindexExtraPow = pindexExtraPow->pprev;
                     // FALLTHROUGH
                     case 1: {
                         const arith_uint256 deltaWork =
                             pindexExtraPow->nChainWork - pindexFork->nChainWork;
                         requiredWork += (deltaWork >> 1);
                         break;
                     }
                     default:
                         requiredWork +=
                             pindexExtraPow->nChainWork - pindexFork->nChainWork;
                         break;
                 }
 
                 if (pindexNew->nChainWork > requiredWork) {
                     // We have enough, clear the parked state.
                     LogPrintf("Unpark chain up to block %s as it has "
                               "accumulated enough PoW.\n",
                               pindexNew->GetBlockHash().ToString());
                     fParkedChain = false;
                     UnparkBlock(pindexTest);
                 }
             }
 
             // Pruned nodes may have entries in setBlockIndexCandidates for
             // which block files have been deleted. Remove those as candidates
             // for the most work chain if we come across them; we can't switch
             // to a chain unless we have all the non-active-chain parent blocks.
             bool fInvalidChain = pindexTest->nStatus.isInvalid();
             bool fMissingData = !pindexTest->nStatus.hasData();
             if (!(fInvalidChain || fParkedChain || fMissingData)) {
                 // The current block is acceptable, move to the parent, up to
                 // the fork point.
                 pindexTest = pindexTest->pprev;
                 continue;
             }
 
             // Candidate chain is not usable (either invalid or parked or
             // missing data)
             hasValidAncestor = false;
             setBlockIndexCandidates.erase(pindexTest);
 
             if (fInvalidChain &&
                 (pindexBestInvalid == nullptr ||
                  pindexNew->nChainWork > pindexBestInvalid->nChainWork)) {
                 pindexBestInvalid = pindexNew;
             }
 
             if (fParkedChain &&
                 (pindexBestParked == nullptr ||
                  pindexNew->nChainWork > pindexBestParked->nChainWork)) {
                 pindexBestParked = pindexNew;
             }
 
             LogPrintf("Considered switching to better tip %s but that chain "
                       "contains a%s%s%s block.\n",
                       pindexNew->GetBlockHash().ToString(),
                       fInvalidChain ? "n invalid" : "",
                       fParkedChain ? " parked" : "",
                       fMissingData ? " missing-data" : "");
 
             CBlockIndex *pindexFailed = pindexNew;
             // Remove the entire chain from the set.
             while (pindexTest != pindexFailed) {
                 if (fInvalidChain || fParkedChain) {
                     pindexFailed->nStatus =
                         pindexFailed->nStatus.withFailedParent(fInvalidChain)
                             .withParkedParent(fParkedChain);
                 } else if (fMissingData) {
                     // If we're missing data, then add back to
                     // mapBlocksUnlinked, so that if the block arrives in the
                     // future we can try adding to setBlockIndexCandidates
                     // again.
                     mapBlocksUnlinked.insert(
                         std::make_pair(pindexFailed->pprev, pindexFailed));
                 }
                 setBlockIndexCandidates.erase(pindexFailed);
                 pindexFailed = pindexFailed->pprev;
             }
 
             if (fInvalidChain || fParkedChain) {
                 // We discovered a new chain tip that is either parked or
                 // invalid, we may want to warn.
                 CheckForkWarningConditionsOnNewFork(pindexNew);
             }
         }
 
         if (g_avalanche && pindexNew->nStatus.isOnParkedChain() &&
             gArgs.GetBoolArg("-enableavalanche", AVALANCHE_DEFAULT_ENABLED)) {
             g_avalanche->addBlockToReconcile(pindexNew);
         }
 
         // We found a candidate that has valid ancestors. This is our guy.
         if (hasValidAncestor) {
             return pindexNew;
         }
     } while (true);
 }
 
 /**
  * Delete all entries in setBlockIndexCandidates that are worse than the current
  * tip.
  */
 void CChainState::PruneBlockIndexCandidates() {
     // Note that we can't delete the current block itself, as we may need to
     // return to it later in case a reorganization to a better block fails.
     auto it = setBlockIndexCandidates.begin();
     while (it != setBlockIndexCandidates.end() &&
            setBlockIndexCandidates.value_comp()(*it, m_chain.Tip())) {
         setBlockIndexCandidates.erase(it++);
     }
 
     // Either the current tip or a successor of it we're working towards is left
     // in setBlockIndexCandidates.
     assert(!setBlockIndexCandidates.empty());
 }
 
 /**
  * Try to make some progress towards making pindexMostWork the active block.
  * pblock is either nullptr or a pointer to a CBlock corresponding to
  * pindexMostWork.
  */
 bool CChainState::ActivateBestChainStep(
     const Config &config, CValidationState &state, CBlockIndex *pindexMostWork,
     const std::shared_ptr<const CBlock> &pblock, bool &fInvalidFound,
     ConnectTrace &connectTrace) {
     AssertLockHeld(cs_main);
 
     const CBlockIndex *pindexOldTip = m_chain.Tip();
     const CBlockIndex *pindexFork = m_chain.FindFork(pindexMostWork);
 
     // Disconnect active blocks which are no longer in the best chain.
     bool fBlocksDisconnected = false;
     DisconnectedBlockTransactions disconnectpool;
     while (m_chain.Tip() && m_chain.Tip() != pindexFork) {
         if (!DisconnectTip(config.GetChainParams(), state, &disconnectpool)) {
             // This is likely a fatal error, but keep the mempool consistent,
             // just in case. Only remove from the mempool in this case.
             disconnectpool.updateMempoolForReorg(config, false);
             return false;
         }
 
         fBlocksDisconnected = true;
     }
 
     // Build list of new blocks to connect.
     std::vector<CBlockIndex *> vpindexToConnect;
     bool fContinue = true;
     int nHeight = pindexFork ? pindexFork->nHeight : -1;
     while (fContinue && nHeight != pindexMostWork->nHeight) {
         // Don't iterate the entire list of potential improvements toward the
         // best tip, as we likely only need a few blocks along the way.
         int nTargetHeight = std::min(nHeight + 32, pindexMostWork->nHeight);
         vpindexToConnect.clear();
         vpindexToConnect.reserve(nTargetHeight - nHeight);
         CBlockIndex *pindexIter = pindexMostWork->GetAncestor(nTargetHeight);
         while (pindexIter && pindexIter->nHeight != nHeight) {
             vpindexToConnect.push_back(pindexIter);
             pindexIter = pindexIter->pprev;
         }
 
         nHeight = nTargetHeight;
 
         // Connect new blocks.
         for (CBlockIndex *pindexConnect : reverse_iterate(vpindexToConnect)) {
             if (!ConnectTip(config, state, pindexConnect,
                             pindexConnect == pindexMostWork
                                 ? pblock
                                 : std::shared_ptr<const CBlock>(),
                             connectTrace, disconnectpool)) {
                 if (state.IsInvalid()) {
                     // The block violates a consensus rule.
                     if (!state.CorruptionPossible()) {
                         InvalidChainFound(vpindexToConnect.back());
                     }
 
                     state = CValidationState();
                     fInvalidFound = true;
                     fContinue = false;
                     break;
                 }
 
                 // A system error occurred (disk space, database error, ...).
                 // Make the mempool consistent with the current tip, just in
                 // case any observers try to use it before shutdown.
                 disconnectpool.updateMempoolForReorg(config, false);
                 return false;
             } else {
                 PruneBlockIndexCandidates();
                 if (!pindexOldTip ||
                     m_chain.Tip()->nChainWork > pindexOldTip->nChainWork) {
                     // We're in a better position than we were. Return
                     // temporarily to release the lock.
                     fContinue = false;
                     break;
                 }
             }
         }
     }
 
     if (fBlocksDisconnected || !disconnectpool.isEmpty()) {
         // If any blocks were disconnected, we need to update the mempool even
         // if disconnectpool is empty. The disconnectpool may also be non-empty
         // if the mempool was imported due to new validation rules being in
         // effect.
         LogPrint(BCLog::MEMPOOL, "Updating mempool due to reorganization or "
                                  "rules upgrade/downgrade\n");
         disconnectpool.updateMempoolForReorg(config, true);
     }
 
     g_mempool.check(pcoinsTip.get());
 
     // Callbacks/notifications for a new best chain.
     if (fInvalidFound) {
         CheckForkWarningConditionsOnNewFork(pindexMostWork);
     } else {
         CheckForkWarningConditions();
     }
 
     return true;
 }
 
 static void NotifyHeaderTip() LOCKS_EXCLUDED(cs_main) {
     bool fNotify = false;
     bool fInitialBlockDownload = false;
     static CBlockIndex *pindexHeaderOld = nullptr;
     CBlockIndex *pindexHeader = nullptr;
     {
         LOCK(cs_main);
         pindexHeader = pindexBestHeader;
 
         if (pindexHeader != pindexHeaderOld) {
             fNotify = true;
             fInitialBlockDownload =
                 ::ChainstateActive().IsInitialBlockDownload();
             pindexHeaderOld = pindexHeader;
         }
     }
 
     // Send block tip changed notifications without cs_main
     if (fNotify) {
         uiInterface.NotifyHeaderTip(fInitialBlockDownload, pindexHeader);
     }
 }
 
 /**
  * Make the best chain active, in multiple steps. The result is either failure
  * or an activated best chain. pblock is either nullptr or a pointer to a block
  * that is already loaded (to avoid loading it again from disk).
  *
  * ActivateBestChain is split into steps (see ActivateBestChainStep) so that
  * we avoid holding cs_main for an extended period of time; the length of this
  * call may be quite long during reindexing or a substantial reorg.
  */
 bool CChainState::ActivateBestChain(const Config &config,
                                     CValidationState &state,
                                     std::shared_ptr<const CBlock> pblock) {
     // Note that while we're often called here from ProcessNewBlock, this is
     // far from a guarantee. Things in the P2P/RPC will often end up calling
     // us in the middle of ProcessNewBlock - do not assume pblock is set
     // sanely for performance or correctness!
     AssertLockNotHeld(cs_main);
 
     const CChainParams &params = config.GetChainParams();
 
     // ABC maintains a fair degree of expensive-to-calculate internal state
     // because this function periodically releases cs_main so that it does not
     // lock up other threads for too long during large connects - and to allow
     // for e.g. the callback queue to drain we use m_cs_chainstate to enforce
     // mutual exclusion so that only one caller may execute this function at a
     // time
     LOCK(m_cs_chainstate);
 
     CBlockIndex *pindexMostWork = nullptr;
     CBlockIndex *pindexNewTip = nullptr;
     int nStopAtHeight = gArgs.GetArg("-stopatheight", DEFAULT_STOPATHEIGHT);
     do {
         boost::this_thread::interruption_point();
 
         if (GetMainSignals().CallbacksPending() > 10) {
             // Block until the validation queue drains. This should largely
             // never happen in normal operation, however may happen during
             // reindex, causing memory blowup if we run too far ahead.
             // Note that if a validationinterface callback ends up calling
             // ActivateBestChain this may lead to a deadlock! We should
             // probably have a DEBUG_LOCKORDER test for this in the future.
             SyncWithValidationInterfaceQueue();
         }
 
         {
             LOCK(cs_main);
             CBlockIndex *starting_tip = m_chain.Tip();
             bool blocks_connected = false;
             do {
                 // We absolutely may not unlock cs_main until we've made forward
                 // progress (with the exception of shutdown due to hardware
                 // issues, low disk space, etc).
 
                 // Destructed before cs_main is unlocked
                 ConnectTrace connectTrace(g_mempool);
 
                 if (pindexMostWork == nullptr) {
                     pindexMostWork = FindMostWorkChain();
                 }
 
                 // Whether we have anything to do at all.
                 if (pindexMostWork == nullptr ||
                     pindexMostWork == m_chain.Tip()) {
                     break;
                 }
 
                 bool fInvalidFound = false;
                 std::shared_ptr<const CBlock> nullBlockPtr;
                 if (!ActivateBestChainStep(
                         config, state, pindexMostWork,
                         pblock && pblock->GetHash() ==
                                       pindexMostWork->GetBlockHash()
                             ? pblock
                             : nullBlockPtr,
                         fInvalidFound, connectTrace)) {
                     return false;
                 }
                 blocks_connected = true;
 
                 if (fInvalidFound) {
                     // Wipe cache, we may need another branch now.
                     pindexMostWork = nullptr;
                 }
 
                 pindexNewTip = m_chain.Tip();
                 for (const PerBlockConnectTrace &trace :
                      connectTrace.GetBlocksConnected()) {
                     assert(trace.pblock && trace.pindex);
                     GetMainSignals().BlockConnected(trace.pblock, trace.pindex,
                                                     trace.conflictedTxs);
                 }
             } while (!m_chain.Tip() ||
                      (starting_tip && CBlockIndexWorkComparator()(
                                           m_chain.Tip(), starting_tip)));
 
             // Check the index once we're done with the above loop, since
             // we're going to release cs_main soon. If the index is in a bad
             // state now, then it's better to know immediately rather than
             // randomly have it cause a problem in a race.
             CheckBlockIndex(params.GetConsensus());
 
             if (!blocks_connected) {
                 return true;
             }
 
             const CBlockIndex *pindexFork = m_chain.FindFork(starting_tip);
             bool fInitialDownload = IsInitialBlockDownload();
 
             // Notify external listeners about the new tip.
             // Enqueue while holding cs_main to ensure that UpdatedBlockTip is
             // called in the order in which blocks are connected
             if (pindexFork != pindexNewTip) {
                 // Notify ValidationInterface subscribers
                 GetMainSignals().UpdatedBlockTip(pindexNewTip, pindexFork,
                                                  fInitialDownload);
 
                 // Always notify the UI if a new block tip was connected
                 uiInterface.NotifyBlockTip(fInitialDownload, pindexNewTip);
             }
         }
         // When we reach this point, we switched to a new tip (stored in
         // pindexNewTip).
 
         if (nStopAtHeight && pindexNewTip &&
             pindexNewTip->nHeight >= nStopAtHeight) {
             StartShutdown();
         }
 
         // We check shutdown only after giving ActivateBestChainStep a chance to
         // run once so that we never shutdown before connecting the genesis
         // block during LoadChainTip(). Previously this caused an assert()
         // failure during shutdown in such cases as the UTXO DB flushing checks
         // that the best block hash is non-null.
         if (ShutdownRequested()) {
             break;
         }
     } while (pindexNewTip != pindexMostWork);
 
     // Write changes periodically to disk, after relay.
     if (!FlushStateToDisk(params, state, FlushStateMode::PERIODIC)) {
         return false;
     }
 
     return true;
 }
 
 bool ActivateBestChain(const Config &config, CValidationState &state,
                        std::shared_ptr<const CBlock> pblock) {
     return ::ChainstateActive().ActivateBestChain(config, state,
                                                   std::move(pblock));
 }
 
 bool CChainState::PreciousBlock(const Config &config, CValidationState &state,
                                 CBlockIndex *pindex) {
     {
         LOCK(cs_main);
         if (pindex->nChainWork < m_chain.Tip()->nChainWork) {
             // Nothing to do, this block is not at the tip.
             return true;
         }
 
         if (m_chain.Tip()->nChainWork > nLastPreciousChainwork) {
             // The chain has been extended since the last call, reset the
             // counter.
             nBlockReverseSequenceId = -1;
         }
 
         nLastPreciousChainwork = m_chain.Tip()->nChainWork;
         setBlockIndexCandidates.erase(pindex);
         pindex->nSequenceId = nBlockReverseSequenceId;
         if (nBlockReverseSequenceId > std::numeric_limits<int32_t>::min()) {
             // We can't keep reducing the counter if somebody really wants to
             // call preciousblock 2**31-1 times on the same set of tips...
             nBlockReverseSequenceId--;
         }
 
         // In case this was parked, unpark it.
         UnparkBlock(pindex);
 
         // Make sure it is added to the candidate list if appropriate.
         if (pindex->IsValid(BlockValidity::TRANSACTIONS) &&
             pindex->HaveTxsDownloaded()) {
             setBlockIndexCandidates.insert(pindex);
             PruneBlockIndexCandidates();
         }
     }
 
     return ActivateBestChain(config, state);
 }
 
 bool PreciousBlock(const Config &config, CValidationState &state,
                    CBlockIndex *pindex) {
     return ::ChainstateActive().PreciousBlock(config, state, pindex);
 }
 
 bool CChainState::UnwindBlock(const Config &config, CValidationState &state,
                               CBlockIndex *pindex, bool invalidate) {
     CBlockIndex *to_mark_failed_or_parked = pindex;
     bool pindex_was_in_chain = false;
     int disconnected = 0;
 
     // Disconnect (descendants of) pindex, and mark them invalid.
     while (true) {
         if (ShutdownRequested()) {
             break;
         }
 
         LOCK(cs_main);
 
         if (!m_chain.Contains(pindex)) {
             break;
         }
 
         pindex_was_in_chain = true;
         CBlockIndex *invalid_walk_tip = m_chain.Tip();
 
         // ActivateBestChain considers blocks already in m_chain
         // unconditionally valid already, so force disconnect away from it.
 
         DisconnectedBlockTransactions disconnectpool;
 
         bool ret =
             DisconnectTip(config.GetChainParams(), state, &disconnectpool);
 
         // DisconnectTip will add transactions to disconnectpool.
         // Adjust the mempool to be consistent with the new tip, adding
         // transactions back to the mempool if disconnecting was successful,
         // and we're not doing a very deep invalidation (in which case
         // keeping the mempool up to date is probably futile anyway).
         disconnectpool.updateMempoolForReorg(
             config, /* fAddToMempool = */ (++disconnected <= 10) && ret);
 
         if (!ret) {
             return false;
         }
 
         assert(invalid_walk_tip->pprev == m_chain.Tip());
 
         // We immediately mark the disconnected blocks as invalid.
         // This prevents a case where pruned nodes may fail to invalidateblock
         // and be left unable to start as they have no tip candidates (as there
         // are no blocks that meet the "have data and are not invalid per
         // nStatus" criteria for inclusion in setBlockIndexCandidates).
 
         invalid_walk_tip->nStatus =
             invalidate ? invalid_walk_tip->nStatus.withFailed()
                        : invalid_walk_tip->nStatus.withParked();
 
         setDirtyBlockIndex.insert(invalid_walk_tip);
         setBlockIndexCandidates.insert(invalid_walk_tip->pprev);
 
         if (invalid_walk_tip == to_mark_failed_or_parked->pprev &&
             (invalidate ? to_mark_failed_or_parked->nStatus.hasFailed()
                         : to_mark_failed_or_parked->nStatus.isParked())) {
             // We only want to mark the last disconnected block as
             // Failed (or Parked); its children need to be FailedParent (or
             // ParkedParent) instead.
             to_mark_failed_or_parked->nStatus =
                 (invalidate
                      ? to_mark_failed_or_parked->nStatus.withFailed(false)
                            .withFailedParent()
                      : to_mark_failed_or_parked->nStatus.withParked(false)
                            .withParkedParent());
 
             setDirtyBlockIndex.insert(to_mark_failed_or_parked);
         }
 
         // Track the last disconnected block, so we can correct its
         // FailedParent (or ParkedParent) status in future iterations, or, if
         // it's the last one, call InvalidChainFound on it.
         to_mark_failed_or_parked = invalid_walk_tip;
     }
 
     {
         LOCK(cs_main);
         if (m_chain.Contains(to_mark_failed_or_parked)) {
             // If the to-be-marked invalid block is in the active chain,
             // something is interfering and we can't proceed.
             return false;
         }
 
         // Mark pindex (or the last disconnected block) as invalid (or parked),
         // even when it never was in the main chain.
         to_mark_failed_or_parked->nStatus =
             invalidate ? to_mark_failed_or_parked->nStatus.withFailed()
                        : to_mark_failed_or_parked->nStatus.withParked();
         setDirtyBlockIndex.insert(to_mark_failed_or_parked);
         if (invalidate) {
             m_failed_blocks.insert(to_mark_failed_or_parked);
         }
 
         // The resulting new best tip may not be in setBlockIndexCandidates
         // anymore, so add it again.
         for (const std::pair<const BlockHash, CBlockIndex *> &it :
              mapBlockIndex) {
             CBlockIndex *i = it.second;
             if (i->IsValid(BlockValidity::TRANSACTIONS) &&
                 i->HaveTxsDownloaded() &&
                 !setBlockIndexCandidates.value_comp()(i, m_chain.Tip())) {
                 setBlockIndexCandidates.insert(i);
             }
         }
 
         if (invalidate) {
             InvalidChainFound(to_mark_failed_or_parked);
         }
     }
 
     // Only notify about a new block tip if the active chain was modified.
     if (pindex_was_in_chain) {
         uiInterface.NotifyBlockTip(IsInitialBlockDownload(),
                                    to_mark_failed_or_parked->pprev);
     }
     return true;
 }
 
 bool FinalizeBlockAndInvalidate(const Config &config, CValidationState &state,
                                 CBlockIndex *pindex) {
     AssertLockHeld(cs_main);
     if (!FinalizeBlockInternal(config, state, pindex)) {
         // state is set by FinalizeBlockInternal.
         return false;
     }
 
     // We have a valid candidate, make sure it is not parked.
     if (pindex->nStatus.isOnParkedChain()) {
         UnparkBlock(pindex);
     }
 
     // If the finalized block is not on the active chain, we may need to rewind.
     if (!::ChainActive().Contains(pindex)) {
         const CBlockIndex *pindexFork = ::ChainActive().FindFork(pindex);
         CBlockIndex *pindexToInvalidate = ::ChainActive().Next(pindexFork);
         if (pindexToInvalidate) {
             return InvalidateBlock(config, state, pindexToInvalidate);
         }
     }
 
     return true;
 }
 
 bool InvalidateBlock(const Config &config, CValidationState &state,
                      CBlockIndex *pindex) {
     return ::ChainstateActive().UnwindBlock(config, state, pindex, true);
 }
 
 bool ParkBlock(const Config &config, CValidationState &state,
                CBlockIndex *pindex) {
     return ::ChainstateActive().UnwindBlock(config, state, pindex, false);
 }
 
 template <typename F>
 bool CChainState::UpdateFlagsForBlock(CBlockIndex *pindexBase,
                                       CBlockIndex *pindex, F f) {
     BlockStatus newStatus = f(pindex->nStatus);
     if (pindex->nStatus != newStatus &&
         (!pindexBase ||
          pindex->GetAncestor(pindexBase->nHeight) == pindexBase)) {
         pindex->nStatus = newStatus;
         setDirtyBlockIndex.insert(pindex);
         if (newStatus.isValid()) {
             m_failed_blocks.erase(pindex);
         }
 
         if (pindex->IsValid(BlockValidity::TRANSACTIONS) &&
             pindex->HaveTxsDownloaded() &&
             setBlockIndexCandidates.value_comp()(::ChainActive().Tip(),
                                                  pindex)) {
             setBlockIndexCandidates.insert(pindex);
         }
         return true;
     }
     return false;
 }
 
 template <typename F, typename C, typename AC>
 void CChainState::UpdateFlags(CBlockIndex *pindex, CBlockIndex *&pindexReset,
                               F f, C fChild, AC fAncestorWasChanged) {
     AssertLockHeld(cs_main);
 
     // Update the current block and ancestors; while we're doing this, identify
     // which was the deepest ancestor we changed.
     CBlockIndex *pindexDeepestChanged = pindex;
     for (auto pindexAncestor = pindex; pindexAncestor != nullptr;
          pindexAncestor = pindexAncestor->pprev) {
         if (UpdateFlagsForBlock(nullptr, pindexAncestor, f)) {
             pindexDeepestChanged = pindexAncestor;
         }
     }
 
     if (pindexReset &&
         pindexReset->GetAncestor(pindexDeepestChanged->nHeight) ==
             pindexDeepestChanged) {
         // reset pindexReset if it had a modified ancestor.
         pindexReset = nullptr;
     }
 
     // Update all blocks under modified blocks.
     BlockMap::iterator it = mapBlockIndex.begin();
     while (it != mapBlockIndex.end()) {
         UpdateFlagsForBlock(pindex, it->second, fChild);
         UpdateFlagsForBlock(pindexDeepestChanged, it->second,
                             fAncestorWasChanged);
         it++;
     }
 }
 
 void CChainState::ResetBlockFailureFlags(CBlockIndex *pindex) {
     AssertLockHeld(cs_main);
 
     // In case we are reconsidering something before the finalization point,
     // move the finalization point to the last common ancestor.
     if (pindexFinalized) {
         pindexFinalized = LastCommonAncestor(pindex, pindexFinalized);
     }
 
     UpdateFlags(
         pindex, pindexBestInvalid,
         [](const BlockStatus status) {
             return status.withClearedFailureFlags();
         },
         [](const BlockStatus status) {
             return status.withClearedFailureFlags();
         },
         [](const BlockStatus status) {
             return status.withFailedParent(false);
         });
 }
 
 void ResetBlockFailureFlags(CBlockIndex *pindex) {
     return ::ChainstateActive().ResetBlockFailureFlags(pindex);
 }
 
 void CChainState::UnparkBlockImpl(CBlockIndex *pindex, bool fClearChildren) {
     AssertLockHeld(cs_main);
 
     UpdateFlags(
         pindex, pindexBestParked,
         [](const BlockStatus status) {
             return status.withClearedParkedFlags();
         },
         [fClearChildren](const BlockStatus status) {
             return fClearChildren ? status.withClearedParkedFlags()
                                   : status.withParkedParent(false);
         },
         [](const BlockStatus status) {
             return status.withParkedParent(false);
         });
 }
 
 void UnparkBlockAndChildren(CBlockIndex *pindex) {
     return ::ChainstateActive().UnparkBlockImpl(pindex, true);
 }
 
 void UnparkBlock(CBlockIndex *pindex) {
     return ::ChainstateActive().UnparkBlockImpl(pindex, false);
 }
 
 const CBlockIndex *GetFinalizedBlock() {
     AssertLockHeld(cs_main);
     return pindexFinalized;
 }
 
 bool IsBlockFinalized(const CBlockIndex *pindex) {
     AssertLockHeld(cs_main);
     return pindexFinalized &&
            pindexFinalized->GetAncestor(pindex->nHeight) == pindex;
 }
 
 CBlockIndex *CChainState::AddToBlockIndex(const CBlockHeader &block) {
     AssertLockHeld(cs_main);
 
     // Check for duplicate
     BlockHash hash = block.GetHash();
     BlockMap::iterator it = mapBlockIndex.find(hash);
     if (it != mapBlockIndex.end()) {
         return it->second;
     }
 
     // Construct new block index object
     CBlockIndex *pindexNew = new CBlockIndex(block);
     // We assign the sequence id to blocks only when the full data is available,
     // to avoid miners withholding blocks but broadcasting headers, to get a
     // competitive advantage.
     pindexNew->nSequenceId = 0;
     BlockMap::iterator mi =
         mapBlockIndex.insert(std::make_pair(hash, pindexNew)).first;
     pindexNew->phashBlock = &((*mi).first);
     BlockMap::iterator miPrev = mapBlockIndex.find(block.hashPrevBlock);
     if (miPrev != mapBlockIndex.end()) {
         pindexNew->pprev = (*miPrev).second;
         pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
         pindexNew->BuildSkip();
     }
     pindexNew->nTimeReceived = GetTime();
     pindexNew->nTimeMax =
         (pindexNew->pprev
              ? std::max(pindexNew->pprev->nTimeMax, pindexNew->nTime)
              : pindexNew->nTime);
     pindexNew->nChainWork =
         (pindexNew->pprev ? pindexNew->pprev->nChainWork : 0) +
         GetBlockProof(*pindexNew);
     pindexNew->RaiseValidity(BlockValidity::TREE);
     if (pindexBestHeader == nullptr ||
         pindexBestHeader->nChainWork < pindexNew->nChainWork) {
         pindexBestHeader = pindexNew;
     }
 
     setDirtyBlockIndex.insert(pindexNew);
     return pindexNew;
 }
 
 /**
  * Mark a block as having its data received and checked (up to
  * BLOCK_VALID_TRANSACTIONS).
  */
 void CChainState::ReceivedBlockTransactions(const CBlock &block,
                                             CBlockIndex *pindexNew,
                                             const FlatFilePos &pos) {
     pindexNew->nTx = block.vtx.size();
     pindexNew->nChainTx = 0;
     pindexNew->nFile = pos.nFile;
     pindexNew->nDataPos = pos.nPos;
     pindexNew->nUndoPos = 0;
     pindexNew->nStatus = pindexNew->nStatus.withData();
     pindexNew->RaiseValidity(BlockValidity::TRANSACTIONS);
     setDirtyBlockIndex.insert(pindexNew);
 
     if (pindexNew->pprev == nullptr || pindexNew->pprev->HaveTxsDownloaded()) {
         // If pindexNew is the genesis block or all parents are
         // BLOCK_VALID_TRANSACTIONS.
         std::deque<CBlockIndex *> queue;
         queue.push_back(pindexNew);
 
         // Recursively process any descendant blocks that now may be eligible to
         // be connected.
         while (!queue.empty()) {
             CBlockIndex *pindex = queue.front();
             queue.pop_front();
             pindex->nChainTx =
                 (pindex->pprev ? pindex->pprev->nChainTx : 0) + pindex->nTx;
             if (pindex->nSequenceId == 0) {
                 // We assign a sequence is when transaction are received to
                 // prevent a miner from being able to broadcast a block but not
                 // its content. However, a sequence id may have been set
                 // manually, for instance via PreciousBlock, in which case, we
                 // don't need to assign one.
                 pindex->nSequenceId = nBlockSequenceId++;
             }
 
             if (m_chain.Tip() == nullptr ||
                 !setBlockIndexCandidates.value_comp()(pindex, m_chain.Tip())) {
                 setBlockIndexCandidates.insert(pindex);
             }
 
             std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
                       std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
                 range = mapBlocksUnlinked.equal_range(pindex);
             while (range.first != range.second) {
                 std::multimap<CBlockIndex *, CBlockIndex *>::iterator it =
                     range.first;
                 queue.push_back(it->second);
                 range.first++;
                 mapBlocksUnlinked.erase(it);
             }
         }
     } else if (pindexNew->pprev &&
                pindexNew->pprev->IsValid(BlockValidity::TREE)) {
         mapBlocksUnlinked.insert(std::make_pair(pindexNew->pprev, pindexNew));
     }
 }
 
 static bool FindBlockPos(FlatFilePos &pos, unsigned int nAddSize,
                          unsigned int nHeight, uint64_t nTime,
                          bool fKnown = false) {
     LOCK(cs_LastBlockFile);
 
     unsigned int nFile = fKnown ? pos.nFile : nLastBlockFile;
     if (vinfoBlockFile.size() <= nFile) {
         vinfoBlockFile.resize(nFile + 1);
     }
 
     if (!fKnown) {
         while (vinfoBlockFile[nFile].nSize + nAddSize >= MAX_BLOCKFILE_SIZE) {
             nFile++;
             if (vinfoBlockFile.size() <= nFile) {
                 vinfoBlockFile.resize(nFile + 1);
             }
         }
         pos.nFile = nFile;
         pos.nPos = vinfoBlockFile[nFile].nSize;
     }
 
     if ((int)nFile != nLastBlockFile) {
         if (!fKnown) {
             LogPrintf("Leaving block file %i: %s\n", nLastBlockFile,
                       vinfoBlockFile[nLastBlockFile].ToString());
         }
         FlushBlockFile(!fKnown);
         nLastBlockFile = nFile;
     }
 
     vinfoBlockFile[nFile].AddBlock(nHeight, nTime);
     if (fKnown) {
         vinfoBlockFile[nFile].nSize =
             std::max(pos.nPos + nAddSize, vinfoBlockFile[nFile].nSize);
     } else {
         vinfoBlockFile[nFile].nSize += nAddSize;
     }
 
     if (!fKnown) {
         bool out_of_space;
         size_t bytes_allocated =
             BlockFileSeq().Allocate(pos, nAddSize, out_of_space);
         if (out_of_space) {
             return AbortNode("Disk space is low!",
                              _("Error: Disk space is low!").translated);
         }
         if (bytes_allocated != 0 && fPruneMode) {
             fCheckForPruning = true;
         }
     }
 
     setDirtyFileInfo.insert(nFile);
     return true;
 }
 
 static bool FindUndoPos(CValidationState &state, int nFile, FlatFilePos &pos,
                         unsigned int nAddSize) {
     pos.nFile = nFile;
 
     LOCK(cs_LastBlockFile);
 
     pos.nPos = vinfoBlockFile[nFile].nUndoSize;
     vinfoBlockFile[nFile].nUndoSize += nAddSize;
     setDirtyFileInfo.insert(nFile);
 
     bool out_of_space;
     size_t bytes_allocated =
         UndoFileSeq().Allocate(pos, nAddSize, out_of_space);
     if (out_of_space) {
         return AbortNode(state, "Disk space is low!",
                          _("Error: Disk space is low!").translated);
     }
     if (bytes_allocated != 0 && fPruneMode) {
         fCheckForPruning = true;
     }
 
     return true;
 }
 
 /**
  * Return true if the provided block header is valid.
  * Only verify PoW if blockValidationOptions is configured to do so.
  * This allows validation of headers on which the PoW hasn't been done.
  * For example: to validate template handed to mining software.
  * Do not call this for any check that depends on the context.
  * For context-dependent calls, see ContextualCheckBlockHeader.
  */
 static bool CheckBlockHeader(const CBlockHeader &block, CValidationState &state,
                              const Consensus::Params &params,
                              BlockValidationOptions validationOptions) {
     // Check proof of work matches claimed amount
     if (validationOptions.shouldValidatePoW() &&
         !CheckProofOfWork(block.GetHash(), block.nBits, params)) {
         return state.DoS(50, false, REJECT_INVALID, "high-hash", false,
                          "proof of work failed");
     }
 
     return true;
 }
 
 bool CheckBlock(const CBlock &block, CValidationState &state,
                 const Consensus::Params &params,
                 BlockValidationOptions validationOptions) {
     // These are checks that are independent of context.
     if (block.fChecked) {
         return true;
     }
 
     // Check that the header is valid (particularly PoW).  This is mostly
     // redundant with the call in AcceptBlockHeader.
     if (!CheckBlockHeader(block, state, params, validationOptions)) {
         return false;
     }
 
     // Check the merkle root.
     if (validationOptions.shouldValidateMerkleRoot()) {
         bool mutated;
         uint256 hashMerkleRoot2 = BlockMerkleRoot(block, &mutated);
         if (block.hashMerkleRoot != hashMerkleRoot2) {
             return state.DoS(100, false, REJECT_INVALID, "bad-txnmrklroot",
                              true, "hashMerkleRoot mismatch");
         }
 
         // Check for merkle tree malleability (CVE-2012-2459): repeating
         // sequences of transactions in a block without affecting the merkle
         // root of a block, while still invalidating it.
         if (mutated) {
             return state.DoS(100, false, REJECT_INVALID, "bad-txns-duplicate",
                              true, "duplicate transaction");
         }
     }
 
     // All potential-corruption validation must be done before we do any
     // transaction validation, as otherwise we may mark the header as invalid
     // because we receive the wrong transactions for it.
 
     // First transaction must be coinbase.
     if (block.vtx.empty()) {
         return state.DoS(100, false, REJECT_INVALID, "bad-cb-missing", false,
                          "first tx is not coinbase");
     }
 
     // Size limits.
     auto nMaxBlockSize = validationOptions.getExcessiveBlockSize();
 
     // Bail early if there is no way this block is of reasonable size.
     if ((block.vtx.size() * MIN_TRANSACTION_SIZE) > nMaxBlockSize) {
         return state.DoS(100, false, REJECT_INVALID, "bad-blk-length", false,
                          "size limits failed");
     }
 
     auto currentBlockSize = ::GetSerializeSize(block, PROTOCOL_VERSION);
     if (currentBlockSize > nMaxBlockSize) {
         return state.DoS(100, false, REJECT_INVALID, "bad-blk-length", false,
                          "size limits failed");
     }
 
     // And a valid coinbase.
     if (!CheckCoinbase(*block.vtx[0], state)) {
         return state.Invalid(false, state.GetRejectCode(),
                              state.GetRejectReason(),
                              strprintf("Coinbase check failed (txid %s) %s",
                                        block.vtx[0]->GetId().ToString(),
                                        state.GetDebugMessage()));
     }
 
     // Check transactions for regularity, skipping the first. Note that this
     // is the first time we check that all after the first are !IsCoinBase.
     for (size_t i = 1; i < block.vtx.size(); i++) {
         auto *tx = block.vtx[i].get();
         if (!CheckRegularTransaction(*tx, state)) {
             return state.Invalid(
                 false, state.GetRejectCode(), state.GetRejectReason(),
                 strprintf("Transaction check failed (txid %s) %s",
                           tx->GetId().ToString(), state.GetDebugMessage()));
         }
     }
 
     if (validationOptions.shouldValidatePoW() &&
         validationOptions.shouldValidateMerkleRoot()) {
         block.fChecked = true;
     }
 
     return true;
 }
 
 /**
  * Context-dependent validity checks.
  * By "context", we mean only the previous block headers, but not the UTXO
  * set; UTXO-related validity checks are done in ConnectBlock().
  * NOTE: This function is not currently invoked by ConnectBlock(), so we
  * should consider upgrade issues if we change which consensus rules are
  * enforced in this function (eg by adding a new consensus rule). See comment
  * in ConnectBlock().
  * Note that -reindex-chainstate skips the validation that happens here!
  */
 static bool ContextualCheckBlockHeader(const CChainParams &params,
                                        const CBlockHeader &block,
                                        CValidationState &state,
                                        const CBlockIndex *pindexPrev,
                                        int64_t nAdjustedTime) {
     assert(pindexPrev != nullptr);
     const int nHeight = pindexPrev->nHeight + 1;
 
     // Check proof of work
     const Consensus::Params &consensusParams = params.GetConsensus();
     if (block.nBits !=
         GetNextWorkRequired(pindexPrev, &block, consensusParams)) {
         LogPrintf("bad bits after height: %d\n", pindexPrev->nHeight);
         return state.DoS(100, false, REJECT_INVALID, "bad-diffbits", false,
                          "incorrect proof of work");
     }
 
     // Check against checkpoints
     if (fCheckpointsEnabled) {
         const CCheckpointData &checkpoints = params.Checkpoints();
 
         // Check that the block chain matches the known block chain up to a
         // checkpoint.
         if (!Checkpoints::CheckBlock(checkpoints, nHeight, block.GetHash())) {
             return state.DoS(100,
                              error("%s: rejected by checkpoint lock-in at %d",
                                    __func__, nHeight),
                              REJECT_CHECKPOINT, "checkpoint mismatch");
         }
 
         // Don't accept any forks from the main chain prior to last checkpoint.
         // GetLastCheckpoint finds the last checkpoint in MapCheckpoints that's
         // in our MapBlockIndex.
         CBlockIndex *pcheckpoint = Checkpoints::GetLastCheckpoint(checkpoints);
         if (pcheckpoint && nHeight < pcheckpoint->nHeight) {
             return state.DoS(
                 100,
                 error("%s: forked chain older than last checkpoint (height %d)",
                       __func__, nHeight),
                 REJECT_CHECKPOINT, "bad-fork-prior-to-checkpoint");
         }
     }
 
     // Check timestamp against prev
     if (block.GetBlockTime() <= pindexPrev->GetMedianTimePast()) {
         return state.Invalid(false, REJECT_INVALID, "time-too-old",
                              "block's timestamp is too early");
     }
 
     // Check timestamp
     if (block.GetBlockTime() > nAdjustedTime + MAX_FUTURE_BLOCK_TIME) {
         return state.Invalid(false, REJECT_INVALID, "time-too-new",
                              "block timestamp too far in the future");
     }
 
     // Reject outdated version blocks when 95% (75% on testnet) of the network
     // has upgraded:
     // check for version 2, 3 and 4 upgrades
     if ((block.nVersion < 2 && nHeight >= consensusParams.BIP34Height) ||
         (block.nVersion < 3 && nHeight >= consensusParams.BIP66Height) ||
         (block.nVersion < 4 && nHeight >= consensusParams.BIP65Height)) {
         return state.Invalid(
             false, REJECT_OBSOLETE,
             strprintf("bad-version(0x%08x)", block.nVersion),
             strprintf("rejected nVersion=0x%08x block", block.nVersion));
     }
 
     return true;
 }
 
 bool ContextualCheckTransactionForCurrentBlock(const Consensus::Params &params,
                                                const CTransaction &tx,
                                                CValidationState &state,
                                                int flags) {
     AssertLockHeld(cs_main);
 
     // By convention a negative value for flags indicates that the current
     // network-enforced consensus rules should be used. In a future soft-fork
     // scenario that would mean checking which rules would be enforced for the
     // next block and setting the appropriate flags. At the present time no
     // soft-forks are scheduled, so no flags are set.
     flags = std::max(flags, 0);
 
     // ContextualCheckTransactionForCurrentBlock() uses
     // ::ChainActive().Height()+1 to evaluate nLockTime because when IsFinalTx()
     // is called within CBlock::AcceptBlock(), the height of the block *being*
     // evaluated is what is used. Thus if we want to know if a transaction can
     // be part of the *next* block, we need to call ContextualCheckTransaction()
     // with one more than ::ChainActive().Height().
     const int nBlockHeight = ::ChainActive().Height() + 1;
 
     // BIP113 will require that time-locked transactions have nLockTime set to
     // less than the median time of the previous block they're contained in.
     // When the next block is created its previous block will be the current
     // chain tip, so we use that to calculate the median time passed to
     // ContextualCheckTransaction() if LOCKTIME_MEDIAN_TIME_PAST is set.
     const int64_t nMedianTimePast =
         ::ChainActive().Tip() == nullptr
             ? 0
             : ::ChainActive().Tip()->GetMedianTimePast();
     const int64_t nLockTimeCutoff = (flags & LOCKTIME_MEDIAN_TIME_PAST)
                                         ? nMedianTimePast
                                         : GetAdjustedTime();
 
     return ContextualCheckTransaction(params, tx, state, nBlockHeight,
                                       nLockTimeCutoff, nMedianTimePast);
 }
 
 /**
  * NOTE: This function is not currently invoked by ConnectBlock(), so we
  * should consider upgrade issues if we change which consensus rules are
  * enforced in this function (eg by adding a new consensus rule). See comment
  * in ConnectBlock().
  * Note that -reindex-chainstate skips the validation that happens here!
  */
 static bool ContextualCheckBlock(const CBlock &block, CValidationState &state,
                                  const Consensus::Params &params,
                                  const CBlockIndex *pindexPrev) {
     const int nHeight = pindexPrev == nullptr ? 0 : pindexPrev->nHeight + 1;
 
     // Start enforcing BIP113 (Median Time Past).
     int nLockTimeFlags = 0;
     if (nHeight >= params.CSVHeight) {
         assert(pindexPrev != nullptr);
         nLockTimeFlags |= LOCKTIME_MEDIAN_TIME_PAST;
     }
 
     const int64_t nMedianTimePast =
         pindexPrev == nullptr ? 0 : pindexPrev->GetMedianTimePast();
 
     const int64_t nLockTimeCutoff = (nLockTimeFlags & LOCKTIME_MEDIAN_TIME_PAST)
                                         ? nMedianTimePast
                                         : block.GetBlockTime();
 
     const bool fIsMagneticAnomalyEnabled =
         IsMagneticAnomalyEnabled(params, pindexPrev);
 
     // Check transactions:
     // - canonical ordering
     // - ensure they are finalized
     // - perform a preliminary block-sigops count (they will be recounted more
     // strictly during ConnectBlock).
     // - perform a transaction-sigops check (again, a more strict check will
     // happen in ConnectBlock).
     const CTransaction *prevTx = nullptr;
     for (const auto &ptx : block.vtx) {
         const CTransaction &tx = *ptx;
         if (fIsMagneticAnomalyEnabled) {
             if (prevTx && (tx.GetId() <= prevTx->GetId())) {
                 if (tx.GetId() == prevTx->GetId()) {
                     return state.DoS(100, false, REJECT_INVALID, "tx-duplicate",
                                      false,
                                      strprintf("Duplicated transaction %s",
                                                tx.GetId().ToString()));
                 }
 
                 return state.DoS(
                     100, false, REJECT_INVALID, "tx-ordering", false,
                     strprintf("Transaction order is invalid (%s < %s)",
                               tx.GetId().ToString(),
                               prevTx->GetId().ToString()));
             }
 
             if (prevTx || !tx.IsCoinBase()) {
                 prevTx = &tx;
             }
         }
 
         if (!ContextualCheckTransaction(params, tx, state, nHeight,
                                         nLockTimeCutoff, nMedianTimePast)) {
             // state set by ContextualCheckTransaction.
             return false;
         }
     }
 
     // Enforce rule that the coinbase starts with serialized block height
     if (nHeight >= params.BIP34Height) {
         CScript expect = CScript() << nHeight;
         if (block.vtx[0]->vin[0].scriptSig.size() < expect.size() ||
             !std::equal(expect.begin(), expect.end(),
                         block.vtx[0]->vin[0].scriptSig.begin())) {
             return state.DoS(100, false, REJECT_INVALID, "bad-cb-height", false,
                              "block height mismatch in coinbase");
         }
     }
 
     return true;
 }
 
 /**
  * If the provided block header is valid, add it to the block index.
  *
  * Returns true if the block is successfully added to the block index.
  */
 bool CChainState::AcceptBlockHeader(const Config &config,
                                     const CBlockHeader &block,
                                     CValidationState &state,
                                     CBlockIndex **ppindex) {
     AssertLockHeld(cs_main);
     const CChainParams &chainparams = config.GetChainParams();
 
     // Check for duplicate
     BlockHash hash = block.GetHash();
     BlockMap::iterator miSelf = mapBlockIndex.find(hash);
     CBlockIndex *pindex = nullptr;
     if (hash != chainparams.GetConsensus().hashGenesisBlock) {
         if (miSelf != mapBlockIndex.end()) {
             // Block header is already known.
             pindex = miSelf->second;
             if (ppindex) {
                 *ppindex = pindex;
             }
 
             if (pindex->nStatus.isInvalid()) {
                 return state.Invalid(error("%s: block %s is marked invalid",
                                            __func__, hash.ToString()),
                                      0, "duplicate");
             }
 
             return true;
         }
 
         if (!CheckBlockHeader(block, state, chainparams.GetConsensus(),
                               BlockValidationOptions(config))) {
             return error("%s: Consensus::CheckBlockHeader: %s, %s", __func__,
                          hash.ToString(), FormatStateMessage(state));
         }
 
         // Get prev block index
         BlockMap::iterator mi = mapBlockIndex.find(block.hashPrevBlock);
         if (mi == mapBlockIndex.end()) {
             return state.DoS(10, error("%s: prev block not found", __func__), 0,
                              "prev-blk-not-found");
         }
 
         CBlockIndex *pindexPrev = (*mi).second;
         assert(pindexPrev);
         if (pindexPrev->nStatus.isInvalid()) {
             return state.DoS(100, error("%s: prev block invalid", __func__),
                              REJECT_INVALID, "bad-prevblk");
         }
 
         if (!ContextualCheckBlockHeader(chainparams, block, state, pindexPrev,
                                         GetAdjustedTime())) {
             return error("%s: Consensus::ContextualCheckBlockHeader: %s, %s",
                          __func__, hash.ToString(), FormatStateMessage(state));
         }
 
         /* Determine if this block descends from any block which has been found
          * invalid (m_failed_blocks), then mark pindexPrev and any blocks
          * between them as failed. For example:
          *
          *                D3
          *              /
          *      B2 - C2
          *    /         \
          *  A             D2 - E2 - F2
          *    \
          *      B1 - C1 - D1 - E1
          *
          * In the case that we attempted to reorg from E1 to F2, only to find
          * C2 to be invalid, we would mark D2, E2, and F2 as BLOCK_FAILED_CHILD
          * but NOT D3 (it was not in any of our candidate sets at the time).
          *
          * In any case D3 will also be marked as BLOCK_FAILED_CHILD at restart
          * in LoadBlockIndex.
          */
         if (!pindexPrev->IsValid(BlockValidity::SCRIPTS)) {
             // The above does not mean "invalid": it checks if the previous
             // block hasn't been validated up to BLOCK_VALID_SCRIPTS. This is a
             // performance optimization, in the common case of adding a new
             // block to the tip, we don't need to iterate over the failed blocks
             // list.
             for (const CBlockIndex *failedit : m_failed_blocks) {
                 if (pindexPrev->GetAncestor(failedit->nHeight) == failedit) {
                     assert(failedit->nStatus.hasFailed());
                     CBlockIndex *invalid_walk = pindexPrev;
                     while (invalid_walk != failedit) {
                         invalid_walk->nStatus =
                             invalid_walk->nStatus.withFailedParent();
                         setDirtyBlockIndex.insert(invalid_walk);
                         invalid_walk = invalid_walk->pprev;
                     }
                     return state.DoS(100,
                                      error("%s: prev block invalid", __func__),
                                      REJECT_INVALID, "bad-prevblk");
                 }
             }
         }
     }
 
     if (pindex == nullptr) {
         pindex = AddToBlockIndex(block);
     }
 
     if (ppindex) {
         *ppindex = pindex;
     }
 
     CheckBlockIndex(chainparams.GetConsensus());
     return true;
 }
 
 // Exposed wrapper for AcceptBlockHeader
 bool ProcessNewBlockHeaders(const Config &config,
                             const std::vector<CBlockHeader> &headers,
                             CValidationState &state,
                             const CBlockIndex **ppindex,
                             CBlockHeader *first_invalid) {
     if (first_invalid != nullptr) {
         first_invalid->SetNull();
     }
 
     {
         LOCK(cs_main);
         for (const CBlockHeader &header : headers) {
             // Use a temp pindex instead of ppindex to avoid a const_cast
             CBlockIndex *pindex = nullptr;
             if (!::ChainstateActive().AcceptBlockHeader(config, header, state,
                                                         &pindex)) {
                 if (first_invalid) {
                     *first_invalid = header;
                 }
                 return false;
             }
 
             if (ppindex) {
                 *ppindex = pindex;
             }
         }
     }
 
     NotifyHeaderTip();
     return true;
 }
 
 /**
  * Store block on disk. If dbp is non-nullptr, the file is known to already
  * reside on disk.
  */
 static FlatFilePos SaveBlockToDisk(const CBlock &block, int nHeight,
                                    const CChainParams &chainparams,
                                    const FlatFilePos *dbp) {
     unsigned int nBlockSize = ::GetSerializeSize(block, CLIENT_VERSION);
     FlatFilePos blockPos;
     if (dbp != nullptr) {
         blockPos = *dbp;
     }
     if (!FindBlockPos(blockPos, nBlockSize + 8, nHeight, block.GetBlockTime(),
                       dbp != nullptr)) {
         error("%s: FindBlockPos failed", __func__);
         return FlatFilePos();
     }
     if (dbp == nullptr) {
         if (!WriteBlockToDisk(block, blockPos, chainparams.DiskMagic())) {
             AbortNode("Failed to write block");
             return FlatFilePos();
         }
     }
     return blockPos;
 }
 
 /**
  * Store a block on disk.
  *
  * @param[in]     config     The global config.
  * @param[in-out] pblock     The block we want to accept.
  * @param[in]     fRequested A boolean to indicate if this block was requested
  *                           from our peers.
  * @param[in]     dbp        If non-null, the disk position of the block.
  * @param[in-out] fNewBlock  True if block was first received via this call.
  * @return True if the block is accepted as a valid block and written to disk.
  */
 bool CChainState::AcceptBlock(const Config &config,
                               const std::shared_ptr<const CBlock> &pblock,
                               CValidationState &state, bool fRequested,
                               const FlatFilePos *dbp, bool *fNewBlock) {
     AssertLockHeld(cs_main);
 
     const CBlock &block = *pblock;
     if (fNewBlock) {
         *fNewBlock = false;
     }
 
     CBlockIndex *pindex = nullptr;
     if (!AcceptBlockHeader(config, block, state, &pindex)) {
         return false;
     }
 
     // Try to process all requested blocks that we don't have, but only
     // process an unrequested block if it's new and has enough work to
     // advance our tip, and isn't too many blocks ahead.
     bool fAlreadyHave = pindex->nStatus.hasData();
 
     // TODO: deal better with return value and error conditions for duplicate
     // and unrequested blocks.
     if (fAlreadyHave) {
         return true;
     }
 
     // Compare block header timestamps and received times of the block and the
     // chaintip.  If they have the same chain height, use these diffs as a
     // tie-breaker, attempting to pick the more honestly-mined block.
     int64_t newBlockTimeDiff = std::llabs(pindex->GetReceivedTimeDiff());
     int64_t chainTipTimeDiff =
         m_chain.Tip() ? std::llabs(m_chain.Tip()->GetReceivedTimeDiff()) : 0;
 
     bool isSameHeight =
         m_chain.Tip() && (pindex->nChainWork == m_chain.Tip()->nChainWork);
     if (isSameHeight) {
         LogPrintf("Chain tip timestamp-to-received-time difference: hash=%s, "
                   "diff=%d\n",
                   m_chain.Tip()->GetBlockHash().ToString(), chainTipTimeDiff);
         LogPrintf("New block timestamp-to-received-time difference: hash=%s, "
                   "diff=%d\n",
                   pindex->GetBlockHash().ToString(), newBlockTimeDiff);
     }
 
     bool fHasMoreOrSameWork =
         (m_chain.Tip() ? pindex->nChainWork >= m_chain.Tip()->nChainWork
                        : true);
 
     // Blocks that are too out-of-order needlessly limit the effectiveness of
     // pruning, because pruning will not delete block files that contain any
     // blocks which are too close in height to the tip.  Apply this test
     // regardless of whether pruning is enabled; it should generally be safe to
     // not process unrequested blocks.
     bool fTooFarAhead =
         (pindex->nHeight > int(m_chain.Height() + MIN_BLOCKS_TO_KEEP));
 
     // TODO: Decouple this function from the block download logic by removing
     // fRequested
     // This requires some new chain data structure to efficiently look up if a
     // block is in a chain leading to a candidate for best tip, despite not
     // being such a candidate itself.
 
     // If we didn't ask for it:
     if (!fRequested) {
         // This is a previously-processed block that was pruned.
         if (pindex->nTx != 0) {
             return true;
         }
 
         // Don't process less-work chains.
         if (!fHasMoreOrSameWork) {
             return true;
         }
 
         // Block height is too high.
         if (fTooFarAhead) {
             return true;
         }
 
         // Protect against DoS attacks from low-work chains.
         // If our tip is behind, a peer could try to send us
         // low-work blocks on a fake chain that we would never
         // request; don't process these.
         if (pindex->nChainWork < nMinimumChainWork) {
             return true;
         }
     }
 
     const CChainParams &chainparams = config.GetChainParams();
     const Consensus::Params &consensusParams = chainparams.GetConsensus();
 
     if (!CheckBlock(block, state, consensusParams,
                     BlockValidationOptions(config)) ||
         !ContextualCheckBlock(block, state, consensusParams, pindex->pprev)) {
         if (state.IsInvalid() && !state.CorruptionPossible()) {
             pindex->nStatus = pindex->nStatus.withFailed();
             setDirtyBlockIndex.insert(pindex);
         }
 
         return error("%s: %s (block %s)", __func__, FormatStateMessage(state),
                      block.GetHash().ToString());
     }
 
     // If connecting the new block would require rewinding more than one block
     // from the active chain (i.e., a "deep reorg"), then mark the new block as
     // parked. If it has enough work then it will be automatically unparked
     // later, during FindMostWorkChain. We mark the block as parked at the very
     // last minute so we can make sure everything is ready to be reorged if
     // needed.
     if (gArgs.GetBoolArg("-parkdeepreorg", true)) {
         const CBlockIndex *pindexFork = m_chain.FindFork(pindex);
         if (pindexFork && pindexFork->nHeight + 1 < m_chain.Height()) {
             LogPrintf("Park block %s as it would cause a deep reorg.\n",
                       pindex->GetBlockHash().ToString());
             pindex->nStatus = pindex->nStatus.withParked();
             setDirtyBlockIndex.insert(pindex);
         }
     }
 
     // Header is valid/has work and the merkle tree is good.
     // Relay now, but if it does not build on our best tip, let the
     // SendMessages loop relay it.
     if (!IsInitialBlockDownload() && m_chain.Tip() == pindex->pprev) {
         GetMainSignals().NewPoWValidBlock(pindex, pblock);
     }
 
     // Write block to history file
     if (fNewBlock) {
         *fNewBlock = true;
     }
     try {
         FlatFilePos blockPos =
             SaveBlockToDisk(block, pindex->nHeight, chainparams, dbp);
         if (blockPos.IsNull()) {
             state.Error(strprintf(
                 "%s: Failed to find position to write new block to disk",
                 __func__));
             return false;
         }
         ReceivedBlockTransactions(block, pindex, blockPos);
     } catch (const std::runtime_error &e) {
         return AbortNode(state, std::string("System error: ") + e.what());
     }
 
     FlushStateToDisk(chainparams, state, FlushStateMode::NONE);
 
     CheckBlockIndex(consensusParams);
 
     return true;
 }
 
 bool ProcessNewBlock(const Config &config,
                      const std::shared_ptr<const CBlock> pblock,
                      bool fForceProcessing, bool *fNewBlock) {
     AssertLockNotHeld(cs_main);
 
     {
         if (fNewBlock) {
             *fNewBlock = false;
         }
 
         CValidationState state;
 
         // CheckBlock() does not support multi-threaded block validation
         // because CBlock::fChecked can cause data race.
         // Therefore, the following critical section must include the
         // CheckBlock() call as well.
         LOCK(cs_main);
 
         // Ensure that CheckBlock() passes before calling AcceptBlock, as
         // belt-and-suspenders.
         bool ret =
             CheckBlock(*pblock, state, config.GetChainParams().GetConsensus(),
                        BlockValidationOptions(config));
         if (ret) {
             // Store to disk
             ret = ::ChainstateActive().AcceptBlock(
                 config, pblock, state, fForceProcessing, nullptr, fNewBlock);
         }
 
         if (!ret) {
             GetMainSignals().BlockChecked(*pblock, state);
             return error("%s: AcceptBlock FAILED (%s)", __func__,
                          FormatStateMessage(state));
         }
     }
 
     NotifyHeaderTip();
 
     // Only used to report errors, not invalidity - ignore it
     CValidationState state;
     if (!::ChainstateActive().ActivateBestChain(config, state, pblock)) {
         return error("%s: ActivateBestChain failed (%s)", __func__,
                      FormatStateMessage(state));
     }
 
     return true;
 }
 
 bool TestBlockValidity(CValidationState &state, const CChainParams &params,
                        const CBlock &block, CBlockIndex *pindexPrev,
                        BlockValidationOptions validationOptions) {
     AssertLockHeld(cs_main);
     assert(pindexPrev && pindexPrev == ::ChainActive().Tip());
     CCoinsViewCache viewNew(pcoinsTip.get());
     BlockHash block_hash(block.GetHash());
     CBlockIndex indexDummy(block);
     indexDummy.pprev = pindexPrev;
     indexDummy.nHeight = pindexPrev->nHeight + 1;
     indexDummy.phashBlock = &block_hash;
 
     // NOTE: CheckBlockHeader is called by CheckBlock
     if (!ContextualCheckBlockHeader(params, block, state, pindexPrev,
                                     GetAdjustedTime())) {
         return error("%s: Consensus::ContextualCheckBlockHeader: %s", __func__,
                      FormatStateMessage(state));
     }
 
     if (!CheckBlock(block, state, params.GetConsensus(), validationOptions)) {
         return error("%s: Consensus::CheckBlock: %s", __func__,
                      FormatStateMessage(state));
     }
 
     if (!ContextualCheckBlock(block, state, params.GetConsensus(),
                               pindexPrev)) {
         return error("%s: Consensus::ContextualCheckBlock: %s", __func__,
                      FormatStateMessage(state));
     }
 
     if (!::ChainstateActive().ConnectBlock(block, state, &indexDummy, viewNew,
                                            params, validationOptions, true)) {
         return false;
     }
 
     assert(state.IsValid());
     return true;
 }
 
 /**
  * BLOCK PRUNING CODE
  */
 
 /**
  * Calculate the amount of disk space the block & undo files currently use.
  */
 uint64_t CalculateCurrentUsage() {
     LOCK(cs_LastBlockFile);
 
     uint64_t retval = 0;
     for (const CBlockFileInfo &file : vinfoBlockFile) {
         retval += file.nSize + file.nUndoSize;
     }
 
     return retval;
 }
 
 /**
  * Prune a block file (modify associated database entries)
  */
 void PruneOneBlockFile(const int fileNumber) {
     LOCK(cs_LastBlockFile);
 
     for (const auto &entry : mapBlockIndex) {
         CBlockIndex *pindex = entry.second;
         if (pindex->nFile == fileNumber) {
             pindex->nStatus = pindex->nStatus.withData(false).withUndo(false);
             pindex->nFile = 0;
             pindex->nDataPos = 0;
             pindex->nUndoPos = 0;
             setDirtyBlockIndex.insert(pindex);
 
             // Prune from mapBlocksUnlinked -- any block we prune would have
             // to be downloaded again in order to consider its chain, at which
             // point it would be considered as a candidate for
             // mapBlocksUnlinked or setBlockIndexCandidates.
             std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
                       std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
                 range = mapBlocksUnlinked.equal_range(pindex->pprev);
             while (range.first != range.second) {
                 std::multimap<CBlockIndex *, CBlockIndex *>::iterator _it =
                     range.first;
                 range.first++;
                 if (_it->second == pindex) {
                     mapBlocksUnlinked.erase(_it);
                 }
             }
         }
     }
 
     vinfoBlockFile[fileNumber].SetNull();
     setDirtyFileInfo.insert(fileNumber);
 }
 
 void UnlinkPrunedFiles(const std::set<int> &setFilesToPrune) {
     for (const int i : setFilesToPrune) {
         FlatFilePos pos(i, 0);
         fs::remove(BlockFileSeq().FileName(pos));
         fs::remove(UndoFileSeq().FileName(pos));
         LogPrintf("Prune: %s deleted blk/rev (%05u)\n", __func__, i);
     }
 }
 
 /**
  * Calculate the block/rev files to delete based on height specified by user
  * with RPC command pruneblockchain
  */
 static void FindFilesToPruneManual(std::set<int> &setFilesToPrune,
                                    int nManualPruneHeight) {
     assert(fPruneMode && nManualPruneHeight > 0);
 
     LOCK2(cs_main, cs_LastBlockFile);
     if (::ChainActive().Tip() == nullptr) {
         return;
     }
 
     // last block to prune is the lesser of (user-specified height,
     // MIN_BLOCKS_TO_KEEP from the tip)
     unsigned int nLastBlockWeCanPrune =
         std::min((unsigned)nManualPruneHeight,
                  ::ChainActive().Tip()->nHeight - MIN_BLOCKS_TO_KEEP);
     int count = 0;
     for (int fileNumber = 0; fileNumber < nLastBlockFile; fileNumber++) {
         if (vinfoBlockFile[fileNumber].nSize == 0 ||
             vinfoBlockFile[fileNumber].nHeightLast > nLastBlockWeCanPrune) {
             continue;
         }
         PruneOneBlockFile(fileNumber);
         setFilesToPrune.insert(fileNumber);
         count++;
     }
     LogPrintf("Prune (Manual): prune_height=%d removed %d blk/rev pairs\n",
               nLastBlockWeCanPrune, count);
 }
 
 /* This function is called from the RPC code for pruneblockchain */
 void PruneBlockFilesManual(int nManualPruneHeight) {
     CValidationState state;
     const CChainParams &chainparams = Params();
     if (!::ChainstateActive().FlushStateToDisk(
             chainparams, state, FlushStateMode::NONE, nManualPruneHeight)) {
         LogPrintf("%s: failed to flush state (%s)\n", __func__,
                   FormatStateMessage(state));
     }
 }
 
 /**
  * Prune block and undo files (blk???.dat and undo???.dat) so that the disk
  * space used is less than a user-defined target. The user sets the target (in
  * MB) on the command line or in config file.  This will be run on startup and
  * whenever new space is allocated in a block or undo file, staying below the
  * target. Changing back to unpruned requires a reindex (which in this case
  * means the blockchain must be re-downloaded.)
  *
  * Pruning functions are called from FlushStateToDisk when the global
  * fCheckForPruning flag has been set. Block and undo files are deleted in
  * lock-step (when blk00003.dat is deleted, so is rev00003.dat.). Pruning cannot
  * take place until the longest chain is at least a certain length (100000 on
  * mainnet, 1000 on testnet, 1000 on regtest). Pruning will never delete a block
  * within a defined distance (currently 288) from the active chain's tip. The
  * block index is updated by unsetting HAVE_DATA and HAVE_UNDO for any blocks
  * that were stored in the deleted files. A db flag records the fact that at
  * least some block files have been pruned.
  *
  * @param[out]   setFilesToPrune   The set of file indices that can be unlinked
  * will be returned
  */
 static void FindFilesToPrune(std::set<int> &setFilesToPrune,
                              uint64_t nPruneAfterHeight) {
     LOCK2(cs_main, cs_LastBlockFile);
     if (::ChainActive().Tip() == nullptr || nPruneTarget == 0) {
         return;
     }
     if (uint64_t(::ChainActive().Tip()->nHeight) <= nPruneAfterHeight) {
         return;
     }
 
     unsigned int nLastBlockWeCanPrune =
         ::ChainActive().Tip()->nHeight - MIN_BLOCKS_TO_KEEP;
     uint64_t nCurrentUsage = CalculateCurrentUsage();
     // We don't check to prune until after we've allocated new space for files,
     // so we should leave a buffer under our target to account for another
     // allocation before the next pruning.
     uint64_t nBuffer = BLOCKFILE_CHUNK_SIZE + UNDOFILE_CHUNK_SIZE;
     uint64_t nBytesToPrune;
     int count = 0;
 
     if (nCurrentUsage + nBuffer >= nPruneTarget) {
         // On a prune event, the chainstate DB is flushed.
         // To avoid excessive prune events negating the benefit of high dbcache
         // values, we should not prune too rapidly.
         // So when pruning in IBD, increase the buffer a bit to avoid a re-prune
         // too soon.
         if (::ChainstateActive().IsInitialBlockDownload()) {
             // Since this is only relevant during IBD, we use a fixed 10%
             nBuffer += nPruneTarget / 10;
         }
 
         for (int fileNumber = 0; fileNumber < nLastBlockFile; fileNumber++) {
             nBytesToPrune = vinfoBlockFile[fileNumber].nSize +
                             vinfoBlockFile[fileNumber].nUndoSize;
 
             if (vinfoBlockFile[fileNumber].nSize == 0) {
                 continue;
             }
 
             // are we below our target?
             if (nCurrentUsage + nBuffer < nPruneTarget) {
                 break;
             }
 
             // don't prune files that could have a block within
             // MIN_BLOCKS_TO_KEEP of the main chain's tip but keep scanning
             if (vinfoBlockFile[fileNumber].nHeightLast > nLastBlockWeCanPrune) {
                 continue;
             }
 
             PruneOneBlockFile(fileNumber);
             // Queue up the files for removal
             setFilesToPrune.insert(fileNumber);
             nCurrentUsage -= nBytesToPrune;
             count++;
         }
     }
 
     LogPrint(BCLog::PRUNE,
              "Prune: target=%dMiB actual=%dMiB diff=%dMiB "
              "max_prune_height=%d removed %d blk/rev pairs\n",
              nPruneTarget / 1024 / 1024, nCurrentUsage / 1024 / 1024,
              ((int64_t)nPruneTarget - (int64_t)nCurrentUsage) / 1024 / 1024,
              nLastBlockWeCanPrune, count);
 }
 
 static FlatFileSeq BlockFileSeq() {
     return FlatFileSeq(GetBlocksDir(), "blk", BLOCKFILE_CHUNK_SIZE);
 }
 
 static FlatFileSeq UndoFileSeq() {
     return FlatFileSeq(GetBlocksDir(), "rev", UNDOFILE_CHUNK_SIZE);
 }
 
 FILE *OpenBlockFile(const FlatFilePos &pos, bool fReadOnly) {
     return BlockFileSeq().Open(pos, fReadOnly);
 }
 
 /** Open an undo file (rev?????.dat) */
 static FILE *OpenUndoFile(const FlatFilePos &pos, bool fReadOnly) {
     return UndoFileSeq().Open(pos, fReadOnly);
 }
 
 fs::path GetBlockPosFilename(const FlatFilePos &pos) {
     return BlockFileSeq().FileName(pos);
 }
 
 CBlockIndex *CChainState::InsertBlockIndex(const BlockHash &hash) {
     AssertLockHeld(cs_main);
 
     if (hash.IsNull()) {
         return nullptr;
     }
 
     // Return existing
     BlockMap::iterator mi = mapBlockIndex.find(hash);
     if (mi != mapBlockIndex.end()) {
         return (*mi).second;
     }
 
     // Create new
     CBlockIndex *pindexNew = new CBlockIndex();
     mi = mapBlockIndex.insert(std::make_pair(hash, pindexNew)).first;
     pindexNew->phashBlock = &((*mi).first);
 
     return pindexNew;
 }
 
 bool CChainState::LoadBlockIndex(const Config &config,
                                  CBlockTreeDB &blocktree) {
     AssertLockHeld(cs_main);
     if (!blocktree.LoadBlockIndexGuts(
             config.GetChainParams().GetConsensus(),
             [this](const BlockHash &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
                 return this->InsertBlockIndex(hash);
             })) {
         return false;
     }
 
     // Calculate nChainWork
     std::vector<std::pair<int, CBlockIndex *>> vSortedByHeight;
     vSortedByHeight.reserve(mapBlockIndex.size());
     for (const std::pair<const BlockHash, CBlockIndex *> &item :
          mapBlockIndex) {
         CBlockIndex *pindex = item.second;
         vSortedByHeight.push_back(std::make_pair(pindex->nHeight, pindex));
     }
 
     sort(vSortedByHeight.begin(), vSortedByHeight.end());
     for (const std::pair<int, CBlockIndex *> &item : vSortedByHeight) {
         CBlockIndex *pindex = item.second;
         pindex->nChainWork = (pindex->pprev ? pindex->pprev->nChainWork : 0) +
                              GetBlockProof(*pindex);
         pindex->nTimeMax =
             (pindex->pprev ? std::max(pindex->pprev->nTimeMax, pindex->nTime)
                            : pindex->nTime);
         // We can link the chain of blocks for which we've received transactions
         // at some point. Pruned nodes may have deleted the block.
         if (pindex->nTx > 0) {
             if (pindex->pprev) {
                 if (pindex->pprev->HaveTxsDownloaded()) {
                     pindex->nChainTx = pindex->pprev->nChainTx + pindex->nTx;
                 } else {
                     pindex->nChainTx = 0;
                     mapBlocksUnlinked.insert(
                         std::make_pair(pindex->pprev, pindex));
                 }
             } else {
                 pindex->nChainTx = pindex->nTx;
             }
         }
 
         if (!pindex->nStatus.hasFailed() && pindex->pprev &&
             pindex->pprev->nStatus.hasFailed()) {
             pindex->nStatus = pindex->nStatus.withFailedParent();
             setDirtyBlockIndex.insert(pindex);
         }
         if (pindex->IsValid(BlockValidity::TRANSACTIONS) &&
             (pindex->HaveTxsDownloaded() || pindex->pprev == nullptr)) {
             setBlockIndexCandidates.insert(pindex);
         }
 
         if (pindex->nStatus.isInvalid() &&
             (!pindexBestInvalid ||
              pindex->nChainWork > pindexBestInvalid->nChainWork)) {
             pindexBestInvalid = pindex;
         }
 
         if (pindex->nStatus.isOnParkedChain() &&
             (!pindexBestParked ||
              pindex->nChainWork > pindexBestParked->nChainWork)) {
             pindexBestParked = pindex;
         }
 
         if (pindex->pprev) {
             pindex->BuildSkip();
         }
 
         if (pindex->IsValid(BlockValidity::TREE) &&
             (pindexBestHeader == nullptr ||
              CBlockIndexWorkComparator()(pindexBestHeader, pindex))) {
             pindexBestHeader = pindex;
         }
     }
 
     return true;
 }
 
 static bool LoadBlockIndexDB(const Config &config)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     if (!::ChainstateActive().LoadBlockIndex(config, *pblocktree)) {
         return false;
     }
 
     // Load block file info
     pblocktree->ReadLastBlockFile(nLastBlockFile);
     vinfoBlockFile.resize(nLastBlockFile + 1);
     LogPrintf("%s: last block file = %i\n", __func__, nLastBlockFile);
     for (int nFile = 0; nFile <= nLastBlockFile; nFile++) {
         pblocktree->ReadBlockFileInfo(nFile, vinfoBlockFile[nFile]);
     }
 
     LogPrintf("%s: last block file info: %s\n", __func__,
               vinfoBlockFile[nLastBlockFile].ToString());
 
     for (int nFile = nLastBlockFile + 1; true; nFile++) {
         CBlockFileInfo info;
         if (pblocktree->ReadBlockFileInfo(nFile, info)) {
             vinfoBlockFile.push_back(info);
         } else {
             break;
         }
     }
 
     // Check presence of blk files
     LogPrintf("Checking all blk files are present...\n");
     std::set<int> setBlkDataFiles;
     for (const std::pair<const BlockHash, CBlockIndex *> &item :
          mapBlockIndex) {
         CBlockIndex *pindex = item.second;
         if (pindex->nStatus.hasData()) {
             setBlkDataFiles.insert(pindex->nFile);
         }
     }
 
     for (const int i : setBlkDataFiles) {
         FlatFilePos pos(i, 0);
         if (CAutoFile(OpenBlockFile(pos, true), SER_DISK, CLIENT_VERSION)
                 .IsNull()) {
             return false;
         }
     }
 
     // Check whether we have ever pruned block & undo files
     pblocktree->ReadFlag("prunedblockfiles", fHavePruned);
     if (fHavePruned) {
         LogPrintf(
             "LoadBlockIndexDB(): Block files have previously been pruned\n");
     }
 
     // Check whether we need to continue reindexing
     bool fReindexing = false;
     pblocktree->ReadReindexing(fReindexing);
     if (fReindexing) {
         fReindex = true;
     }
 
     return true;
 }
 
 bool LoadChainTip(const Config &config) {
     AssertLockHeld(cs_main);
 
     if (::ChainActive().Tip() &&
         ::ChainActive().Tip()->GetBlockHash() == pcoinsTip->GetBestBlock()) {
         return true;
     }
 
     if (pcoinsTip->GetBestBlock().IsNull() && mapBlockIndex.size() == 1) {
         // In case we just added the genesis block, connect it now, so
         // that we always have a ::ChainActive().Tip() when we return.
         LogPrintf("%s: Connecting genesis block...\n", __func__);
         CValidationState state;
         if (!ActivateBestChain(config, state)) {
             LogPrintf("%s: failed to activate chain (%s)\n", __func__,
                       FormatStateMessage(state));
             return false;
         }
     }
 
     // Load pointer to end of best chain
     CBlockIndex *pindex = LookupBlockIndex(pcoinsTip->GetBestBlock());
     if (!pindex) {
         return false;
     }
     ::ChainActive().SetTip(pindex);
 
     ::ChainstateActive().PruneBlockIndexCandidates();
 
     LogPrintf(
         "Loaded best chain: hashBestChain=%s height=%d date=%s progress=%f\n",
         ::ChainActive().Tip()->GetBlockHash().ToString(),
         ::ChainActive().Height(),
         FormatISO8601DateTime(::ChainActive().Tip()->GetBlockTime()),
         GuessVerificationProgress(config.GetChainParams().TxData(),
                                   ::ChainActive().Tip()));
     return true;
 }
 
 CVerifyDB::CVerifyDB() {
     uiInterface.ShowProgress(_("Verifying blocks...").translated, 0, false);
 }
 
 CVerifyDB::~CVerifyDB() {
     uiInterface.ShowProgress("", 100, false);
 }
 
 bool CVerifyDB::VerifyDB(const Config &config, CCoinsView *coinsview,
                          int nCheckLevel, int nCheckDepth) {
     LOCK(cs_main);
 
     const CChainParams &params = config.GetChainParams();
     const Consensus::Params &consensusParams = params.GetConsensus();
 
     if (::ChainActive().Tip() == nullptr ||
         ::ChainActive().Tip()->pprev == nullptr) {
         return true;
     }
 
     // Verify blocks in the best chain
     if (nCheckDepth <= 0 || nCheckDepth > ::ChainActive().Height()) {
         nCheckDepth = ::ChainActive().Height();
     }
 
     nCheckLevel = std::max(0, std::min(4, nCheckLevel));
     LogPrintf("Verifying last %i blocks at level %i\n", nCheckDepth,
               nCheckLevel);
 
     CCoinsViewCache coins(coinsview);
     CBlockIndex *pindex;
     CBlockIndex *pindexFailure = nullptr;
     int nGoodTransactions = 0;
     CValidationState state;
     int reportDone = 0;
     LogPrintfToBeContinued("[0%%]...");
     for (pindex = ::ChainActive().Tip(); pindex && pindex->pprev;
          pindex = pindex->pprev) {
         boost::this_thread::interruption_point();
         int percentageDone =
             std::max(1, std::min(99, (int)(((double)(::ChainActive().Height() -
                                                      pindex->nHeight)) /
                                            (double)nCheckDepth *
                                            (nCheckLevel >= 4 ? 50 : 100))));
 
         if (reportDone < percentageDone / 10) {
             // report every 10% step
             LogPrintfToBeContinued("[%d%%]...", percentageDone);
             reportDone = percentageDone / 10;
         }
 
         uiInterface.ShowProgress(_("Verifying blocks...").translated,
                                  percentageDone, false);
         if (pindex->nHeight <= ::ChainActive().Height() - nCheckDepth) {
             break;
         }
 
         if (fPruneMode && !pindex->nStatus.hasData()) {
             // If pruning, only go back as far as we have data.
             LogPrintf("VerifyDB(): block verification stopping at height %d "
                       "(pruning, no data)\n",
                       pindex->nHeight);
             break;
         }
 
         CBlock block;
 
         // check level 0: read from disk
         if (!ReadBlockFromDisk(block, pindex, consensusParams)) {
             return error(
                 "VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s",
                 pindex->nHeight, pindex->GetBlockHash().ToString());
         }
 
         // check level 1: verify block validity
         if (nCheckLevel >= 1 && !CheckBlock(block, state, consensusParams,
                                             BlockValidationOptions(config))) {
             return error("%s: *** found bad block at %d, hash=%s (%s)\n",
                          __func__, pindex->nHeight,
                          pindex->GetBlockHash().ToString(),
                          FormatStateMessage(state));
         }
 
         // check level 2: verify undo validity
         if (nCheckLevel >= 2 && pindex) {
             CBlockUndo undo;
             if (!pindex->GetUndoPos().IsNull()) {
                 if (!UndoReadFromDisk(undo, pindex)) {
                     return error(
                         "VerifyDB(): *** found bad undo data at %d, hash=%s\n",
                         pindex->nHeight, pindex->GetBlockHash().ToString());
                 }
             }
         }
 
         // check level 3: check for inconsistencies during memory-only
         // disconnect of tip blocks
         if (nCheckLevel >= 3 &&
             (coins.DynamicMemoryUsage() + pcoinsTip->DynamicMemoryUsage()) <=
                 nCoinCacheUsage) {
             assert(coins.GetBestBlock() == pindex->GetBlockHash());
             DisconnectResult res =
                 ::ChainstateActive().DisconnectBlock(block, pindex, coins);
             if (res == DisconnectResult::FAILED) {
                 return error("VerifyDB(): *** irrecoverable inconsistency in "
                              "block data at %d, hash=%s",
                              pindex->nHeight,
                              pindex->GetBlockHash().ToString());
             }
 
             if (res == DisconnectResult::UNCLEAN) {
                 nGoodTransactions = 0;
                 pindexFailure = pindex;
             } else {
                 nGoodTransactions += block.vtx.size();
             }
         }
 
         if (ShutdownRequested()) {
             return true;
         }
     }
 
     if (pindexFailure) {
         return error("VerifyDB(): *** coin database inconsistencies found "
                      "(last %i blocks, %i good transactions before that)\n",
                      ::ChainActive().Height() - pindexFailure->nHeight + 1,
                      nGoodTransactions);
     }
 
     // store block count as we move pindex at check level >= 4
     int block_count = ::ChainActive().Height() - pindex->nHeight;
 
     // check level 4: try reconnecting blocks
     if (nCheckLevel >= 4) {
         while (pindex != ::ChainActive().Tip()) {
             boost::this_thread::interruption_point();
             uiInterface.ShowProgress(
                 _("Verifying blocks...").translated,
                 std::max(
                     1, std::min(99,
                                 100 - (int)(((double)(::ChainActive().Height() -
                                                       pindex->nHeight)) /
                                             (double)nCheckDepth * 50))),
                 false);
             pindex = ::ChainActive().Next(pindex);
             CBlock block;
             if (!ReadBlockFromDisk(block, pindex, consensusParams)) {
                 return error(
                     "VerifyDB(): *** ReadBlockFromDisk failed at %d, hash=%s",
                     pindex->nHeight, pindex->GetBlockHash().ToString());
             }
             if (!::ChainstateActive().ConnectBlock(
                     block, state, pindex, coins, params,
                     BlockValidationOptions(config))) {
                 return error("VerifyDB(): *** found unconnectable block at %d, "
                              "hash=%s (%s)",
                              pindex->nHeight, pindex->GetBlockHash().ToString(),
                              FormatStateMessage(state));
             }
         }
     }
 
     LogPrintf("[DONE].\n");
     LogPrintf("No coin database inconsistencies in last %i blocks (%i "
               "transactions)\n",
               block_count, nGoodTransactions);
 
     return true;
 }
 
 /**
  * Apply the effects of a block on the utxo cache, ignoring that it may already
  * have been applied.
  */
 bool CChainState::RollforwardBlock(const CBlockIndex *pindex,
                                    CCoinsViewCache &view,
                                    const Consensus::Params &params) {
     // TODO: merge with ConnectBlock
     CBlock block;
     if (!ReadBlockFromDisk(block, pindex, params)) {
         return error("ReplayBlock(): ReadBlockFromDisk failed at %d, hash=%s",
                      pindex->nHeight, pindex->GetBlockHash().ToString());
     }
 
     for (const CTransactionRef &tx : block.vtx) {
         // Pass check = true as every addition may be an overwrite.
         AddCoins(view, *tx, pindex->nHeight, true);
     }
 
     for (const CTransactionRef &tx : block.vtx) {
         if (tx->IsCoinBase()) {
             continue;
         }
 
         for (const CTxIn &txin : tx->vin) {
             view.SpendCoin(txin.prevout);
         }
     }
 
     return true;
 }
 
 bool CChainState::ReplayBlocks(const Consensus::Params &params,
                                CCoinsView *view) {
     LOCK(cs_main);
 
     CCoinsViewCache cache(view);
 
     std::vector<BlockHash> hashHeads = view->GetHeadBlocks();
     if (hashHeads.empty()) {
         // We're already in a consistent state.
         return true;
     }
 
     if (hashHeads.size() != 2) {
         return error("ReplayBlocks(): unknown inconsistent state");
     }
 
     uiInterface.ShowProgress(_("Replaying blocks...").translated, 0, false);
     LogPrintf("Replaying blocks\n");
 
     // Old tip during the interrupted flush.
     const CBlockIndex *pindexOld = nullptr;
     // New tip during the interrupted flush.
     const CBlockIndex *pindexNew;
     // Latest block common to both the old and the new tip.
     const CBlockIndex *pindexFork = nullptr;
 
     if (mapBlockIndex.count(hashHeads[0]) == 0) {
         return error(
             "ReplayBlocks(): reorganization to unknown block requested");
     }
 
     pindexNew = mapBlockIndex[hashHeads[0]];
 
     if (!hashHeads[1].IsNull()) {
         // The old tip is allowed to be 0, indicating it's the first flush.
         if (mapBlockIndex.count(hashHeads[1]) == 0) {
             return error(
                 "ReplayBlocks(): reorganization from unknown block requested");
         }
 
         pindexOld = mapBlockIndex[hashHeads[1]];
         pindexFork = LastCommonAncestor(pindexOld, pindexNew);
         assert(pindexFork != nullptr);
     }
 
     // Rollback along the old branch.
     while (pindexOld != pindexFork) {
         if (pindexOld->nHeight > 0) {
             // Never disconnect the genesis block.
             CBlock block;
             if (!ReadBlockFromDisk(block, pindexOld, params)) {
                 return error("RollbackBlock(): ReadBlockFromDisk() failed at "
                              "%d, hash=%s",
                              pindexOld->nHeight,
                              pindexOld->GetBlockHash().ToString());
             }
 
             LogPrintf("Rolling back %s (%i)\n",
                       pindexOld->GetBlockHash().ToString(), pindexOld->nHeight);
             DisconnectResult res = DisconnectBlock(block, pindexOld, cache);
             if (res == DisconnectResult::FAILED) {
                 return error(
                     "RollbackBlock(): DisconnectBlock failed at %d, hash=%s",
                     pindexOld->nHeight, pindexOld->GetBlockHash().ToString());
             }
 
             // If DisconnectResult::UNCLEAN is returned, it means a non-existing
             // UTXO was deleted, or an existing UTXO was overwritten. It
             // corresponds to cases where the block-to-be-disconnect never had
             // all its operations applied to the UTXO set. However, as both
             // writing a UTXO and deleting a UTXO are idempotent operations, the
             // result is still a version of the UTXO set with the effects of
             // that block undone.
         }
         pindexOld = pindexOld->pprev;
     }
 
     // Roll forward from the forking point to the new tip.
     int nForkHeight = pindexFork ? pindexFork->nHeight : 0;
     for (int nHeight = nForkHeight + 1; nHeight <= pindexNew->nHeight;
          ++nHeight) {
         const CBlockIndex *pindex = pindexNew->GetAncestor(nHeight);
         LogPrintf("Rolling forward %s (%i)\n",
                   pindex->GetBlockHash().ToString(), nHeight);
         if (!RollforwardBlock(pindex, cache, params)) {
             return false;
         }
     }
 
     cache.SetBestBlock(pindexNew->GetBlockHash());
     cache.Flush();
     uiInterface.ShowProgress("", 100, false);
     return true;
 }
 
 bool ReplayBlocks(const Consensus::Params &params, CCoinsView *view) {
     return ::ChainstateActive().ReplayBlocks(params, view);
 }
 
 // May NOT be used after any connections are up as much of the peer-processing
 // logic assumes a consistent block index state
 void CChainState::UnloadBlockIndex() {
     nBlockSequenceId = 1;
     m_failed_blocks.clear();
     setBlockIndexCandidates.clear();
 }
 
 // May NOT be used after any connections are up as much
 // of the peer-processing logic assumes a consistent
 // block index state
 void UnloadBlockIndex() {
     LOCK(cs_main);
     ::ChainActive().SetTip(nullptr);
     pindexFinalized = nullptr;
     pindexBestInvalid = nullptr;
     pindexBestParked = nullptr;
     pindexBestHeader = nullptr;
     pindexBestForkTip = nullptr;
     pindexBestForkBase = nullptr;
     g_mempool.clear();
     mapBlocksUnlinked.clear();
     vinfoBlockFile.clear();
     nLastBlockFile = 0;
     setDirtyBlockIndex.clear();
     setDirtyFileInfo.clear();
 
     for (const BlockMap::value_type &entry : mapBlockIndex) {
         delete entry.second;
     }
 
     mapBlockIndex.clear();
     fHavePruned = false;
 
     ::ChainstateActive().UnloadBlockIndex();
 }
 
 bool LoadBlockIndex(const Config &config) {
     // Load block index from databases
     bool needs_init = fReindex;
     if (!fReindex) {
         bool ret = LoadBlockIndexDB(config);
         if (!ret) {
             return false;
         }
 
         needs_init = mapBlockIndex.empty();
     }
 
     if (needs_init) {
         // Everything here is for *new* reindex/DBs. Thus, though
         // LoadBlockIndexDB may have set fReindex if we shut down
         // mid-reindex previously, we don't check fReindex and
         // instead only check it prior to LoadBlockIndexDB to set
         // needs_init.
 
         LogPrintf("Initializing databases...\n");
     }
     return true;
 }
 
 bool CChainState::LoadGenesisBlock(const CChainParams &chainparams) {
     LOCK(cs_main);
 
     // Check whether we're already initialized by checking for genesis in
     // mapBlockIndex. Note that we can't use m_chain here, since it is
     // set based on the coins db, not the block index db, which is the only
     // thing loaded at this point.
     if (mapBlockIndex.count(chainparams.GenesisBlock().GetHash())) {
         return true;
     }
 
     try {
         const CBlock &block = chainparams.GenesisBlock();
         FlatFilePos blockPos = SaveBlockToDisk(block, 0, chainparams, nullptr);
         if (blockPos.IsNull()) {
             return error("%s: writing genesis block to disk failed", __func__);
         }
         CBlockIndex *pindex = AddToBlockIndex(block);
         ReceivedBlockTransactions(block, pindex, blockPos);
     } catch (const std::runtime_error &e) {
         return error("%s: failed to write genesis block: %s", __func__,
                      e.what());
     }
 
     return true;
 }
 
 bool LoadGenesisBlock(const CChainParams &chainparams) {
     return ::ChainstateActive().LoadGenesisBlock(chainparams);
 }
 
 bool LoadExternalBlockFile(const Config &config, FILE *fileIn,
                            FlatFilePos *dbp) {
     // Map of disk positions for blocks with unknown parent (only used for
     // reindex)
     static std::multimap<uint256, FlatFilePos> mapBlocksUnknownParent;
     int64_t nStart = GetTimeMillis();
 
     const CChainParams &chainparams = config.GetChainParams();
 
     int nLoaded = 0;
     try {
         // This takes over fileIn and calls fclose() on it in the CBufferedFile
         // destructor. Make sure we have at least 2*MAX_TX_SIZE space in there
         // so any transaction can fit in the buffer.
         CBufferedFile blkdat(fileIn, 2 * MAX_TX_SIZE, MAX_TX_SIZE + 8, SER_DISK,
                              CLIENT_VERSION);
         uint64_t nRewind = blkdat.GetPos();
         while (!blkdat.eof()) {
             boost::this_thread::interruption_point();
 
             blkdat.SetPos(nRewind);
             // Start one byte further next time, in case of failure.
             nRewind++;
             // Remove former limit.
             blkdat.SetLimit();
             unsigned int nSize = 0;
             try {
                 // Locate a header.
                 uint8_t buf[CMessageHeader::MESSAGE_START_SIZE];
                 blkdat.FindByte(chainparams.DiskMagic()[0]);
                 nRewind = blkdat.GetPos() + 1;
                 blkdat >> buf;
                 if (memcmp(buf, chainparams.DiskMagic().data(),
                            CMessageHeader::MESSAGE_START_SIZE)) {
                     continue;
                 }
 
                 // Read size.
                 blkdat >> nSize;
                 if (nSize < 80) {
                     continue;
                 }
             } catch (const std::exception &) {
                 // No valid block header found; don't complain.
                 break;
             }
 
             try {
                 // read block
                 uint64_t nBlockPos = blkdat.GetPos();
                 if (dbp) {
                     dbp->nPos = nBlockPos;
                 }
                 blkdat.SetLimit(nBlockPos + nSize);
                 blkdat.SetPos(nBlockPos);
                 std::shared_ptr<CBlock> pblock = std::make_shared<CBlock>();
                 CBlock &block = *pblock;
                 blkdat >> block;
                 nRewind = blkdat.GetPos();
 
                 const BlockHash hash = block.GetHash();
                 {
                     LOCK(cs_main);
                     // detect out of order blocks, and store them for later
                     if (hash != chainparams.GetConsensus().hashGenesisBlock &&
                         !LookupBlockIndex(block.hashPrevBlock)) {
                         LogPrint(
                             BCLog::REINDEX,
                             "%s: Out of order block %s, parent %s not known\n",
                             __func__, hash.ToString(),
                             block.hashPrevBlock.ToString());
                         if (dbp) {
                             mapBlocksUnknownParent.insert(
                                 std::make_pair(block.hashPrevBlock, *dbp));
                         }
                         continue;
                     }
 
                     // process in case the block isn't known yet
                     CBlockIndex *pindex = LookupBlockIndex(hash);
                     if (!pindex || !pindex->nStatus.hasData()) {
                         CValidationState state;
                         if (::ChainstateActive().AcceptBlock(
                                 config, pblock, state, true, dbp, nullptr)) {
                             nLoaded++;
                         }
                         if (state.IsError()) {
                             break;
                         }
                     } else if (hash != chainparams.GetConsensus()
                                            .hashGenesisBlock &&
                                pindex->nHeight % 1000 == 0) {
                         LogPrint(
                             BCLog::REINDEX,
                             "Block Import: already had block %s at height %d\n",
                             hash.ToString(), pindex->nHeight);
                     }
                 }
 
                 // Activate the genesis block so normal node progress can
                 // continue
                 if (hash == chainparams.GetConsensus().hashGenesisBlock) {
                     CValidationState state;
                     if (!ActivateBestChain(config, state)) {
                         break;
                     }
                 }
 
                 NotifyHeaderTip();
 
                 // Recursively process earlier encountered successors of this
                 // block
                 std::deque<uint256> queue;
                 queue.push_back(hash);
                 while (!queue.empty()) {
                     uint256 head = queue.front();
                     queue.pop_front();
                     std::pair<std::multimap<uint256, FlatFilePos>::iterator,
                               std::multimap<uint256, FlatFilePos>::iterator>
                         range = mapBlocksUnknownParent.equal_range(head);
                     while (range.first != range.second) {
                         std::multimap<uint256, FlatFilePos>::iterator it =
                             range.first;
                         std::shared_ptr<CBlock> pblockrecursive =
                             std::make_shared<CBlock>();
                         if (ReadBlockFromDisk(*pblockrecursive, it->second,
                                               chainparams.GetConsensus())) {
                             LogPrint(
                                 BCLog::REINDEX,
                                 "%s: Processing out of order child %s of %s\n",
                                 __func__, pblockrecursive->GetHash().ToString(),
                                 head.ToString());
                             LOCK(cs_main);
                             CValidationState dummy;
                             if (::ChainstateActive().AcceptBlock(
                                     config, pblockrecursive, dummy, true,
                                     &it->second, nullptr)) {
                                 nLoaded++;
                                 queue.push_back(pblockrecursive->GetHash());
                             }
                         }
                         range.first++;
                         mapBlocksUnknownParent.erase(it);
                         NotifyHeaderTip();
                     }
                 }
             } catch (const std::exception &e) {
                 LogPrintf("%s: Deserialize or I/O error - %s\n", __func__,
                           e.what());
             }
         }
     } catch (const std::runtime_error &e) {
         AbortNode(std::string("System error: ") + e.what());
     }
 
     if (nLoaded > 0) {
         LogPrintf("Loaded %i blocks from external file in %dms\n", nLoaded,
                   GetTimeMillis() - nStart);
     }
 
     return nLoaded > 0;
 }
 
 void CChainState::CheckBlockIndex(const Consensus::Params &consensusParams) {
     if (!fCheckBlockIndex) {
         return;
     }
 
     LOCK(cs_main);
 
     // During a reindex, we read the genesis block and call CheckBlockIndex
     // before ActivateBestChain, so we have the genesis block in mapBlockIndex
     // but no active chain. (A few of the tests when iterating the block tree
     // require that m_chain has been initialized.)
     if (m_chain.Height() < 0) {
         assert(mapBlockIndex.size() <= 1);
         return;
     }
 
     // Build forward-pointing map of the entire block tree.
     std::multimap<CBlockIndex *, CBlockIndex *> forward;
     for (const auto &entry : mapBlockIndex) {
         forward.emplace(entry.second->pprev, entry.second);
     }
 
     assert(forward.size() == mapBlockIndex.size());
 
     std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
               std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
         rangeGenesis = forward.equal_range(nullptr);
     CBlockIndex *pindex = rangeGenesis.first->second;
     rangeGenesis.first++;
     // There is only one index entry with parent nullptr.
     assert(rangeGenesis.first == rangeGenesis.second);
 
     // Iterate over the entire block tree, using depth-first search.
     // Along the way, remember whether there are blocks on the path from genesis
     // block being explored which are the first to have certain properties.
     size_t nNodes = 0;
     int nHeight = 0;
     // Oldest ancestor of pindex which is invalid.
     CBlockIndex *pindexFirstInvalid = nullptr;
     // Oldest ancestor of pindex which is parked.
     CBlockIndex *pindexFirstParked = nullptr;
     // Oldest ancestor of pindex which does not have data available.
     CBlockIndex *pindexFirstMissing = nullptr;
     // Oldest ancestor of pindex for which nTx == 0.
     CBlockIndex *pindexFirstNeverProcessed = nullptr;
     // Oldest ancestor of pindex which does not have BLOCK_VALID_TREE
     // (regardless of being valid or not).
     CBlockIndex *pindexFirstNotTreeValid = nullptr;
     // Oldest ancestor of pindex which does not have BLOCK_VALID_TRANSACTIONS
     // (regardless of being valid or not).
     CBlockIndex *pindexFirstNotTransactionsValid = nullptr;
     // Oldest ancestor of pindex which does not have BLOCK_VALID_CHAIN
     // (regardless of being valid or not).
     CBlockIndex *pindexFirstNotChainValid = nullptr;
     // Oldest ancestor of pindex which does not have BLOCK_VALID_SCRIPTS
     // (regardless of being valid or not).
     CBlockIndex *pindexFirstNotScriptsValid = nullptr;
     while (pindex != nullptr) {
         nNodes++;
         if (pindexFirstInvalid == nullptr && pindex->nStatus.hasFailed()) {
             pindexFirstInvalid = pindex;
         }
         if (pindexFirstParked == nullptr && pindex->nStatus.isParked()) {
             pindexFirstParked = pindex;
         }
         if (pindexFirstMissing == nullptr && !pindex->nStatus.hasData()) {
             pindexFirstMissing = pindex;
         }
         if (pindexFirstNeverProcessed == nullptr && pindex->nTx == 0) {
             pindexFirstNeverProcessed = pindex;
         }
         if (pindex->pprev != nullptr && pindexFirstNotTreeValid == nullptr &&
             pindex->nStatus.getValidity() < BlockValidity::TREE) {
             pindexFirstNotTreeValid = pindex;
         }
         if (pindex->pprev != nullptr &&
             pindexFirstNotTransactionsValid == nullptr &&
             pindex->nStatus.getValidity() < BlockValidity::TRANSACTIONS) {
             pindexFirstNotTransactionsValid = pindex;
         }
         if (pindex->pprev != nullptr && pindexFirstNotChainValid == nullptr &&
             pindex->nStatus.getValidity() < BlockValidity::CHAIN) {
             pindexFirstNotChainValid = pindex;
         }
         if (pindex->pprev != nullptr && pindexFirstNotScriptsValid == nullptr &&
             pindex->nStatus.getValidity() < BlockValidity::SCRIPTS) {
             pindexFirstNotScriptsValid = pindex;
         }
 
         // Begin: actual consistency checks.
         if (pindex->pprev == nullptr) {
             // Genesis block checks.
             // Genesis block's hash must match.
             assert(pindex->GetBlockHash() == consensusParams.hashGenesisBlock);
             // The current active chain's genesis block must be this block.
             assert(pindex == m_chain.Genesis());
         }
         if (!pindex->HaveTxsDownloaded()) {
             // nSequenceId can't be set positive for blocks that aren't linked
             // (negative is used for preciousblock)
             assert(pindex->nSequenceId <= 0);
         }
         // VALID_TRANSACTIONS is equivalent to nTx > 0 for all nodes (whether or
         // not pruning has occurred). HAVE_DATA is only equivalent to nTx > 0
         // (or VALID_TRANSACTIONS) if no pruning has occurred.
         if (!fHavePruned) {
             // If we've never pruned, then HAVE_DATA should be equivalent to nTx
             // > 0
             assert(pindex->nStatus.hasData() == (pindex->nTx > 0));
             assert(pindexFirstMissing == pindexFirstNeverProcessed);
         } else if (pindex->nStatus.hasData()) {
             // If we have pruned, then we can only say that HAVE_DATA implies
             // nTx > 0
             assert(pindex->nTx > 0);
         }
         if (pindex->nStatus.hasUndo()) {
             assert(pindex->nStatus.hasData());
         }
         // This is pruning-independent.
         assert((pindex->nStatus.getValidity() >= BlockValidity::TRANSACTIONS) ==
                (pindex->nTx > 0));
         // All parents having had data (at some point) is equivalent to all
         // parents being VALID_TRANSACTIONS, which is equivalent to
         // HaveTxsDownloaded(). All parents having had data (at some point) is
         // equivalent to all parents being VALID_TRANSACTIONS, which is
         // equivalent to HaveTxsDownloaded().
         assert((pindexFirstNeverProcessed == nullptr) ==
                (pindex->HaveTxsDownloaded()));
         assert((pindexFirstNotTransactionsValid == nullptr) ==
                (pindex->HaveTxsDownloaded()));
         // nHeight must be consistent.
         assert(pindex->nHeight == nHeight);
         // For every block except the genesis block, the chainwork must be
         // larger than the parent's.
         assert(pindex->pprev == nullptr ||
                pindex->nChainWork >= pindex->pprev->nChainWork);
         // The pskip pointer must point back for all but the first 2 blocks.
         assert(nHeight < 2 ||
                (pindex->pskip && (pindex->pskip->nHeight < nHeight)));
         // All mapBlockIndex entries must at least be TREE valid
         assert(pindexFirstNotTreeValid == nullptr);
         if (pindex->nStatus.getValidity() >= BlockValidity::TREE) {
             // TREE valid implies all parents are TREE valid
             assert(pindexFirstNotTreeValid == nullptr);
         }
         if (pindex->nStatus.getValidity() >= BlockValidity::CHAIN) {
             // CHAIN valid implies all parents are CHAIN valid
             assert(pindexFirstNotChainValid == nullptr);
         }
         if (pindex->nStatus.getValidity() >= BlockValidity::SCRIPTS) {
             // SCRIPTS valid implies all parents are SCRIPTS valid
             assert(pindexFirstNotScriptsValid == nullptr);
         }
         if (pindexFirstInvalid == nullptr) {
             // Checks for not-invalid blocks.
             // The failed mask cannot be set for blocks without invalid parents.
             assert(!pindex->nStatus.isInvalid());
         }
         if (pindexFirstParked == nullptr) {
             // Checks for not-parked blocks.
             // The parked mask cannot be set for blocks without parked parents.
             // (i.e., hasParkedParent only if an ancestor is properly parked).
             assert(!pindex->nStatus.isOnParkedChain());
         }
         if (!CBlockIndexWorkComparator()(pindex, m_chain.Tip()) &&
             pindexFirstNeverProcessed == nullptr) {
             if (pindexFirstInvalid == nullptr) {
                 // If this block sorts at least as good as the current tip and
                 // is valid and we have all data for its parents, it must be in
                 // setBlockIndexCandidates or be parked.
                 if (pindexFirstMissing == nullptr) {
                     assert(pindex->nStatus.isOnParkedChain() ||
                            setBlockIndexCandidates.count(pindex));
                 }
                 // m_chain.Tip() must also be there even if some data has
                 // been pruned.
                 if (pindex == m_chain.Tip()) {
                     assert(setBlockIndexCandidates.count(pindex));
                 }
                 // If some parent is missing, then it could be that this block
                 // was in setBlockIndexCandidates but had to be removed because
                 // of the missing data. In this case it must be in
                 // mapBlocksUnlinked -- see test below.
             }
         } else {
             // If this block sorts worse than the current tip or some ancestor's
             // block has never been seen, it cannot be in
             // setBlockIndexCandidates.
             assert(setBlockIndexCandidates.count(pindex) == 0);
         }
         // Check whether this block is in mapBlocksUnlinked.
         std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
                   std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
             rangeUnlinked = mapBlocksUnlinked.equal_range(pindex->pprev);
         bool foundInUnlinked = false;
         while (rangeUnlinked.first != rangeUnlinked.second) {
             assert(rangeUnlinked.first->first == pindex->pprev);
             if (rangeUnlinked.first->second == pindex) {
                 foundInUnlinked = true;
                 break;
             }
             rangeUnlinked.first++;
         }
         if (pindex->pprev && pindex->nStatus.hasData() &&
             pindexFirstNeverProcessed != nullptr &&
             pindexFirstInvalid == nullptr) {
             // If this block has block data available, some parent was never
             // received, and has no invalid parents, it must be in
             // mapBlocksUnlinked.
             assert(foundInUnlinked);
         }
         if (!pindex->nStatus.hasData()) {
             // Can't be in mapBlocksUnlinked if we don't HAVE_DATA
             assert(!foundInUnlinked);
         }
         if (pindexFirstMissing == nullptr) {
             // We aren't missing data for any parent -- cannot be in
             // mapBlocksUnlinked.
             assert(!foundInUnlinked);
         }
         if (pindex->pprev && pindex->nStatus.hasData() &&
             pindexFirstNeverProcessed == nullptr &&
             pindexFirstMissing != nullptr) {
             // We HAVE_DATA for this block, have received data for all parents
             // at some point, but we're currently missing data for some parent.
             // We must have pruned.
             assert(fHavePruned);
             // This block may have entered mapBlocksUnlinked if:
             //  - it has a descendant that at some point had more work than the
             //    tip, and
             //  - we tried switching to that descendant but were missing
             //    data for some intermediate block between m_chain and the
             //    tip.
             // So if this block is itself better than m_chain.Tip() and it
             // wasn't in
             // setBlockIndexCandidates, then it must be in mapBlocksUnlinked.
             if (!CBlockIndexWorkComparator()(pindex, m_chain.Tip()) &&
                 setBlockIndexCandidates.count(pindex) == 0) {
                 if (pindexFirstInvalid == nullptr) {
                     assert(foundInUnlinked);
                 }
             }
         }
         // Perhaps too slow
         // assert(pindex->GetBlockHash() == pindex->GetBlockHeader().GetHash());
         // End: actual consistency checks.
 
         // Try descending into the first subnode.
         std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
                   std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
             range = forward.equal_range(pindex);
         if (range.first != range.second) {
             // A subnode was found.
             pindex = range.first->second;
             nHeight++;
             continue;
         }
         // This is a leaf node. Move upwards until we reach a node of which we
         // have not yet visited the last child.
         while (pindex) {
             // We are going to either move to a parent or a sibling of pindex.
             // If pindex was the first with a certain property, unset the
             // corresponding variable.
             if (pindex == pindexFirstInvalid) {
                 pindexFirstInvalid = nullptr;
             }
             if (pindex == pindexFirstParked) {
                 pindexFirstParked = nullptr;
             }
             if (pindex == pindexFirstMissing) {
                 pindexFirstMissing = nullptr;
             }
             if (pindex == pindexFirstNeverProcessed) {
                 pindexFirstNeverProcessed = nullptr;
             }
             if (pindex == pindexFirstNotTreeValid) {
                 pindexFirstNotTreeValid = nullptr;
             }
             if (pindex == pindexFirstNotTransactionsValid) {
                 pindexFirstNotTransactionsValid = nullptr;
             }
             if (pindex == pindexFirstNotChainValid) {
                 pindexFirstNotChainValid = nullptr;
             }
             if (pindex == pindexFirstNotScriptsValid) {
                 pindexFirstNotScriptsValid = nullptr;
             }
             // Find our parent.
             CBlockIndex *pindexPar = pindex->pprev;
             // Find which child we just visited.
             std::pair<std::multimap<CBlockIndex *, CBlockIndex *>::iterator,
                       std::multimap<CBlockIndex *, CBlockIndex *>::iterator>
                 rangePar = forward.equal_range(pindexPar);
             while (rangePar.first->second != pindex) {
                 // Our parent must have at least the node we're coming from as
                 // child.
                 assert(rangePar.first != rangePar.second);
                 rangePar.first++;
             }
             // Proceed to the next one.
             rangePar.first++;
             if (rangePar.first != rangePar.second) {
                 // Move to the sibling.
                 pindex = rangePar.first->second;
                 break;
             } else {
                 // Move up further.
                 pindex = pindexPar;
                 nHeight--;
                 continue;
             }
         }
     }
 
     // Check that we actually traversed the entire map.
     assert(nNodes == forward.size());
 }
 
 std::string CBlockFileInfo::ToString() const {
     return strprintf(
         "CBlockFileInfo(blocks=%u, size=%u, heights=%u...%u, time=%s...%s)",
         nBlocks, nSize, nHeightFirst, nHeightLast,
         FormatISO8601DateTime(nTimeFirst), FormatISO8601DateTime(nTimeLast));
 }
 
 CBlockFileInfo *GetBlockFileInfo(size_t n) {
     LOCK(cs_LastBlockFile);
 
     return &vinfoBlockFile.at(n);
 }
 
 static ThresholdState VersionBitsStateImpl(const Consensus::Params &params,
                                            Consensus::DeploymentPos pos,
                                            const CBlockIndex *pindex)
     EXCLUSIVE_LOCKS_REQUIRED(cs_main) {
     return VersionBitsState(pindex, params, pos, versionbitscache);
 }
 
 ThresholdState VersionBitsTipState(const Consensus::Params &params,
                                    Consensus::DeploymentPos pos) {
     LOCK(cs_main);
     return VersionBitsStateImpl(params, pos, ::ChainActive().Tip());
 }
 
 ThresholdState VersionBitsBlockState(const Consensus::Params &params,
                                      Consensus::DeploymentPos pos,
                                      const CBlockIndex *pindex) {
     LOCK(cs_main);
     return VersionBitsStateImpl(params, pos, pindex);
 }
 
 BIP9Stats VersionBitsTipStatistics(const Consensus::Params &params,
                                    Consensus::DeploymentPos pos) {
     LOCK(cs_main);
     return VersionBitsStatistics(::ChainActive().Tip(), params, pos);
 }
 
 int VersionBitsTipStateSinceHeight(const Consensus::Params &params,
                                    Consensus::DeploymentPos pos) {
     LOCK(cs_main);
     return VersionBitsStateSinceHeight(::ChainActive().Tip(), params, pos,
                                        versionbitscache);
 }
 
 static const uint64_t MEMPOOL_DUMP_VERSION = 1;
 
 bool LoadMempool(const Config &config, CTxMemPool &pool) {
     int64_t nExpiryTimeout =
         gArgs.GetArg("-mempoolexpiry", DEFAULT_MEMPOOL_EXPIRY) * 60 * 60;
     FILE *filestr = fsbridge::fopen(GetDataDir() / "mempool.dat", "rb");
     CAutoFile file(filestr, SER_DISK, CLIENT_VERSION);
     if (file.IsNull()) {
         LogPrintf(
             "Failed to open mempool file from disk. Continuing anyway.\n");
         return false;
     }
 
     int64_t count = 0;
     int64_t expired = 0;
     int64_t failed = 0;
     int64_t already_there = 0;
     int64_t nNow = GetTime();
 
     try {
         uint64_t version;
         file >> version;
         if (version != MEMPOOL_DUMP_VERSION) {
             return false;
         }
 
         uint64_t num;
         file >> num;
         while (num--) {
             CTransactionRef tx;
             int64_t nTime;
             int64_t nFeeDelta;
             file >> tx;
             file >> nTime;
             file >> nFeeDelta;
 
             Amount amountdelta = nFeeDelta * SATOSHI;
             if (amountdelta != Amount::zero()) {
                 pool.PrioritiseTransaction(tx->GetId(), amountdelta);
             }
             CValidationState state;
             if (nTime + nExpiryTimeout > nNow) {
                 LOCK(cs_main);
                 AcceptToMemoryPoolWithTime(
                     config, pool, state, tx, nullptr /* pfMissingInputs */,
                     nTime, false /* bypass_limits */,
                     Amount::zero() /* nAbsurdFee */, false /* test_accept */);
                 if (state.IsValid()) {
                     ++count;
                 } else {
                     // mempool may contain the transaction already, e.g. from
                     // wallet(s) having loaded it while we were processing
                     // mempool transactions; consider these as valid, instead of
                     // failed, but mark them as 'already there'
                     if (pool.exists(tx->GetId())) {
                         ++already_there;
                     } else {
                         ++failed;
                     }
                 }
             } else {
                 ++expired;
             }
 
             if (ShutdownRequested()) {
                 return false;
             }
         }
         std::map<TxId, Amount> mapDeltas;
         file >> mapDeltas;
 
         for (const auto &i : mapDeltas) {
             pool.PrioritiseTransaction(i.first, i.second);
         }
     } catch (const std::exception &e) {
         LogPrintf("Failed to deserialize mempool data on disk: %s. Continuing "
                   "anyway.\n",
                   e.what());
         return false;
     }
 
     LogPrintf("Imported mempool transactions from disk: %i succeeded, %i "
               "failed, %i expired, %i already there\n",
               count, failed, expired, already_there);
     return true;
 }
 
 bool DumpMempool(const CTxMemPool &pool) {
     int64_t start = GetTimeMicros();
 
     std::map<uint256, Amount> mapDeltas;
     std::vector<TxMempoolInfo> vinfo;
 
     static Mutex dump_mutex;
     LOCK(dump_mutex);
 
     {
         LOCK(pool.cs);
         for (const auto &i : pool.mapDeltas) {
             mapDeltas[i.first] = i.second;
         }
 
         vinfo = pool.infoAll();
     }
 
     int64_t mid = GetTimeMicros();
 
     try {
         FILE *filestr = fsbridge::fopen(GetDataDir() / "mempool.dat.new", "wb");
         if (!filestr) {
             return false;
         }
 
         CAutoFile file(filestr, SER_DISK, CLIENT_VERSION);
 
         uint64_t version = MEMPOOL_DUMP_VERSION;
         file << version;
 
         file << uint64_t(vinfo.size());
         for (const auto &i : vinfo) {
             file << *(i.tx);
             file << int64_t(i.nTime);
             file << i.nFeeDelta;
             mapDeltas.erase(i.tx->GetId());
         }
 
         file << mapDeltas;
         if (!FileCommit(file.Get())) {
             throw std::runtime_error("FileCommit failed");
         }
         file.fclose();
         RenameOver(GetDataDir() / "mempool.dat.new",
                    GetDataDir() / "mempool.dat");
         int64_t last = GetTimeMicros();
         LogPrintf("Dumped mempool: %gs to copy, %gs to dump\n",
                   (mid - start) * MICRO, (last - mid) * MICRO);
     } catch (const std::exception &e) {
         LogPrintf("Failed to dump mempool: %s. Continuing anyway.\n", e.what());
         return false;
     }
     return true;
 }
 
 bool IsBlockPruned(const CBlockIndex *pblockindex) {
     return (fHavePruned && !pblockindex->nStatus.hasData() &&
             pblockindex->nTx > 0);
 }
 
 //! Guess how far we are in the verification process at the given block index
 //! require cs_main if pindex has not been validated yet (because nChainTx might
 //! be unset)
 //! This conditional lock requirement might be confusing, see:
 //! https://github.com/bitcoin/bitcoin/issues/15994
 double GuessVerificationProgress(const ChainTxData &data,
                                  const CBlockIndex *pindex) {
     if (pindex == nullptr) {
         return 0.0;
     }
 
     int64_t nNow = time(nullptr);
 
     double fTxTotal;
     if (pindex->nChainTx <= data.nTxCount) {
         fTxTotal = data.nTxCount + (nNow - data.nTime) * data.dTxRate;
     } else {
         fTxTotal =
             pindex->nChainTx + (nNow - pindex->GetBlockTime()) * data.dTxRate;
     }
 
     return pindex->nChainTx / fTxTotal;
 }
 
 class CMainCleanup {
 public:
     CMainCleanup() {}
     ~CMainCleanup() {
         // block headers
         for (const std::pair<const BlockHash, CBlockIndex *> &it :
              mapBlockIndex) {
             delete it.second;
         }
         mapBlockIndex.clear();
     }
 } instance_of_cmaincleanup;
diff --git a/test/functional/abc-op-reversebytes-activation.py b/test/functional/abc-op-reversebytes-activation.py
deleted file mode 100755
index 13692e49d0..0000000000
--- a/test/functional/abc-op-reversebytes-activation.py
+++ /dev/null
@@ -1,291 +0,0 @@
-#!/usr/bin/env python3
-# Copyright (c) 2020 The Bitcoin developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""
-This test checks the activation logic of OP_REVERSEBYTES.
-Derived from both abc-schnorrmultisig-activation.py (see https://reviews.bitcoinabc.org/D3736) and
-abc-schnorrmultisig.py
-"""
-
-from test_framework.blocktools import (
-    create_block,
-    create_coinbase,
-    create_tx_with_script,
-    make_conform_to_ctor,
-)
-from test_framework.messages import (
-    CBlock,
-    COutPoint,
-    CTransaction,
-    CTxIn,
-    CTxOut,
-    FromHex,
-    ToHex,
-)
-from test_framework.mininode import (
-    P2PDataStore,
-)
-from test_framework.script import (
-    CScript,
-    OP_EQUAL,
-    OP_REVERSEBYTES,
-    OP_RETURN,
-)
-from test_framework.test_framework import BitcoinTestFramework
-from test_framework.util import assert_equal, assert_raises_rpc_error
-
-
-# The upgrade activation time, which we artificially set far into the future.
-PHONON_START_TIME = 2000000000
-
-
-# Blocks with invalid scripts give this error:
-BAD_INPUTS_ERROR = 'blk-bad-inputs'
-
-# Pre-upgrade, we get a BAD_OPCODE error
-PRE_UPGRADE_BAD_OPCODE_ERROR = \
-    'upgrade-conditional-script-failure (Opcode missing or not understood)'
-
-
-class OpReversebytesActivationTest(BitcoinTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 1
-        self.block_heights = {}
-        self.extra_args = [
-            ["-phononactivationtime={}".format(PHONON_START_TIME),
-             "-acceptnonstdtxn=1"]]
-
-    def bootstrap_p2p(self, *, num_connections=1):
-        """Add a P2P connection to the node.
-
-        Helper to connect and wait for version handshake."""
-        for _ in range(num_connections):
-            self.nodes[0].add_p2p_connection(P2PDataStore())
-        self.nodes[0].p2p.wait_for_verack()
-
-    def reconnect_p2p(self, **kwargs):
-        """Tear down and bootstrap the P2P connection to the node.
-
-        The node gets disconnected several times in this test. This helper
-        method reconnects the p2p and restarts the network thread."""
-        self.nodes[0].disconnect_p2ps()
-        self.bootstrap_p2p(**kwargs)
-
-    def get_best_block(self, node):
-        """Get the best block. Register its height so we can use build_block."""
-        block_height = node.getblockcount()
-        blockhash = node.getblockhash(block_height)
-        block = FromHex(CBlock(), node.getblock(blockhash, 0))
-        block.calc_sha256()
-        self.block_heights[block.sha256] = block_height
-        return block
-
-    def build_block(self, parent, transactions=(), n_time=None):
-        """Make a new block with an OP_1 coinbase output.
-
-        Requires parent to have its height registered."""
-        parent.calc_sha256()
-        block_height = self.block_heights[parent.sha256] + 1
-        block_time = (parent.nTime + 1) if n_time is None else n_time
-
-        block = create_block(
-            parent.sha256, create_coinbase(block_height), block_time)
-        block.vtx.extend(transactions)
-        make_conform_to_ctor(block)
-        block.hashMerkleRoot = block.calc_merkle_root()
-        block.solve()
-        self.block_heights[block.sha256] = block_height
-        return block
-
-    def check_for_no_ban_on_rejected_tx(self, tx, reject_reason):
-        """Check we are not disconnected when sending a txn that the node rejects."""
-        self.nodes[0].p2p.send_txs_and_test(
-            [tx], self.nodes[0], success=False, reject_reason=reject_reason)
-
-    def check_for_ban_on_rejected_tx(self, tx, reject_reason=None):
-        """Check we are disconnected when sending a txn that the node rejects.
-
-        (Can't actually get banned, since bitcoind won't ban local peers.)"""
-        self.nodes[0].p2p.send_txs_and_test(
-            [tx], self.nodes[0], success=False, expect_disconnect=True, reject_reason=reject_reason)
-        self.reconnect_p2p()
-
-    def check_for_ban_on_rejected_block(self, block, reject_reason=None):
-        """Check we are disconnected when sending a block that the node rejects.
-
-        (Can't actually get banned, since bitcoind won't ban local peers.)"""
-        self.nodes[0].p2p.send_blocks_and_test([block], self.nodes[0], success=False,
-                                               reject_reason=reject_reason, expect_disconnect=True)
-        self.reconnect_p2p()
-
-    def run_test(self):
-        node, = self.nodes
-
-        self.bootstrap_p2p()
-
-        tip = self.get_best_block(node)
-
-        self.log.info("Create some blocks with OP_1 coinbase for spending.")
-        blocks = []
-        for _ in range(10):
-            tip = self.build_block(tip)
-            blocks.append(tip)
-        node.p2p.send_blocks_and_test(blocks, node, success=True)
-        spendable_outputs = [block.vtx[0] for block in blocks]
-
-        self.log.info("Mature the blocks and get out of IBD.")
-        node.generatetoaddress(100, node.get_deterministic_priv_key().address)
-
-        tip = self.get_best_block(node)
-
-        self.log.info(
-            "Set up spending transactions to test and mine the funding transactions.")
-
-        def create_fund_and_spend_tx():
-            spend_from = spendable_outputs.pop()
-            value = spend_from.vout[0].nValue
-
-            # Reversed data
-            data = bytes.fromhex('0123456789abcdef')
-            rev_data = bytes(reversed(data))
-
-            # Lockscript: provide a bytestring that reverses to X
-            script = CScript([OP_REVERSEBYTES, rev_data, OP_EQUAL])
-
-            # Fund transaction: REVERSEBYTES <reversed(x)> EQUAL
-            tx_fund = create_tx_with_script(spend_from, 0, b'', value, script)
-            tx_fund.rehash()
-
-            # Spend transaction: <x>
-            tx_spend = CTransaction()
-            tx_spend.vout.append(
-                CTxOut(value - 1000, CScript([b'x' * 100, OP_RETURN])))
-            tx_spend.vin.append(
-                CTxIn(COutPoint(tx_fund.sha256, 0), b''))
-            tx_spend.vin[0].scriptSig = CScript([data])
-            tx_spend.rehash()
-
-            return tx_spend, tx_fund
-
-        # Create funding/spending transaction pair
-        tx_reversebytes_spend, tx_reversebytes_fund = create_fund_and_spend_tx()
-
-        # Mine funding transaction into block. Pre-upgrade output scripts can have
-        # OP_REVERSEBYTES and still be fully valid, but they cannot spend it.
-        tip = self.build_block(tip, [tx_reversebytes_fund])
-        node.p2p.send_blocks_and_test([tip], node)
-
-        self.log.info("Start pre-upgrade tests")
-
-        self.log.info(
-            "Sending rejected transaction (bad opcode) via RPC (doesn't ban)")
-        assert_raises_rpc_error(-26, PRE_UPGRADE_BAD_OPCODE_ERROR,
-                                node.sendrawtransaction, ToHex(tx_reversebytes_spend))
-
-        self.log.info(
-            "Sending rejected transaction (bad opcode) via net (no banning)")
-        self.check_for_no_ban_on_rejected_tx(
-            tx_reversebytes_spend, PRE_UPGRADE_BAD_OPCODE_ERROR)
-
-        self.log.info(
-            "Sending invalid transactions in blocks (bad inputs, and get banned)")
-        self.check_for_ban_on_rejected_block(self.build_block(tip, [tx_reversebytes_spend]),
-                                             BAD_INPUTS_ERROR)
-
-        self.log.info("Start activation tests")
-
-        self.log.info("Approach to just before upgrade activation")
-        # Move our clock to the upgrade time so we will accept such
-        # future-timestamped blocks.
-        node.setmocktime(PHONON_START_TIME)
-
-        # Mine six blocks with timestamp starting at PHONON_START_TIME-1
-        blocks = []
-        for i in range(-1, 5):
-            tip = self.build_block(tip, n_time=PHONON_START_TIME + i)
-            blocks.append(tip)
-        node.p2p.send_blocks_and_test(blocks, node)
-
-        # Ensure our MTP is PHONON_START_TIME-1, just before activation
-        assert_equal(node.getblockchaininfo()['mediantime'],
-                     PHONON_START_TIME - 1)
-
-        self.log.info(
-            "The next block will activate, but the activation block itself must follow old rules")
-        self.check_for_ban_on_rejected_block(
-            self.build_block(tip, [tx_reversebytes_spend]), BAD_INPUTS_ERROR)
-
-        # Save pre-upgrade block, we will reorg based on this block later
-        pre_upgrade_block = tip
-
-        self.log.info("Mine the activation block itself")
-        tip = self.build_block(tip, [])
-        node.p2p.send_blocks_and_test([tip], node)
-
-        self.log.info("We have activated!")
-        # Ensure our MTP is PHONON_START_TIME, exactly at activation
-        assert_equal(node.getblockchaininfo()['mediantime'], PHONON_START_TIME)
-        # Ensure empty mempool
-        assert_equal(node.getrawmempool(), [])
-
-        # Save upgrade block, will invalidate and reconsider this later
-        upgrade_block = tip
-
-        self.log.info(
-            "Submitting a new OP_REVERSEBYTES tx via net, and mining it in a block")
-        # Send OP_REVERSEBYTES tx
-        node.p2p.send_txs_and_test([tx_reversebytes_spend], node)
-
-        # Verify OP_REVERSEBYTES tx is in mempool
-        assert_equal(set(node.getrawmempool()), {tx_reversebytes_spend.hash})
-
-        # Mine OP_REVERSEBYTES tx into block
-        tip = self.build_block(tip, [tx_reversebytes_spend])
-        node.p2p.send_blocks_and_test([tip], node)
-
-        # Save post-upgrade block, will invalidate and reconsider this later
-        post_upgrade_block = tip
-
-        self.log.info("Start deactivation tests")
-
-        self.log.info(
-            "Invalidating the post-upgrade blocks returns OP_REVERSEBYTES transaction to mempool")
-        node.invalidateblock(post_upgrade_block.hash)
-        assert_equal(set(node.getrawmempool()), {
-                     tx_reversebytes_spend.hash})
-
-        self.log.info(
-            "Invalidating the upgrade block evicts the OP_REVERSEBYTES transaction")
-        node.invalidateblock(upgrade_block.hash)
-        assert_equal(set(node.getrawmempool()), set())
-
-        self.log.info("Return to our tip")
-        node.reconsiderblock(upgrade_block.hash)
-        node.reconsiderblock(post_upgrade_block.hash)
-        assert_equal(node.getbestblockhash(), tip.hash)
-        assert_equal(node.getrawmempool(), [])
-
-        self.log.info(
-            "Create an empty-block reorg that forks from pre-upgrade")
-        tip = pre_upgrade_block
-        blocks = []
-        for _ in range(10):
-            tip = self.build_block(tip)
-            blocks.append(tip)
-        node.p2p.send_blocks_and_test(blocks, node)
-
-        self.log.info(
-            "Transactions from orphaned blocks are sent into mempool ready to be mined again, "
-            "including upgrade-dependent ones even though the fork deactivated and reactivated "
-            "the upgrade.")
-        assert_equal(set(node.getrawmempool()),
-                     {tx_reversebytes_spend.hash})
-        node.generatetoaddress(1, node.get_deterministic_priv_key().address)
-        tip = self.get_best_block(node)
-        assert (set(tx.rehash() for tx in tip.vtx) >=
-                {tx_reversebytes_spend.hash})
-
-
-if __name__ == '__main__':
-    OpReversebytesActivationTest().main()