diff --git a/src/test/fuzz/deserialize.cpp b/src/test/fuzz/deserialize.cpp
index d9c62f12b..42467d49c 100644
--- a/src/test/fuzz/deserialize.cpp
+++ b/src/test/fuzz/deserialize.cpp
@@ -1,230 +1,230 @@
 // Copyright (c) 2009-2018 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <addrdb.h>
 #include <addrman.h>
 #include <blockencodings.h>
 #include <blockfileinfo.h>
 #include <blockfilter.h>
 #include <chain.h>
 #include <coins.h>
 #include <compressor.h>
 #include <consensus/merkle.h>
 #include <key.h>
 #include <merkleblock.h>
 #include <net.h>
 #include <node/utxo_snapshot.h>
 #include <primitives/block.h>
 #include <protocol.h>
 #include <psbt.h>
 #include <pubkey.h>
 #include <script/keyorigin.h>
 #include <streams.h>
 #include <undo.h>
 #include <version.h>
 
 #include <test/fuzz/fuzz.h>
 
 #include <cstdint>
 #include <exception>
 #include <stdexcept>
 #include <unistd.h>
 #include <vector>
 
 void initialize() {
     // Fuzzers using pubkey must hold an ECCVerifyHandle.
     static const ECCVerifyHandle verify_handle;
 }
 
 namespace {
 
 struct invalid_fuzzing_input_exception : public std::exception {};
 
 template <typename T> CDataStream Serialize(const T &obj) {
     CDataStream ds(SER_NETWORK, INIT_PROTO_VERSION);
     ds << obj;
     return ds;
 }
 
 template <typename T> T Deserialize(CDataStream ds) {
     T obj;
     ds >> obj;
     return obj;
 }
 
 template <typename T>
 void DeserializeFromFuzzingInput(const std::vector<uint8_t> &buffer, T &obj) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     try {
         int version;
         ds >> version;
         ds.SetVersion(version);
     } catch (const std::ios_base::failure &) {
         throw invalid_fuzzing_input_exception();
     }
     try {
         ds >> obj;
     } catch (const std::ios_base::failure &) {
         throw invalid_fuzzing_input_exception();
     }
     assert(buffer.empty() || !Serialize(obj).empty());
 }
 
 template <typename T> void AssertEqualAfterSerializeDeserialize(const T &obj) {
     assert(Deserialize<T>(Serialize(obj)) == obj);
 }
 
 } // namespace
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     try {
 #if BLOCK_FILTER_DESERIALIZE
         BlockFilter block_filter;
         DeserializeFromFuzzingInput(buffer, block_filter);
 #elif ADDR_INFO_DESERIALIZE
         CAddrInfo addr_info;
         DeserializeFromFuzzingInput(buffer, addr_info);
 #elif BLOCK_FILE_INFO_DESERIALIZE
         CBlockFileInfo block_file_info;
         DeserializeFromFuzzingInput(buffer, block_file_info);
 #elif BLOCK_HEADER_AND_SHORT_TXIDS_DESERIALIZE
         CBlockHeaderAndShortTxIDs block_header_and_short_txids;
         DeserializeFromFuzzingInput(buffer, block_header_and_short_txids);
 #elif FEE_RATE_DESERIALIZE
         CFeeRate fee_rate;
         DeserializeFromFuzzingInput(buffer, fee_rate);
         AssertEqualAfterSerializeDeserialize(fee_rate);
 #elif MERKLE_BLOCK_DESERIALIZE
         CMerkleBlock merkle_block;
         DeserializeFromFuzzingInput(buffer, merkle_block);
 #elif OUT_POINT_DESERIALIZE
         COutPoint out_point;
         DeserializeFromFuzzingInput(buffer, out_point);
         AssertEqualAfterSerializeDeserialize(out_point);
 #elif PARTIAL_MERKLE_TREE_DESERIALIZE
         CPartialMerkleTree partial_merkle_tree;
         DeserializeFromFuzzingInput(buffer, partial_merkle_tree);
 #elif PUB_KEY_DESERIALIZE
         CPubKey pub_key;
         DeserializeFromFuzzingInput(buffer, pub_key);
         // TODO: The following equivalence should hold for CPubKey? Fix.
         // AssertEqualAfterSerializeDeserialize(pub_key);
 #elif SCRIPT_DESERIALIZE
         CScript script;
         DeserializeFromFuzzingInput(buffer, script);
 #elif SUB_NET_DESERIALIZE
         CSubNet sub_net;
         DeserializeFromFuzzingInput(buffer, sub_net);
         AssertEqualAfterSerializeDeserialize(sub_net);
 #elif TX_IN_DESERIALIZE
         CTxIn tx_in;
         DeserializeFromFuzzingInput(buffer, tx_in);
         AssertEqualAfterSerializeDeserialize(tx_in);
 #elif FLAT_FILE_POS_DESERIALIZE
         FlatFilePos flat_file_pos;
         DeserializeFromFuzzingInput(buffer, flat_file_pos);
         AssertEqualAfterSerializeDeserialize(flat_file_pos);
 #elif KEY_ORIGIN_INFO_DESERIALIZE
         KeyOriginInfo key_origin_info;
         DeserializeFromFuzzingInput(buffer, key_origin_info);
         AssertEqualAfterSerializeDeserialize(key_origin_info);
 #elif PARTIALLY_SIGNED_TRANSACTION_DESERIALIZE
         PartiallySignedTransaction partially_signed_transaction;
         DeserializeFromFuzzingInput(buffer, partially_signed_transaction);
 #elif PREFILLED_TRANSACTION_DESERIALIZE
         PrefilledTransaction prefilled_transaction;
         DeserializeFromFuzzingInput(buffer, prefilled_transaction);
 #elif PSBT_INPUT_DESERIALIZE
         PSBTInput psbt_input;
         DeserializeFromFuzzingInput(buffer, psbt_input);
 #elif PSBT_OUTPUT_DESERIALIZE
         PSBTOutput psbt_output;
         DeserializeFromFuzzingInput(buffer, psbt_output);
 #elif BLOCK_DESERIALIZE
         CBlock block;
         DeserializeFromFuzzingInput(buffer, block);
 #elif BLOCKLOCATOR_DESERIALIZE
         CBlockLocator bl;
         DeserializeFromFuzzingInput(buffer, bl);
 #elif BLOCKMERKLEROOT
         CBlock block;
         DeserializeFromFuzzingInput(buffer, block);
         bool mutated;
         BlockMerkleRoot(block, &mutated);
 #elif ADDRMAN_DESERIALIZE
         CAddrMan am;
         DeserializeFromFuzzingInput(buffer, am);
 #elif BLOCKHEADER_DESERIALIZE
         CBlockHeader bh;
         DeserializeFromFuzzingInput(buffer, bh);
 #elif BANENTRY_DESERIALIZE
         CBanEntry be;
         DeserializeFromFuzzingInput(buffer, be);
 #elif TXUNDO_DESERIALIZE
         CTxUndo tu;
         DeserializeFromFuzzingInput(buffer, tu);
 #elif BLOCKUNDO_DESERIALIZE
         CBlockUndo bu;
         DeserializeFromFuzzingInput(buffer, bu);
 #elif COINS_DESERIALIZE
         Coin coin;
         DeserializeFromFuzzingInput(buffer, coin);
 #elif NETADDR_DESERIALIZE
         CNetAddr na;
         DeserializeFromFuzzingInput(buffer, na);
         AssertEqualAfterSerializeDeserialize(na);
 #elif SERVICE_DESERIALIZE
         CService s;
         DeserializeFromFuzzingInput(buffer, s);
         AssertEqualAfterSerializeDeserialize(s);
 #elif MESSAGEHEADER_DESERIALIZE
-        const CMessageHeader::MessageMagic pchMessageStart = {0x00, 0x00, 0x00,
-                                                              0x00};
+        const CMessageHeader::MessageMagic pchMessageStart = {
+            {0x00, 0x00, 0x00, 0x00}};
         CMessageHeader mh(pchMessageStart);
         DeserializeFromFuzzingInput(buffer, mh);
         (void)mh.IsValidWithoutConfig(pchMessageStart);
 #elif ADDRESS_DESERIALIZE
         CAddress a;
         DeserializeFromFuzzingInput(buffer, a);
 #elif INV_DESERIALIZE
         CInv i;
         DeserializeFromFuzzingInput(buffer, i);
 #elif BLOOMFILTER_DESERIALIZE
         CBloomFilter bf;
         DeserializeFromFuzzingInput(buffer, bf);
 #elif DISKBLOCKINDEX_DESERIALIZE
         CDiskBlockIndex dbi;
         DeserializeFromFuzzingInput(buffer, dbi);
 #elif TXOUTCOMPRESSOR_DESERIALIZE
         CTxOut to;
         auto toc = Using<TxOutCompression>(to);
         DeserializeFromFuzzingInput(buffer, toc);
 #elif BLOCKTRANSACTIONS_DESERIALIZE
         BlockTransactions bt;
         DeserializeFromFuzzingInput(buffer, bt);
 #elif BLOCKTRANSACTIONSREQUEST_DESERIALIZE
         BlockTransactionsRequest btr;
         DeserializeFromFuzzingInput(buffer, btr);
 #elif SNAPSHOTMETADATA_DESERIALIZE
         SnapshotMetadata snapshot_metadata;
         DeserializeFromFuzzingInput(buffer, snapshot_metadata);
 #elif UINT160_DESERIALIZE
         uint160 u160;
         DeserializeFromFuzzingInput(buffer, u160);
         AssertEqualAfterSerializeDeserialize(u160);
 #elif UINT256_DESERIALIZE
         uint256 u256;
         DeserializeFromFuzzingInput(buffer, u256);
         AssertEqualAfterSerializeDeserialize(u256);
 #else
 #error Need at least one fuzz target to compile
 #endif
         // Classes intentionally not covered in this file since their
         // deserialization code is fuzzed elsewhere:
         // * Deserialization of CTxOut is fuzzed in src/test/fuzz/tx_out.cpp
         // * Deserialization of CMutableTransaction is fuzzed in
         //   src/test/fuzz/transaction.cpp
     } catch (const invalid_fuzzing_input_exception &) {
     }
 }
