_ZN8FuzzDataC2EPKhm:
   50|  1.03k|           size_t size) : Data(data),Size(size){}
_ZNK8FuzzData8chardataEv:
  158|     91|  const char* chardata() const {return static_cast<const char*>(static_cast<const void*>(Data));}
_ZN8FuzzData6getIntILi0ELi10EEEiv:
   54|  1.03k|  int getInt() {
   55|  1.03k|    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|  1.03k|    constexpr int range=(Max-Min)+1;
   60|  1.03k|    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|  1.03k|    if(range<256)
  ------------------
  |  Branch (64:8): [Folded - Ignored]
  ------------------
   65|  1.03k|      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|  1.03k|  T get() {
   74|  1.03k|    const auto Nbytes=sizeof(T);
   75|  1.03k|    T ret{};
   76|  1.03k|    if(Size<Nbytes) {
  ------------------
  |  Branch (76:8): [True: 0, False: 1.03k]
  ------------------
   77|       |      //don't throw, signal with null instead.
   78|      0|      Data=nullptr;
   79|      0|      Size=0;
   80|      0|      return ret;
   81|      0|    }
   82|  1.03k|    std::memcpy(&ret,Data,Nbytes);
   83|  1.03k|    Data+=Nbytes;
   84|  1.03k|    Size-=Nbytes;
   85|  1.03k|    return ret;
   86|  1.03k|  }
_ZN8FuzzData3getImEET_v:
   73|  2.06k|  T get() {
   74|  2.06k|    const auto Nbytes=sizeof(T);
   75|  2.06k|    T ret{};
   76|  2.06k|    if(Size<Nbytes) {
  ------------------
  |  Branch (76:8): [True: 678, False: 1.38k]
  ------------------
   77|       |      //don't throw, signal with null instead.
   78|    678|      Data=nullptr;
   79|    678|      Size=0;
   80|    678|      return ret;
   81|    678|    }
   82|  1.38k|    std::memcpy(&ret,Data,Nbytes);
   83|  1.38k|    Data+=Nbytes;
   84|  1.38k|    Size-=Nbytes;
   85|  1.38k|    return ret;
   86|  2.06k|  }

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

_ZN8simdjson15simdjson_resultINS_13padded_stringEEC2ENS_10error_codeE:
  196|      6|    : internal::simdjson_result_base<T>(error) {}
_ZN8simdjson8internal20simdjson_result_baseINS_13padded_stringEEC2ENS_10error_codeE:
  111|      6|    : simdjson_result_base(T{}, error) {}
_ZN8simdjson8internal20simdjson_result_baseINS_13padded_stringEEC2EOS2_NS_10error_codeE:
  108|     91|    : std::pair<T, error_code>(std::forward<T>(value), error) {}
_ZN8simdjson15simdjson_resultINS_13padded_stringEEC2EOS1_:
  199|     85|    : internal::simdjson_result_base<T>(std::forward<T>(value)) {}
_ZN8simdjson8internal20simdjson_result_baseINS_13padded_stringEEC2EOS2_:
  114|     85|    : simdjson_result_base(std::forward<T>(value), SUCCESS) {}

_ZN8simdjson13padded_stringC2Em:
   49|  1.55k|    : viable_size(length), data_ptr(internal::allocate_padded_buffer(length)) {
   50|  1.55k|}
_ZN8simdjson8internal22allocate_padded_bufferEm:
   21|  1.55k|inline char *allocate_padded_buffer(size_t length) noexcept {
   22|  1.55k|  const size_t totalpaddedlength = length + SIMDJSON_PADDING;
   23|  1.55k|  if(totalpaddedlength<length) {
  ------------------
  |  Branch (23:6): [True: 14, False: 1.54k]
  ------------------
   24|       |    // overflow
   25|     14|    return nullptr;
   26|     14|  }
   27|  1.54k|#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
   28|       |  // avoid getting out of memory
   29|  1.54k|  if (totalpaddedlength>(1UL<<20)) {
  ------------------
  |  Branch (29:7): [True: 1.00k, False: 544]
  ------------------
   30|  1.00k|    return nullptr;
   31|  1.00k|  }
   32|    544|#endif
   33|       |
   34|    544|  char *padded_buffer = new (std::nothrow) char[totalpaddedlength];
   35|    544|  if (padded_buffer == nullptr) {
  ------------------
  |  Branch (35:7): [True: 0, False: 544]
  ------------------
   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|    544|  std::memset(padded_buffer + length, 0, totalpaddedlength - length);
   41|    544|  return padded_buffer;
   42|    544|} // allocate_padded_buffer()
_ZN8simdjson13padded_stringD2Ev:
  116|  1.65k|inline padded_string::~padded_string() noexcept {
  117|  1.65k|  delete[] data_ptr;
  118|  1.65k|}
_ZN8simdjson13padded_stringaSEOS0_:
   98|    265|inline padded_string &padded_string::operator=(padded_string &&o) noexcept {
   99|    265|  delete[] data_ptr;
  100|    265|  data_ptr = o.data_ptr;
  101|    265|  viable_size = o.viable_size;
  102|    265|  o.data_ptr = nullptr; // we take ownership
  103|    265|  o.viable_size = 0;
  104|    265|  return *this;
  105|    265|}
_ZN8simdjson13padded_string4swapERS0_:
  107|    266|inline void padded_string::swap(padded_string &o) noexcept {
  108|    266|  size_t tmp_viable_size = viable_size;
  109|    266|  char *tmp_data_ptr = data_ptr;
  110|    266|  viable_size = o.viable_size;
  111|    266|  data_ptr = o.data_ptr;
  112|    266|  o.data_ptr = tmp_data_ptr;
  113|    266|  o.viable_size = tmp_viable_size;
  114|    266|}
_ZN8simdjson13padded_string4dataEv:
  126|    312|inline char *padded_string::data() noexcept { return data_ptr; }
_ZNK8simdjson13padded_stringcvNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEEv:
  128|    132|inline padded_string::operator std::string_view() const { return std::string_view(data(), length()); }
_ZNK8simdjson13padded_string4dataEv:
  124|    132|inline const char *padded_string::data() const noexcept { return data_ptr; }
_ZNK8simdjson13padded_string6lengthEv:
  122|    132|inline size_t padded_string::length() const noexcept { return viable_size; }
_ZN8simdjson13padded_string4loadENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  134|     91|inline simdjson_result<padded_string> padded_string::load(std::string_view filename) noexcept {
  135|       |  // Open the file
  136|     91|  SIMDJSON_PUSH_DISABLE_WARNINGS
  137|       |  SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
  138|     91|  std::FILE *fp = std::fopen(filename.data(), "rb");
  139|     91|  SIMDJSON_POP_DISABLE_WARNINGS
  140|       |
  141|     91|  if (fp == nullptr) {
  ------------------
  |  Branch (141:7): [True: 0, False: 91]
  ------------------
  142|      0|    return IO_ERROR;
  143|      0|  }
  144|       |
  145|       |  // Get the file size
  146|     91|  int ret;
  147|       |#if SIMDJSON_VISUAL_STUDIO && !SIMDJSON_IS_32BITS
  148|       |  ret = _fseeki64(fp, 0, SEEK_END);
  149|       |#else
  150|     91|  ret = std::fseek(fp, 0, SEEK_END);
  151|     91|#endif // _WIN64
  152|     91|  if(ret < 0) {
  ------------------
  |  Branch (152:6): [True: 0, False: 91]
  ------------------
  153|      0|    std::fclose(fp);
  154|      0|    return IO_ERROR;
  155|      0|  }
  156|       |#if SIMDJSON_VISUAL_STUDIO && !SIMDJSON_IS_32BITS
  157|       |  __int64 llen = _ftelli64(fp);
  158|       |  if(llen == -1L) {
  159|       |    std::fclose(fp);
  160|       |    return IO_ERROR;
  161|       |  }
  162|       |#else
  163|     91|  long llen = std::ftell(fp);
  164|     91|  if((llen < 0) || (llen == LONG_MAX)) {
  ------------------
  |  Branch (164:6): [True: 0, False: 91]
  |  Branch (164:20): [True: 0, False: 91]
  ------------------
  165|      0|    std::fclose(fp);
  166|      0|    return IO_ERROR;
  167|      0|  }
  168|     91|#endif
  169|       |
  170|       |  // Allocate the padded_string
  171|     91|  size_t len = static_cast<size_t>(llen);
  172|     91|  padded_string s(len);
  173|     91|  if (s.data() == nullptr) {
  ------------------
  |  Branch (173:7): [True: 6, False: 85]
  ------------------
  174|      6|    std::fclose(fp);
  175|      6|    return MEMALLOC;
  176|      6|  }
  177|       |
  178|       |  // Read the padded_string
  179|     85|  std::rewind(fp);
  180|     85|  size_t bytes_read = std::fread(s.data(), 1, len, fp);
  181|     85|  if (std::fclose(fp) != 0 || bytes_read != len) {
  ------------------
  |  Branch (181:7): [True: 0, False: 85]
  |  Branch (181:31): [True: 0, False: 85]
  ------------------
  182|      0|    return IO_ERROR;
  183|      0|  }
  184|       |
  185|     85|  return s;
  186|     85|}
_ZN8simdjson13padded_stringC2Ev:
   47|      6|inline padded_string::padded_string() noexcept = default;
_ZN8simdjson13padded_stringC2EOS0_:
   93|     91|    : viable_size(o.viable_size), data_ptr(o.data_ptr) {
   94|     91|  o.data_ptr = nullptr; // we take ownership
   95|     91|  o.viable_size = 0;
   96|     91|}