diff --git a/src/test/fuzz/block.cpp b/src/test/fuzz/block.cpp
index d232df1e4..648b1f8e3 100644
--- a/src/test/fuzz/block.cpp
+++ b/src/test/fuzz/block.cpp
@@ -1,71 +1,83 @@
 // 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 <config.h>
 #include <consensus/merkle.h>
 #include <consensus/validation.h>
 #include <core_io.h>
 #include <core_memusage.h>
 #include <primitives/block.h>
 #include <pubkey.h>
 #include <streams.h>
 #include <validation.h>
 #include <version.h>
 
 #include <test/fuzz/fuzz.h>
 
 #include <cassert>
 #include <string>
 
 void initialize() {
     static const ECCVerifyHandle verify_handle;
     SelectParams(CBaseChainParams::REGTEST);
 }
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     CBlock block;
     try {
         int nVersion;
         ds >> nVersion;
         ds.SetVersion(nVersion);
         ds >> block;
     } catch (const std::ios_base::failure &) {
         return;
     }
     const Config &config = GetConfig();
     const Consensus::Params &consensus_params =
         config.GetChainParams().GetConsensus();
     BlockValidationOptions options(config);
 
     BlockValidationState validation_state_pow_and_merkle;
     const bool valid_incl_pow_and_merkle = CheckBlock(
         block, validation_state_pow_and_merkle, consensus_params, options);
+    assert(validation_state_pow_and_merkle.IsValid() ||
+           validation_state_pow_and_merkle.IsInvalid() ||
+           validation_state_pow_and_merkle.IsError());
+    (void)validation_state_pow_and_merkle.Error("");
     BlockValidationState validation_state_pow;
     const bool valid_incl_pow =
         CheckBlock(block, validation_state_pow, consensus_params,
                    options.withCheckMerkleRoot(false));
+    assert(validation_state_pow.IsValid() || validation_state_pow.IsInvalid() ||
+           validation_state_pow.IsError());
     BlockValidationState validation_state_merkle;
     const bool valid_incl_merkle =
         CheckBlock(block, validation_state_merkle, consensus_params,
                    options.withCheckPoW(false));
+    assert(validation_state_merkle.IsValid() ||
+           validation_state_merkle.IsInvalid() ||
+           validation_state_merkle.IsError());
     BlockValidationState validation_state_none;
     const bool valid_incl_none =
         CheckBlock(block, validation_state_none, consensus_params,
                    options.withCheckPoW(false).withCheckMerkleRoot(false));
+    assert(validation_state_none.IsValid() ||
+           validation_state_none.IsInvalid() ||
+           validation_state_none.IsError());
     if (valid_incl_pow_and_merkle) {
         assert(valid_incl_pow && valid_incl_merkle && valid_incl_none);
     } else if (valid_incl_merkle || valid_incl_pow) {
         assert(valid_incl_none);
     }
     (void)block.GetHash();
     (void)block.ToString();
     (void)BlockMerkleRoot(block);
 
     CBlock block_copy = block;
     block_copy.SetNull();
     const bool is_null = block_copy.IsNull();
     assert(is_null);
 }
diff --git a/src/test/fuzz/block_header.cpp b/src/test/fuzz/block_header.cpp
index e150e0237..91caf0360 100644
--- a/src/test/fuzz/block_header.cpp
+++ b/src/test/fuzz/block_header.cpp
@@ -1,43 +1,52 @@
 // 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 <primitives/block.h>
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 #include <uint256.h>
 
 #include <cassert>
 #include <cstdint>
 #include <optional>
 #include <string>
 #include <vector>
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const std::optional<CBlockHeader> block_header =
         ConsumeDeserializable<CBlockHeader>(fuzzed_data_provider);
     if (!block_header) {
         return;
     }
     {
         const BlockHash hash = block_header->GetHash();
         static const BlockHash blockhash_max(
             uint256S("fffffffffffffffffffffffffffffffffffffffffffffffffffffffff"
                      "fffffff"));
         assert(hash != blockhash_max);
         assert(block_header->GetBlockTime() == block_header->nTime);
         assert(block_header->IsNull() == (block_header->nBits == 0));
     }
     {
         CBlockHeader mut_block_header = *block_header;
         mut_block_header.SetNull();
         assert(mut_block_header.IsNull());
         CBlock block{*block_header};
         assert(block.GetBlockHeader().GetHash() == block_header->GetHash());
         (void)block.ToString();
         block.SetNull();
         assert(block.GetBlockHeader().GetHash() == mut_block_header.GetHash());
     }