diff --git a/src/test/fuzz/script.cpp b/src/test/fuzz/script.cpp
index 94e916a9b..854a71bd5 100644
--- a/src/test/fuzz/script.cpp
+++ b/src/test/fuzz/script.cpp
@@ -1,145 +1,145 @@
 // Copyright (c) 2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <chainparams.h>
 #include <compressor.h>
 #include <core_io.h>
 #include <core_memusage.h>
 #include <policy/policy.h>
 #include <pubkey.h>
 #include <script/descriptor.h>
 #include <script/interpreter.h>
 #include <script/script.h>
 #include <script/script_error.h>
 #include <script/sign.h>
 #include <script/signingprovider.h>
 #include <script/standard.h>
 #include <streams.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <univalue.h>
 
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <memory>
 #include <optional>
 #include <string>
 #include <vector>
 
 void initialize() {
     // Fuzzers using pubkey must hold an ECCVerifyHandle.
     static const ECCVerifyHandle verify_handle;
 
     SelectParams(CBaseChainParams::REGTEST);
 }
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const std::optional<CScript> script_opt =
         ConsumeDeserializable<CScript>(fuzzed_data_provider);
     if (!script_opt) {
         return;
     }
     const CScript script{*script_opt};
 
     std::vector<uint8_t> compressed;
     if (CompressScript(script, compressed)) {
         const unsigned int size = compressed[0];
         compressed.erase(compressed.begin());
-        assert(size >= 0 && size <= 5);
+        assert(size <= 5);
         CScript decompressed_script;
         const bool ok = DecompressScript(decompressed_script, size, compressed);
         assert(ok);
         assert(script == decompressed_script);
     }
 
     CTxDestination address;
     (void)ExtractDestination(script, address);
 
     TxoutType type_ret;
     std::vector<CTxDestination> addresses;
     int required_ret;
     (void)ExtractDestinations(script, type_ret, addresses, required_ret);
 
     const FlatSigningProvider signing_provider;
     (void)InferDescriptor(script, signing_provider);
 
     (void)script.IsWitnessProgram();
 
     (void)IsSolvable(signing_provider, script);
 
     TxoutType which_type;
     (void)IsStandard(script, which_type);
 
     (void)RecursiveDynamicUsage(script);
 
     std::vector<std::vector<uint8_t>> solutions;
     (void)Solver(script, solutions);
 
     (void)script.HasValidOps();
     (void)script.IsPayToScriptHash();
     (void)script.IsPushOnly();
     (void)script.IsUnspendable();
     (void)script.IsWitnessProgram();
 
     (void)FormatScript(script);
     (void)ScriptToAsmStr(script, false);
     (void)ScriptToAsmStr(script, true);
 
     UniValue o1(UniValue::VOBJ);
     ScriptPubKeyToUniv(script, o1, true);
     UniValue o2(UniValue::VOBJ);
     ScriptPubKeyToUniv(script, o2, false);
     UniValue o3(UniValue::VOBJ);
     ScriptToUniv(script, o3, true);
     UniValue o4(UniValue::VOBJ);
     ScriptToUniv(script, o4, false);
 
     {
         const std::vector<uint8_t> bytes =
             ConsumeRandomLengthByteVector(fuzzed_data_provider);
         // DecompressScript(..., ..., bytes) is not guaranteed to be defined if
         // the bytes vector is too short
         if (bytes.size() >= 32) {
             CScript decompressed_script;
             DecompressScript(
                 decompressed_script,
                 fuzzed_data_provider.ConsumeIntegral<unsigned int>(), bytes);
         }
     }
 
     const std::optional<CScript> other_script =
         ConsumeDeserializable<CScript>(fuzzed_data_provider);
     if (other_script) {
         CScript script_mut{script};
         (void)FindAndDelete(script_mut, *other_script);
     }
 
     (void)GetOpName(ConsumeOpcodeType(fuzzed_data_provider));
     (void)ScriptErrorString(static_cast<ScriptError>(
         fuzzed_data_provider.ConsumeIntegralInRange<int>(
             0, static_cast<int>(ScriptError::ERROR_COUNT))));
 
     {
         const std::vector<uint8_t> bytes =
             ConsumeRandomLengthByteVector(fuzzed_data_provider);
         CScript append_script{bytes.begin(), bytes.end()};
         append_script << fuzzed_data_provider.ConsumeIntegral<int64_t>();
         append_script << ConsumeOpcodeType(fuzzed_data_provider);
         append_script << CScriptNum{
             fuzzed_data_provider.ConsumeIntegral<int64_t>()};
         append_script << ConsumeRandomLengthByteVector(fuzzed_data_provider);
     }
 
     {
         const CTxDestination tx_destination_1 =
             ConsumeTxDestination(fuzzed_data_provider);
         const CTxDestination tx_destination_2 =
             ConsumeTxDestination(fuzzed_data_provider);
         (void)(tx_destination_1 == tx_destination_2);
         (void)(tx_destination_1 < tx_destination_2);
     }
 }
