_ZN8FuzzDataC2EPKhm:
   50|    996|           size_t size) : Data(data),Size(size){}
_ZNK8FuzzData8chardataEv:
  158|    118|  const char* chardata() const {return static_cast<const char*>(static_cast<const void*>(Data));}
_ZN8FuzzData6getIntILi0ELi10EEEiv:
   54|    996|  int getInt() {
   55|    996|    static_assert (Min<Max,"min must be <max");
   56|       |
   57|       |    // make this constexpr, can't overflow because that is UB and is forbidden
   58|       |    // in constexpr evaluation
   59|    996|    constexpr int range=(Max-Min)+1;
   60|    996|    constexpr unsigned int urange=range;
   61|       |
   62|       |    // don't use std::uniform_int_distribution, we don't want to pay for
   63|       |    // over consumption of random data. Accept the slightly non-uniform distribution.
   64|    996|    if(range<256)
  ------------------
  |  Branch (64:8): [Folded - Ignored]
  ------------------
   65|    996|      return Min+static_cast<int>(get<uint8_t>()%urange);
   66|      0|    if(range<65536)
  ------------------
  |  Branch (66:8): [Folded - Ignored]
  ------------------
   67|      0|      return Min+static_cast<int>(get<uint16_t>()%urange);
   68|       |
   69|      0|    return Min+static_cast<int>(get<uint32_t>()%urange);
   70|      0|  }
_ZN8FuzzData3getIhEET_v:
   73|    996|  T get() {
   74|    996|    const auto Nbytes=sizeof(T);
   75|    996|    T ret{};
   76|    996|    if(Size<Nbytes) {
  ------------------
  |  Branch (76:8): [True: 0, False: 996]
  ------------------
   77|       |      //don't throw, signal with null instead.
   78|      0|      Data=nullptr;
   79|      0|      Size=0;
   80|      0|      return ret;
   81|      0|    }
   82|    996|    std::memcpy(&ret,Data,Nbytes);
   83|    996|    Data+=Nbytes;
   84|    996|    Size-=Nbytes;
   85|    996|    return ret;
   86|    996|  }
_ZN8FuzzData3getImEET_v:
   73|  1.99k|  T get() {
   74|  1.99k|    const auto Nbytes=sizeof(T);
   75|  1.99k|    T ret{};
   76|  1.99k|    if(Size<Nbytes) {
  ------------------
  |  Branch (76:8): [True: 631, False: 1.36k]
  ------------------
   77|       |      //don't throw, signal with null instead.
   78|    631|      Data=nullptr;
   79|    631|      Size=0;
   80|    631|      return ret;
   81|    631|    }
   82|  1.36k|    std::memcpy(&ret,Data,Nbytes);
   83|  1.36k|    Data+=Nbytes;
   84|  1.36k|    Size-=Nbytes;
   85|  1.36k|    return ret;
   86|  1.99k|  }

LLVMFuzzerTestOneInput:
    8|    996|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
    9|    996|  FuzzData fd(Data, Size);
   10|       |
   11|    996|  const int action = fd.getInt<0, 10>();
   12|       |
   13|    996|  const auto s1 = fd.get<size_t>();
   14|    996|  const auto s2 = fd.get<size_t>();
   15|    996|  switch (action) {
   16|    127|  case 0: {
  ------------------
  |  Branch (16:3): [True: 127, False: 869]
  ------------------
   17|    127|    simdjson_unused simdjson::padded_string p(s1);
  ------------------
  |  |  113|    127|  #define simdjson_unused __attribute__((unused))
  ------------------
   18|    127|  } break;
   19|    238|  case 1: {
  ------------------
  |  Branch (19:3): [True: 238, False: 758]
  ------------------
   20|       |    // operator== with temp value
   21|    238|    simdjson_unused simdjson::padded_string p1(s1);
  ------------------
  |  |  113|    238|  #define simdjson_unused __attribute__((unused))
  ------------------
   22|    238|    simdjson_unused simdjson::padded_string p2(s2);
  ------------------
  |  |  113|    238|  #define simdjson_unused __attribute__((unused))
  ------------------
   23|    238|    p1 = std::move(p2);
   24|    238|  } break;
   25|    261|  case 2: {
  ------------------
  |  Branch (25:3): [True: 261, False: 735]
  ------------------
   26|       |    // swap
   27|    261|    simdjson_unused simdjson::padded_string p1(s1);
  ------------------
  |  |  113|    261|  #define simdjson_unused __attribute__((unused))
  ------------------
   28|    261|    simdjson_unused simdjson::padded_string p2(s2);
  ------------------
  |  |  113|    261|  #define simdjson_unused __attribute__((unused))
  ------------------
   29|    261|    p1.swap(p2);
   30|    261|  } break;
   31|    127|  case 3: {
  ------------------
  |  Branch (31:3): [True: 127, False: 869]
  ------------------
   32|    127|    simdjson_unused simdjson::padded_string p(s1);
  ------------------
  |  |  113|    127|  #define simdjson_unused __attribute__((unused))
  ------------------
   33|    127|    p.data();
   34|    127|  } break;
   35|    123|  case 4: {
  ------------------
  |  Branch (35:3): [True: 123, False: 873]
  ------------------
   36|    123|    simdjson::padded_string p(s1);
   37|    123|    simdjson_unused auto sv = static_cast<std::string_view>(p);
  ------------------
  |  |  113|    123|  #define simdjson_unused __attribute__((unused))
  ------------------
   38|    123|  } break;
   39|    118|  case 5: {
  ------------------
  |  Branch (39:3): [True: 118, False: 878]
  ------------------
   40|       |    // load from file.
   41|    118|    const std::string filename = "/dev/shm/fuzz_padded.tmp";
   42|    118|    {
   43|    118|      std::ofstream file(filename);
   44|    118|      assert(file);
   45|      0|      const long ssize = static_cast<long>(fd.Size);
   46|    118|      file.write(fd.chardata(), ssize);
   47|    118|      assert(file.tellp() == ssize);
   48|    118|    }
   49|    118|    simdjson_unused auto data = simdjson::padded_string::load(filename);
  ------------------
  |  |  113|    118|  #define simdjson_unused __attribute__((unused))
  ------------------
   50|    118|  } break;
   51|      2|  default:;
  ------------------
  |  Branch (51:3): [True: 2, False: 994]
  ------------------
   52|    996|  }
   53|    996|  return 0;
   54|    996|}