+    {
+        std::optional<CBlockLocator> block_locator =
+            ConsumeDeserializable<CBlockLocator>(fuzzed_data_provider);
+        if (block_locator) {
+            (void)block_locator->IsNull();
+            block_locator->SetNull();
+            assert(block_locator->IsNull());
+        }
+    }
 }
diff --git a/src/test/fuzz/script.cpp b/src/test/fuzz/script.cpp
index 184eedaca..e8d146e5a 100644
--- a/src/test/fuzz/script.cpp
+++ b/src/test/fuzz/script.cpp
@@ -1,113 +1,117 @@
 // 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/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 <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);
         CScript decompressed_script;
         const bool ok = DecompressScript(decompressed_script, size, compressed);
         assert(ok);
         assert(script == decompressed_script);
     }
 
     CTxDestination address;
     (void)ExtractDestination(script, address);
 
     txnouttype 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);
 
     txnouttype 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);
     }
 }
diff --git a/src/test/fuzz/string.cpp b/src/test/fuzz/string.cpp
index afa998fca..6a5bd0e50 100644
--- a/src/test/fuzz/string.cpp
+++ b/src/test/fuzz/string.cpp
@@ -1,136 +1,142 @@
 // 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 <blockfilter.h>
 #include <clientversion.h>
 #include <logging.h>
 #include <netbase.h>
 #include <outputtype.h>
 #include <rpc/client.h>
 #include <rpc/request.h>
 #include <rpc/server.h>
 #include <rpc/util.h>
 #include <script/descriptor.h>
 #include <serialize.h>
 #include <streams.h>
 #include <util/error.h>
 #include <util/message.h>
 #include <util/settings.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
 #include <util/translation.h>
 #include <util/url.h>
 #include <version.h>
 
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 #include <test/fuzz/util.h>
 
 #include <cstdint>
 #include <string>
 #include <vector>
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const std::string random_string_1 =
         fuzzed_data_provider.ConsumeRandomLengthString(32);
     const std::string random_string_2 =
         fuzzed_data_provider.ConsumeRandomLengthString(32);
     const std::vector<std::string> random_string_vector =
         ConsumeRandomLengthStringVector(fuzzed_data_provider);
 
     (void)AmountErrMsg(random_string_1, random_string_2);
     (void)AmountHighWarn(random_string_1);
     BlockFilterType block_filter_type;
     (void)BlockFilterTypeByName(random_string_1, block_filter_type);
     (void)Capitalize(random_string_1);
     (void)CopyrightHolders(random_string_1);
     (void)FormatParagraph(
         random_string_1,
         fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 1000),
         fuzzed_data_provider.ConsumeIntegralInRange<size_t>(0, 1000));
     (void)FormatSubVersion(random_string_1,
                            fuzzed_data_provider.ConsumeIntegral<int>(),
                            random_string_vector);
     (void)GetDescriptorChecksum(random_string_1);
     (void)HelpExampleCli(random_string_1, random_string_2);
     (void)HelpExampleRpc(random_string_1, random_string_2);
     (void)HelpMessageGroup(random_string_1);
     (void)HelpMessageOpt(random_string_1, random_string_2);
     ArgsManager argsman;
     (void)IsDeprecatedRPCEnabled(argsman, random_string_1);
     (void)Join(random_string_vector, random_string_1);
     (void)JSONRPCError(fuzzed_data_provider.ConsumeIntegral<int>(),
                        random_string_1);
     const util::Settings settings;
     (void)OnlyHasDefaultSectionSetting(settings, random_string_1,
                                        random_string_2);
     (void)ParseNetwork(random_string_1);
     try {
         (void)ParseNonRFCJSONValue(random_string_1);
     } catch (const std::runtime_error &) {
     }
     OutputType output_type;
     (void)ParseOutputType(random_string_1, output_type);
     (void)ResolveErrMsg(random_string_1, random_string_2);
     try {
         (void)RPCConvertNamedValues(random_string_1, random_string_vector);
     } catch (const std::runtime_error &) {
     }
     try {
         (void)RPCConvertValues(random_string_1, random_string_vector);
     } catch (const std::runtime_error &) {
     }
     (void)SanitizeString(random_string_1);
     (void)SanitizeString(
         random_string_1,
         fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 3));
     (void)ShellEscape(random_string_1);
     int port_out;
     std::string host_out;
     SplitHostPort(random_string_1, port_out, host_out);
     (void)TimingResistantEqual(random_string_1, random_string_2);
     (void)ToLower(random_string_1);
     (void)ToUpper(random_string_1);
     (void)TrimString(random_string_1);
     (void)TrimString(random_string_1, random_string_2);
     (void)urlDecode(random_string_1);
     (void)ValidAsCString(random_string_1);
     (void)_(random_string_1.c_str());
 
     {
         CDataStream data_stream{SER_NETWORK, INIT_PROTO_VERSION};
         std::string s;
         LimitedString<10> limited_string = LIMITED_STRING(s, 10);
         data_stream << random_string_1;
         try {
             data_stream >> limited_string;
             assert(data_stream.empty());
             assert(s.size() <= random_string_1.size());
             assert(s.size() <= 10);
             if (!random_string_1.empty()) {
                 assert(!s.empty());
             }
         } catch (const std::ios_base::failure &) {
         }
     }
     {
         CDataStream data_stream{SER_NETWORK, INIT_PROTO_VERSION};
         const LimitedString<10> limited_string =
             LIMITED_STRING(random_string_1, 10);
         data_stream << limited_string;
         std::string deserialized_string;
         data_stream >> deserialized_string;
         assert(data_stream.empty());
         assert(deserialized_string == random_string_1);
     }
     {
         int64_t amount_out;
         (void)ParseFixedPoint(
             random_string_1,
             fuzzed_data_provider.ConsumeIntegralInRange<int>(0, 1024),
             &amount_out);
     }