diff --git a/src/test/fuzz/scriptnum_ops.cpp b/src/test/fuzz/scriptnum_ops.cpp
index b674774ea..c4f30aadf 100644
--- a/src/test/fuzz/scriptnum_ops.cpp
+++ b/src/test/fuzz/scriptnum_ops.cpp
@@ -1,186 +1,186 @@
 // Copyright (c) 2020 The Bitcoin Core 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 <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 
 #include <cassert>
 #include <cstdint>
 #include <limits>
 #include <vector>
 
 namespace {
 bool IsValidAddition(const CScriptNum &lhs, const CScriptNum &rhs) {
     return rhs == 0 ||
            (rhs > 0 &&
             lhs <= CScriptNum{std::numeric_limits<int64_t>::max()} - rhs) ||
            (rhs < 0 &&
             lhs >= CScriptNum{std::numeric_limits<int64_t>::min()} - rhs);
 }
 
 bool IsValidSubtraction(const CScriptNum &lhs, const CScriptNum &rhs) {
     return rhs == 0 ||
            (rhs > 0 &&
             lhs >= CScriptNum{std::numeric_limits<int64_t>::min()} + rhs) ||
            (rhs < 0 &&
             lhs <= CScriptNum{std::numeric_limits<int64_t>::max()} + rhs);
 }
 } // namespace
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     CScriptNum script_num = ConsumeScriptNum(fuzzed_data_provider);
     while (fuzzed_data_provider.remaining_bytes() > 0) {
         switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 11)) {
             case 0: {
                 const int64_t i =
                     fuzzed_data_provider.ConsumeIntegral<int64_t>();
                 assert((script_num == i) != (script_num != i));
-                assert((script_num <= i) != script_num > i);
+                assert((script_num <= i) != (script_num > i));
                 assert((script_num >= i) != (script_num < i));
                 // Avoid signed integer overflow:
                 // script/script.h:264:93: runtime error: signed integer
                 // overflow: -2261405121394637306 + -9223372036854775802 cannot
                 // be represented in type 'long'
                 if (IsValidAddition(script_num, CScriptNum{i})) {
                     assert((script_num + i) - i == script_num);
                 }
                 // Avoid signed integer overflow:
                 // script/script.h:265:93: runtime error: signed integer
                 // overflow: 9223371895120855039 - -9223372036854710486 cannot
                 // be represented in type 'long'
                 if (IsValidSubtraction(script_num, CScriptNum{i})) {
                     assert((script_num - i) + i == script_num);
                 }
                 break;
             }
             case 1: {
                 const CScriptNum random_script_num =
                     ConsumeScriptNum(fuzzed_data_provider);
                 assert((script_num == random_script_num) !=
                        (script_num != random_script_num));
                 assert((script_num <= random_script_num) !=
                        (script_num > random_script_num));
                 assert((script_num >= random_script_num) !=
                        (script_num < random_script_num));
                 // Avoid signed integer overflow:
                 // script/script.h:264:93: runtime error: signed integer
                 // overflow: -9223126527765971126 + -9223372036854756825 cannot
                 // be represented in type 'long'
                 if (IsValidAddition(script_num, random_script_num)) {
                     assert((script_num + random_script_num) -
                                random_script_num ==
                            script_num);
                 }
                 // Avoid signed integer overflow:
                 // script/script.h:265:93: runtime error: signed integer
                 // overflow: 6052837899185946624 - -9223372036854775808 cannot
                 // be represented in type 'long'
                 if (IsValidSubtraction(script_num, random_script_num)) {
                     assert((script_num - random_script_num) +
                                random_script_num ==
                            script_num);
                 }
                 break;
             }
             case 2: {
                 const CScriptNum random_script_num =
                     ConsumeScriptNum(fuzzed_data_provider);
                 if (!IsValidAddition(script_num, random_script_num)) {
                     // Avoid assertion failure:
                     // ./script/script.h:292: CScriptNum
                     // &CScriptNum::operator+=(const int64_t &): Assertion `rhs
                     // == 0 || (rhs > 0 && m_value <=
                     // std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 &&
                     // m_value >= std::numeric_limits<int64_t>::min() - rhs)'
                     // failed.
                     break;
                 }
                 script_num += random_script_num;
                 break;
             }
             case 3: {
                 const CScriptNum random_script_num =
                     ConsumeScriptNum(fuzzed_data_provider);
                 if (!IsValidSubtraction(script_num, random_script_num)) {
                     // Avoid assertion failure:
                     // ./script/script.h:300: CScriptNum
                     // &CScriptNum::operator-=(const int64_t &): Assertion `rhs
                     // == 0 || (rhs > 0 && m_value >=
                     // std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 &&
                     // m_value <= std::numeric_limits<int64_t>::max() + rhs)'
                     // failed.
                     break;
                 }
                 script_num -= random_script_num;
                 break;
             }
             case 4:
                 script_num = script_num &
                              fuzzed_data_provider.ConsumeIntegral<int64_t>();
                 break;
             case 5:
                 script_num =
                     script_num & ConsumeScriptNum(fuzzed_data_provider);
                 break;
             case 6:
                 script_num &= ConsumeScriptNum(fuzzed_data_provider);
                 break;
             case 7:
                 if (script_num ==
                     CScriptNum{std::numeric_limits<int64_t>::min()}) {
                     // Avoid assertion failure:
                     // ./script/script.h:279: CScriptNum CScriptNum::operator-()
                     // const: Assertion `m_value !=
                     // std::numeric_limits<int64_t>::min()' failed.
                     break;
                 }
                 script_num = -script_num;
                 break;
             case 8:
                 script_num = fuzzed_data_provider.ConsumeIntegral<int64_t>();
                 break;
             case 9: {
                 const int64_t random_integer =
                     fuzzed_data_provider.ConsumeIntegral<int64_t>();
                 if (!IsValidAddition(script_num, CScriptNum{random_integer})) {
                     // Avoid assertion failure:
                     // ./script/script.h:292: CScriptNum
                     // &CScriptNum::operator+=(const int64_t &): Assertion `rhs
                     // == 0 || (rhs > 0 && m_value <=
                     // std::numeric_limits<int64_t>::max() - rhs) || (rhs < 0 &&
                     // m_value >= std::numeric_limits<int64_t>::min() - rhs)'
                     // failed.
                     break;
                 }
                 script_num += random_integer;
                 break;
             }
             case 10: {
                 const int64_t random_integer =
                     fuzzed_data_provider.ConsumeIntegral<int64_t>();
                 if (!IsValidSubtraction(script_num,
                                         CScriptNum{random_integer})) {
                     // Avoid assertion failure:
                     // ./script/script.h:300: CScriptNum
                     // &CScriptNum::operator-=(const int64_t &): Assertion `rhs
                     // == 0 || (rhs > 0 && m_value >=
                     // std::numeric_limits<int64_t>::min() + rhs) || (rhs < 0 &&
                     // m_value <= std::numeric_limits<int64_t>::max() + rhs)'
                     // failed.
                     break;
                 }
                 script_num -= random_integer;
                 break;
             }
             case 11:
                 script_num &= fuzzed_data_provider.ConsumeIntegral<int64_t>();
                 break;
         }
         (void)script_num.getint();
         (void)script_num.getvch();
     }
 }