_ZN8simdjson15simdjson_resultINS_13padded_stringEEC2ENS_10error_codeE:
  175|      5|    : internal::simdjson_result_base<T>(error) {}
_ZN8simdjson8internal20simdjson_result_baseINS_13padded_stringEEC2ENS_10error_codeE:
  107|      5|    : simdjson_result_base(T{}, error) {}
_ZN8simdjson8internal20simdjson_result_baseINS_13padded_stringEEC2EOS2_NS_10error_codeE:
  104|    118|    : std::pair<T, error_code>(std::forward<T>(value), error) {}
_ZN8simdjson15simdjson_resultINS_13padded_stringEEC2EOS1_:
  178|    113|    : internal::simdjson_result_base<T>(std::forward<T>(value)) {}
_ZN8simdjson8internal20simdjson_result_baseINS_13padded_stringEEC2EOS2_:
  110|    113|    : simdjson_result_base(std::forward<T>(value), SUCCESS) {}

_ZN8simdjson13padded_stringC2Em:
   49|  1.49k|    : viable_size(length), data_ptr(internal::allocate_padded_buffer(length)) {
   50|  1.49k|}
_ZN8simdjson8internal22allocate_padded_bufferEm:
   21|  1.49k|inline char *allocate_padded_buffer(size_t length) noexcept {
   22|  1.49k|  const size_t totalpaddedlength = length + SIMDJSON_PADDING;
   23|  1.49k|  if(totalpaddedlength<length) {
  ------------------
  |  Branch (23:6): [True: 15, False: 1.47k]
  ------------------
   24|       |    // overflow
   25|     15|    return nullptr;
   26|     15|  }
   27|  1.47k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
   28|       |  // avoid getting out of memory
   29|  1.47k|  if (totalpaddedlength>(1UL<<20)) {
  ------------------
  |  Branch (29:7): [True: 913, False: 565]
  ------------------
   30|    913|    return nullptr;
   31|    913|  }
   32|    565|#endif
   33|       |
   34|    565|  char *padded_buffer = new (std::nothrow) char[totalpaddedlength];
   35|    565|  if (padded_buffer == nullptr) {
  ------------------
  |  Branch (35:7): [True: 0, False: 565]
  ------------------
   36|      0|    return nullptr;
   37|      0|  }
   38|       |  // We write nulls in the padded region to avoid having uninitialized
   39|       |  // content which may trigger warning for some sanitizers
   40|    565|  std::memset(padded_buffer + length, 0, totalpaddedlength - length);
   41|    565|  return padded_buffer;
   42|    565|} // allocate_padded_buffer()
_ZN8simdjson13padded_stringD2Ev:
   99|  1.61k|inline padded_string::~padded_string() noexcept {
  100|  1.61k|  delete[] data_ptr;
  101|  1.61k|}