+    {
+        (void)Untranslated(random_string_1);
+        const bilingual_str bs1{random_string_1, random_string_2};
+        const bilingual_str bs2{random_string_2, random_string_1};
+        (void)(bs1 + bs2);
+    }
 }
diff --git a/src/test/fuzz/strprintf.cpp b/src/test/fuzz/strprintf.cpp
index fd3529af4..4eb56dd75 100644
--- a/src/test/fuzz/strprintf.cpp
+++ b/src/test/fuzz/strprintf.cpp
@@ -1,205 +1,260 @@
 // 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 <util/strencodings.h>
+#include <util/translation.h>
 
 #include <test/fuzz/FuzzedDataProvider.h>
 #include <test/fuzz/fuzz.h>
 
 #include <tinyformat.h>
 
 #include <algorithm>
 #include <cstdint>
 #include <string>
 #include <vector>
 
 void test_one_input(const std::vector<uint8_t> &buffer) {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const std::string format_string =
         fuzzed_data_provider.ConsumeRandomLengthString(64);
+    const bilingual_str bilingual_string{format_string, format_string};
 
     const int digits_in_format_specifier =
         std::count_if(format_string.begin(), format_string.end(), IsDigit);
 
     // Avoid triggering the following crash bug:
     // * strprintf("%987654321000000:", 1);
     //
     // Avoid triggering the following OOM bug:
     // * strprintf("%.222222200000000$", 1.1);
     //
     // Upstream bug report: https://github.com/c42f/tinyformat/issues/70
     if (format_string.find('%') != std::string::npos &&
         digits_in_format_specifier >= 7) {
         return;
     }
 
     // Avoid triggering the following crash bug:
     // * strprintf("%1$*1$*", -11111111);
     //
     // Upstream bug report: https://github.com/c42f/tinyformat/issues/70
     if (format_string.find('%') != std::string::npos &&
         format_string.find('$') != std::string::npos &&
         format_string.find('*') != std::string::npos &&
         digits_in_format_specifier > 0) {
         return;
     }
 
     // Avoid triggering the following crash bug:
     // * strprintf("%.1s", (char*)nullptr);
     //
     // ()strprintf(format_string, (char*)nullptr);
     //
     // Upstream bug report: https://github.com/c42f/tinyformat/issues/70
 
     try {
         (void)strprintf(format_string, (signed char *)nullptr);
+        (void)tinyformat::format(bilingual_string, (signed char *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (uint8_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (uint8_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (void *)nullptr);
+        (void)tinyformat::format(bilingual_string, (void *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (bool *)nullptr);
+        (void)tinyformat::format(bilingual_string, (bool *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (float *)nullptr);
+        (void)tinyformat::format(bilingual_string, (float *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (double *)nullptr);
+        (void)tinyformat::format(bilingual_string, (double *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (int16_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (int16_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (uint16_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (uint16_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (int32_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (int32_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (uint32_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (uint32_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (int64_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (int64_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
     try {
         (void)strprintf(format_string, (uint64_t *)nullptr);
+        (void)tinyformat::format(bilingual_string, (uint64_t *)nullptr);
     } catch (const tinyformat::format_error &) {
     }
 
     try {
         switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 5)) {
             case 0:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeRandomLengthString(32));
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeRandomLengthString(32));
                 break;
             case 1:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeRandomLengthString(32).c_str());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeRandomLengthString(32).c_str());
                 break;
             case 2:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<signed char>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<signed char>());
                 break;
             case 3:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<uint8_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<uint8_t>());
                 break;
             case 4:
                 (void)strprintf(format_string,
                                 fuzzed_data_provider.ConsumeIntegral<char>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<char>());
                 break;
             case 5:
                 (void)strprintf(format_string,
                                 fuzzed_data_provider.ConsumeBool());
+                (void)tinyformat::format(bilingual_string,
+                                         fuzzed_data_provider.ConsumeBool());
                 break;
         }
     } catch (const tinyformat::format_error &) {
     }
 
     if (format_string.find('%') != std::string::npos &&
         format_string.find('c') != std::string::npos) {
         // Avoid triggering the following:
         // * strprintf("%c", 1.31783e+38);
         // tinyformat.h:244:36: runtime error: 1.31783e+38 is outside the range
         // of representable values of type 'char'
         return;
     }
 
     if (format_string.find('%') != std::string::npos &&
         format_string.find('*') != std::string::npos) {
         // Avoid triggering the following:
         // * strprintf("%*", -2.33527e+38);
         // tinyformat.h:283:65: runtime error: -2.33527e+38 is outside the range
         // of representable values of type 'int'
         // * strprintf("%*", -2147483648);
         // tinyformat.h:763:25: runtime error: negation of -2147483648 cannot be
         // represented in type 'int'; cast to an unsigned type to negate this
         // value to itself
         return;
     }
 
     try {
         switch (fuzzed_data_provider.ConsumeIntegralInRange(0, 7)) {
             case 0:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeFloatingPoint<float>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeFloatingPoint<float>());
                 break;
             case 1:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeFloatingPoint<double>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeFloatingPoint<double>());
                 break;
             case 2:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<int16_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<int16_t>());
                 break;
             case 3:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<uint16_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<uint16_t>());
                 break;
             case 4:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<int32_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<int32_t>());
                 break;
             case 5:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<uint32_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<uint32_t>());
                 break;
             case 6:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<int64_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<int64_t>());
                 break;
             case 7:
                 (void)strprintf(
                     format_string,
                     fuzzed_data_provider.ConsumeIntegral<uint64_t>());
+                (void)tinyformat::format(
+                    bilingual_string,
+                    fuzzed_data_provider.ConsumeIntegral<uint64_t>());
                 break;
         }
     } catch (const tinyformat::format_error &) {
     }
 }