diff --git a/src/test/fuzz/signature_checker.cpp b/src/test/fuzz/signature_checker.cpp
index 37df6dfec..54e2f8774 100644
--- a/src/test/fuzz/signature_checker.cpp
+++ b/src/test/fuzz/signature_checker.cpp
@@ -1,72 +1,72 @@
 // Copyright (c) 2009-2019 The Bitcoin Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <pubkey.h>
 #include <script/interpreter.h>
 
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 
 #include <cstdint>
 #include <limits>
 #include <string>
 #include <vector>
 
 void initialize() {
     static const auto verify_handle = std::make_unique<ECCVerifyHandle>();
 }
 
 namespace {
 class FuzzedSignatureChecker : public BaseSignatureChecker {
     FuzzedDataProvider &m_fuzzed_data_provider;
 
 public:
     FuzzedSignatureChecker(FuzzedDataProvider &fuzzed_data_provider)
         : m_fuzzed_data_provider(fuzzed_data_provider) {}
 
-    virtual bool CheckSig(const std::vector<uint8_t> &scriptSig,
-                          const std::vector<uint8_t> &vchPubKey,
-                          const CScript &scriptCode, uint32_t flags) const {
+    bool CheckSig(const std::vector<uint8_t> &scriptSig,
+                  const std::vector<uint8_t> &vchPubKey,
+                  const CScript &scriptCode, uint32_t flags) const override {
         return m_fuzzed_data_provider.ConsumeBool();
     }
 
-    virtual bool CheckLockTime(const CScriptNum &nLockTime) const {
+    bool CheckLockTime(const CScriptNum &nLockTime) const override {
         return m_fuzzed_data_provider.ConsumeBool();
     }
 
-    virtual bool CheckSequence(const CScriptNum &nSequence) const {
+    bool CheckSequence(const CScriptNum &nSequence) const override {
         return m_fuzzed_data_provider.ConsumeBool();
     }
 
     virtual ~FuzzedSignatureChecker() {}
 };
 } // namespace
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const unsigned int flags =
         fuzzed_data_provider.ConsumeIntegral<unsigned int>();
     const std::string script_string_1 =
         fuzzed_data_provider.ConsumeRandomLengthString(65536);
     const std::vector<uint8_t> script_bytes_1{script_string_1.begin(),
                                               script_string_1.end()};
     const std::string script_string_2 =
         fuzzed_data_provider.ConsumeRandomLengthString(65536);
     const std::vector<uint8_t> script_bytes_2{script_string_2.begin(),
                                               script_string_2.end()};
     std::vector<std::vector<uint8_t>> stack;
     ScriptExecutionMetrics metrics;
     ScriptError serror;
     (void)EvalScript(stack, {script_bytes_1.begin(), script_bytes_1.end()},
                      flags, FuzzedSignatureChecker(fuzzed_data_provider),
                      metrics, &serror);
     if ((flags & SCRIPT_VERIFY_CLEANSTACK) != 0 &&
         (flags & SCRIPT_VERIFY_P2SH) == 0) {
         return;
     }
     (void)VerifyScript({script_bytes_1.begin(), script_bytes_1.end()},
                        {script_bytes_2.begin(), script_bytes_2.end()}, flags,
                        FuzzedSignatureChecker(fuzzed_data_provider), metrics,
                        &serror);
 }