_ZN8simdjson13padded_stringaSEOS0_:
   81|    238|inline padded_string &padded_string::operator=(padded_string &&o) noexcept {
   82|    238|  delete[] data_ptr;
   83|    238|  data_ptr = o.data_ptr;
   84|    238|  viable_size = o.viable_size;
   85|    238|  o.data_ptr = nullptr; // we take ownership
   86|    238|  o.viable_size = 0;
   87|    238|  return *this;
   88|    238|}
_ZN8simdjson13padded_string4swapERS0_:
   90|    261|inline void padded_string::swap(padded_string &o) noexcept {
   91|    261|  size_t tmp_viable_size = viable_size;
   92|    261|  char *tmp_data_ptr = data_ptr;
   93|    261|  viable_size = o.viable_size;
   94|    261|  data_ptr = o.data_ptr;
   95|    261|  o.data_ptr = tmp_data_ptr;
   96|    261|  o.viable_size = tmp_viable_size;
   97|    261|}
_ZN8simdjson13padded_string4dataEv:
  109|    358|inline char *padded_string::data() noexcept { return data_ptr; }
_ZNK8simdjson13padded_stringcvNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEv:
  111|    123|inline padded_string::operator std::string_view() const { return std::string_view(data(), length()); }
_ZNK8simdjson13padded_string4dataEv:
  107|    123|inline const char *padded_string::data() const noexcept { return data_ptr; }
_ZNK8simdjson13padded_string6lengthEv:
  105|    123|inline size_t padded_string::length() const noexcept { return viable_size; }
_ZN8simdjson13padded_string4loadENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  117|    118|inline simdjson_result<padded_string> padded_string::load(std::string_view filename) noexcept {
  118|       |  // Open the file
  119|    118|  SIMDJSON_PUSH_DISABLE_WARNINGS
  120|       |  SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
  121|    118|  std::FILE *fp = std::fopen(filename.data(), "rb");
  122|    118|  SIMDJSON_POP_DISABLE_WARNINGS
  123|       |
  124|    118|  if (fp == nullptr) {
  ------------------
  |  Branch (124:7): [True: 0, False: 118]
  ------------------
  125|      0|    return IO_ERROR;
  126|      0|  }
  127|       |
  128|       |  // Get the file size
  129|    118|  int ret;
  130|       |#if SIMDJSON_VISUAL_STUDIO && !SIMDJSON_IS_32BITS
  131|       |  ret = _fseeki64(fp, 0, SEEK_END);
  132|       |#else
  133|    118|  ret = std::fseek(fp, 0, SEEK_END);
  134|    118|#endif // _WIN64
  135|    118|  if(ret < 0) {
  ------------------
  |  Branch (135:6): [True: 0, False: 118]
  ------------------
  136|      0|    std::fclose(fp);
  137|      0|    return IO_ERROR;
  138|      0|  }
  139|       |#if SIMDJSON_VISUAL_STUDIO && !SIMDJSON_IS_32BITS
  140|       |  __int64 llen = _ftelli64(fp);
  141|       |  if(llen == -1L) {
  142|       |    std::fclose(fp);
  143|       |    return IO_ERROR;
  144|       |  }
  145|       |#else
  146|    118|  long llen = std::ftell(fp);
  147|    118|  if((llen < 0) || (llen == LONG_MAX)) {
  ------------------
  |  Branch (147:6): [True: 0, False: 118]
  |  Branch (147:20): [True: 0, False: 118]
  ------------------
  148|      0|    std::fclose(fp);
  149|      0|    return IO_ERROR;
  150|      0|  }
  151|    118|#endif
  152|       |
  153|       |  // Allocate the padded_string
  154|    118|  size_t len = static_cast<size_t>(llen);
  155|    118|  padded_string s(len);
  156|    118|  if (s.data() == nullptr) {
  ------------------
  |  Branch (156:7): [True: 5, False: 113]
  ------------------
  157|      5|    std::fclose(fp);
  158|      5|    return MEMALLOC;
  159|      5|  }
  160|       |
  161|       |  // Read the padded_string
  162|    113|  std::rewind(fp);
  163|    113|  size_t bytes_read = std::fread(s.data(), 1, len, fp);
  164|    113|  if (std::fclose(fp) != 0 || bytes_read != len) {
  ------------------
  |  Branch (164:7): [True: 0, False: 113]
  |  Branch (164:31): [True: 0, False: 113]
  ------------------
  165|      0|    return IO_ERROR;
  166|      0|  }
  167|       |
  168|    113|  return s;
  169|    113|}
_ZN8simdjson13padded_stringC2Ev:
   47|      5|inline padded_string::padded_string() noexcept = default;
_ZN8simdjson13padded_stringC2EOS0_:
   77|    118|    : viable_size(o.viable_size), data_ptr(o.data_ptr) {
   78|    118|  o.data_ptr = nullptr; // we take ownership
   79|    118|}