LLVMFuzzerTestOneInput:
   23|  2.31k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   24|  2.31k|  custom_obj obj;
   25|  2.31k|  std::string input(reinterpret_cast<const char*>(data), size);
   26|  2.31k|  spotify::json::try_decode(obj, input);
   27|  2.31k|  return 0;
   28|  2.31k|}
fuzz_decode.cpp:_ZN7spotify4json15default_codec_tIN12_GLOBAL__N_110custom_objEE5codecEv:
   16|  2.31k|  static codec::object_t<custom_obj> codec() {
   17|  2.31k|    auto codec = codec::object<custom_obj>();
   18|  2.31k|    codec.required("x", &custom_obj::val);
   19|  2.31k|    return codec;
   20|  2.31k|  }

fuzz_decode.cpp:_ZNK7spotify4json5codec8object_tIN12_GLOBAL__N_110custom_objEE6decodeERNS0_14decode_contextE:
   98|  1.29M|  json_never_inline object_type decode(decode_context &context) const {
   99|  1.29M|    object_type value = construct(std::is_default_constructible<T>());
  100|  1.29M|    object_t_base::decode(context, &value);
  101|  1.29M|    return value;
  102|  1.29M|  }
fuzz_decode.cpp:_ZNK7spotify4json5codec8object_tIN12_GLOBAL__N_110custom_objEE9constructENSt3__117integral_constantIbLb1EEE:
  109|  2.31k|  T construct(std::true_type /*is_default_constructible*/) const {
  110|  2.31k|    if (json_unlikely(_construct)) {
  ------------------
  |  |   33|  2.31k|  #define json_unlikely(expr) __builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (33:31): [True: 0, False: 2.31k]
  |  |  ------------------
  ------------------
  111|      0|      const auto &typed = static_cast<const construct_callable &>(*_construct);
  112|      0|      return typed();
  113|  2.31k|    } else {
  114|  2.31k|      return object_type();
  115|  2.31k|    }
  116|  2.31k|  }
fuzz_decode.cpp:_ZN7spotify4json5codec6objectIN12_GLOBAL__N_110custom_objEEENS1_8object_tIT_EEv:
  351|  2.31k|object_t<T> object() {
  352|  2.31k|  return object_t<T>();
  353|  2.31k|}
fuzz_decode.cpp:_ZN7spotify4json5codec8object_tIN12_GLOBAL__N_110custom_objEEC2IS4_vEEv:
   75|  2.31k|  object_t() {}
fuzz_decode.cpp:_ZN7spotify4json5codec8object_tIN12_GLOBAL__N_110custom_objEE8requiredIJMS4_NSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEEEvRKSD_DpOT_:
   94|  2.31k|  void required(const std::string &name, args_type &&...args) {
   95|  2.31k|    add_field(name, true, std::forward<args_type>(args)...);
   96|  2.31k|  }
fuzz_decode.cpp:_ZN7spotify4json5codec8object_tIN12_GLOBAL__N_110custom_objEE9add_fieldINSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEES4_EEvRKSD_bMT0_T_:
  245|  2.31k|  void add_field(const std::string &name, bool required, value_type object_type::*member_ptr) {
  246|  2.31k|    add_field(name, required, member_ptr, default_codec<value_type>());
  247|  2.31k|  }
fuzz_decode.cpp:_ZN7spotify4json5codec8object_tIN12_GLOBAL__N_110custom_objEE9add_fieldINSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEES4_NS1_8string_tEEEvRKSD_bMT0_T_OT1_:
  254|  2.31k|      codec_type &&codec) {
  255|  2.31k|    using member_ptr = value_type (object_type::*);
  256|  2.31k|    using field_type = member_var_field<member_ptr, typename std::decay<codec_type>::type>;
  257|  2.31k|    _fields.save(name, required, std::shared_ptr<detail::field>(new field_type(
  258|  2.31k|        required,
  259|  2.31k|        _fields.num_required_fields(),
  260|  2.31k|        std::forward<codec_type>(codec),
  261|  2.31k|        member)));
  262|  2.31k|  }
fuzz_decode.cpp:_ZN7spotify4json5codec8object_tIN12_GLOBAL__N_110custom_objEE16member_var_fieldIMS4_NSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS1_8string_tEEC2EbmOSF_SE_:
  167|  2.31k|        : codec_field<codec_type>(required, required_field_idx, std::move(codec)),
  168|  2.31k|          member(member) {}
fuzz_decode.cpp:_ZN7spotify4json5codec8object_tIN12_GLOBAL__N_110custom_objEE11codec_fieldINS1_8string_tEEC2EbmOS7_:
  128|  2.31k|        : field(required, required_field_idx),
  129|  2.31k|          codec(std::move(codec)) {}
fuzz_decode.cpp:_ZNK7spotify4json5codec8object_tIN12_GLOBAL__N_110custom_objEE16member_var_fieldIMS4_NSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS1_8string_tEE6decodeERNS0_14decode_contextEPv:
  174|  1.40k|    void decode(decode_context &context, void *object) const override {
  175|  1.40k|      auto &typed = *static_cast<object_type *>(object);
  176|  1.40k|      typed.*member = this->codec.decode(context);
  177|  1.40k|    }

_ZN7spotify4json15default_codec_tINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5codecEv:
   44|  2.31k|  static codec::string_t codec() {
   45|  2.31k|    return codec::string_t();
   46|  2.31k|  }
_ZN7spotify4json5codec6stringEv:
   36|  2.31k|inline string_t string() {
   37|  2.31k|  return string_t();
   38|  2.31k|}

fuzz_decode.cpp:_ZN7spotify4json10try_decodeIN12_GLOBAL__N_110custom_objENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEbRT_RKT0_:
  124|  2.31k|bool try_decode(value_type &object, const string_type &string) noexcept {
  125|  2.31k|  return try_decode(object, default_codec<value_type>(), string);
  126|  2.31k|}
fuzz_decode.cpp:_ZN7spotify4json10try_decodeINS0_5codec8object_tIN12_GLOBAL__N_110custom_objEEENSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEEbRNT_11object_typeERKSE_RKT0_:
  105|  2.31k|    const string_type &string) noexcept {
  106|  2.31k|  return try_decode(object, codec, string.data(), string.size());
  107|  2.31k|}
fuzz_decode.cpp:_ZN7spotify4json10try_decodeINS0_5codec8object_tIN12_GLOBAL__N_110custom_objEEEEEbRNT_11object_typeERKS7_PKcm:
   81|  2.31k|    size_t size) noexcept {
   82|  2.31k|  if (size == 0) {
  ------------------
  |  Branch (82:7): [True: 0, False: 2.31k]
  ------------------
   83|      0|    return false;  // avoid exceptions below
   84|      0|  }
   85|  2.31k|  try {
   86|  2.31k|    object = decode(codec, data, size);
   87|  2.31k|    return true;
   88|  2.31k|  } catch (...) {
   89|  2.30k|    return false;
   90|  2.30k|  }
   91|  2.31k|}
fuzz_decode.cpp:_ZN7spotify4json6decodeINS0_5codec8object_tIN12_GLOBAL__N_110custom_objEEEEENT_11object_typeERKS7_PKcm:
   34|  2.31k|typename codec_type::object_type decode(const codec_type &codec, const char *data, size_t size) {
   35|  2.31k|  decode_context c(data, data + size);
   36|  2.31k|  detail::skip_any_whitespace(c);
   37|  2.31k|  const auto result = codec.decode(c);
   38|  2.31k|  detail::skip_any_whitespace(c);
   39|  2.31k|  detail::fail_if(c, c.position != c.end, "Unexpected trailing input");
   40|  2.31k|  return result;
   41|  2.31k|}

_ZNK7spotify4json14decode_context6offsetEv:
   36|  2.30k|  json_force_inline size_t offset() const {
   37|  2.30k|    return (position - begin);
   38|  2.30k|  }
_ZNK7spotify4json14decode_context6offsetEl:
   40|  2.30k|  json_force_inline size_t offset(const ptrdiff_t d) const {
   41|  2.30k|    return offset() + d;
   42|  2.30k|  }
_ZNK7spotify4json14decode_context9remainingEv:
   44|  2.13M|  json_force_inline size_t remaining() const {
   45|  2.13M|    return (end - position);
   46|  2.13M|  }

fuzz_decode.cpp:_ZN7spotify4json13default_codecIN12_GLOBAL__N_110custom_objEEEDTclsr15default_codec_tIT_EE5codecEEv:
   32|  2.31k|decltype(default_codec_t<T>::codec()) default_codec() {
   33|  2.31k|  return default_codec_t<T>::codec();
   34|  2.31k|}
_ZN7spotify4json13default_codecINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEDTclsr15default_codec_tIT_EE5codecEEv:
   32|  2.31k|decltype(default_codec_t<T>::codec()) default_codec() {
   33|  2.31k|  return default_codec_t<T>::codec();
   34|  2.31k|}

_ZN7spotify4json6detail11bitset_base12test_and_setEm:
   32|  1.36k|  json_force_inline uint8_t test_and_set(const std::size_t index) {
   33|  1.36k|    const auto byte = (index / 8);
   34|  1.36k|    const auto bidx = (index & 7);
   35|  1.36k|    const auto mask = (1 << bidx);
   36|  1.36k|    const auto byte_before = _base[byte];
   37|  1.36k|    _base[byte] = (byte_before | mask);
   38|  1.36k|    return (byte_before & mask) >> bidx;
   39|  1.36k|  }
_ZN7spotify4json6detail6bitsetILm64EEC2Em:
   52|  2.31k|      : bitset_base(size, size <= inline_size ? _array : nullptr) {
  ------------------
  |  Branch (52:27): [True: 2.31k, False: 0]
  ------------------
   53|  2.31k|    if (json_likely(size <= inline_size)) {
  ------------------
  |  |   32|  2.31k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 2.31k, False: 0]
  |  |  ------------------
  ------------------
   54|  2.31k|      memset(_array, 0, sizeof(_array));
   55|  2.31k|    }
   56|  2.31k|  }

_ZN7spotify4json6detail5cpuidC2Ev:
   34|  4.63k|  cpuid() {
   35|  4.63k|#if defined(json_arch_x86)
   36|  4.63k|    const uint32_t cpuid_function(1);
   37|       |#if defined(_MSC_VER)
   38|       |    ::__cpuid(reinterpret_cast<int *>(_registers.data()), cpuid_function);
   39|       |#elif defined(__GNUC__)
   40|       |    __asm__ __volatile__ (
   41|  4.63k|        "cpuid ;\n"
   42|  4.63k|        : "=a" (_registers[cpu_register::eax]),
   43|  4.63k|          "=b" (_registers[cpu_register::ebx]),
   44|  4.63k|          "=c" (_registers[cpu_register::ecx]),
   45|  4.63k|          "=d" (_registers[cpu_register::edx])
   46|  4.63k|        : "a" (cpuid_function)
   47|  4.63k|        :);
   48|  4.63k|#endif  // defined(_MSC_VER)
   49|  4.63k|#endif  // defined(json_arch_x86)
   50|  4.63k|  }
_ZNK7spotify4json6detail5cpuid9has_sse42Ev:
   52|  4.63k|  bool has_sse42() const {
   53|  4.63k|    return has_feature_bit(cpu_register::ecx, cpu_feature_bit::sse_42);
   54|  4.63k|  }
_ZNK7spotify4json6detail5cpuid15has_feature_bitERKNS2_12cpu_register4typeERKNS2_15cpu_feature_bit4typeE:
   74|  4.63k|      const cpu_feature_bit::type &bit) const {
   75|  4.63k|    return (_registers[reg] & (1 << bit)) != 0;
   76|  4.63k|  }

_ZN7spotify4json6detail7fail_ifERKNS0_14decode_contextEbPKcl:
   44|  2.96M|    const ptrdiff_t d = 0) {
   45|  2.96M|  if (json_unlikely(condition)) {
  ------------------
  |  |   33|  2.96M|  #define json_unlikely(expr) __builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (33:31): [True: 1.70k, False: 2.96M]
  |  |  ------------------
  ------------------
   46|  1.70k|    fail(context, error, d);
   47|  1.70k|  }
   48|  2.96M|}
_ZN7spotify4json6detail14peek_uncheckedERKNS0_14decode_contextE:
   60|  1.47M|json_force_inline char peek_unchecked(const decode_context &context) {
   61|  1.47M|  return *context.position;
   62|  1.47M|}
_ZN7spotify4json6detail4peekERKNS0_14decode_contextE:
   70|   248k|json_force_inline char peek(const decode_context &context) {
   71|   248k|  return (context.remaining() ? peek_unchecked(context) : 0);
  ------------------
  |  Branch (71:11): [True: 247k, False: 640]
  ------------------
   72|   248k|}
_ZN7spotify4json6detail6peek_2ERKNS0_14decode_contextEcc:
   79|  5.80k|json_force_inline bool peek_2(const decode_context &context, const char first, const char second) {
   80|  5.80k|  if (context.remaining() < 2) {
  ------------------
  |  Branch (80:7): [True: 33, False: 5.77k]
  ------------------
   81|     33|    return false;
   82|     33|  }
   83|  5.77k|  return first == *context.position && second == *(context.position + 1);
  ------------------
  |  Branch (83:10): [True: 3.29k, False: 2.47k]
  |  Branch (83:40): [True: 2.70k, False: 596]
  ------------------
   84|  5.80k|}
_ZN7spotify4json6detail14next_uncheckedERNS0_14decode_contextE:
   86|   419k|json_force_inline char next_unchecked(decode_context &context) {
   87|   419k|  return *(context.position++);
   88|   419k|}
_ZN7spotify4json6detail4nextERNS0_14decode_contextE:
   96|  94.4k|json_force_inline char next(decode_context &context) {
   97|  94.4k|  return next(context, "Unexpected end of input");
   98|  94.4k|}
_ZN7spotify4json6detail16skip_unchecked_1ERNS0_14decode_contextE:
  100|  1.16M|json_force_inline void skip_unchecked_1(decode_context &context) {
  101|  1.16M|  context.position++;
  102|  1.16M|}
_ZN7spotify4json6detail16skip_unchecked_nERNS0_14decode_contextEm:
  104|  2.70k|json_force_inline void skip_unchecked_n(decode_context &context, const size_t num_bytes) {
  105|  2.70k|  context.position += num_bytes;
  106|  2.70k|}
_ZN7spotify4json6detail6skip_1ERNS0_14decode_contextEc:
  122|  94.4k|json_force_inline void skip_1(decode_context &context, char character) {
  123|  94.4k|  fail_if(context, next(context) != character, "Unexpected input", -1);
  124|  94.4k|}
_ZN7spotify4json6detail6skip_4ERNS0_14decode_contextEPKc:
  131|  4.30k|json_force_inline void skip_4(decode_context &context, const char characters[4]) {
  132|  4.30k|  require_bytes<4>(context);
  133|  4.30k|  fail_if(context, memcmp(characters, context.position, 4) != 0, "Unexpected input");
  134|  4.30k|  context.position += 4;
  135|  4.30k|}
_ZN7spotify4json6detail9skip_trueERNS0_14decode_contextE:
  187|  2.15k|json_force_inline void skip_true(decode_context &context) {
  188|  2.15k|  skip_4(context, "true");
  189|  2.15k|}
_ZN7spotify4json6detail10skip_falseERNS0_14decode_contextE:
  191|    829|json_force_inline void skip_false(decode_context &context) {
  192|    829|  context.position++;  // skip past the 'f' in 'false', we know it is there
  193|    829|  skip_4(context, "alse");
  194|    829|}
_ZN7spotify4json6detail9skip_nullERNS0_14decode_contextE:
  196|  1.32k|json_force_inline void skip_null(decode_context &context) {
  197|  1.32k|  skip_4(context, "null");
  198|  1.32k|}
_ZN7spotify4json6detail4nextIA24_cEEcRNS0_14decode_contextERKT_:
   91|  94.4k|json_force_inline char next(decode_context &context, const string_type &error) {
   92|  94.4k|  require_bytes<1>(context, error);
   93|  94.4k|  return next_unchecked(context);
   94|  94.4k|}
_ZN7spotify4json6detail13require_bytesILm1EA24_cEEvRKNS0_14decode_contextERKT0_:
   51|  94.4k|json_force_inline void require_bytes(const decode_context &context, const string_type &error) {
   52|  94.4k|  fail_if(context, context.remaining() < num_required_bytes, error);
   53|  94.4k|}
_ZN7spotify4json6detail13require_bytesILm4EEEvRKNS0_14decode_contextE:
   56|  4.30k|json_force_inline void require_bytes(const decode_context &context) {
   57|  4.30k|  require_bytes<num_required_bytes>(context, "Unexpected end of input");
   58|  4.30k|}
_ZN7spotify4json6detail13require_bytesILm4EA24_cEEvRKNS0_14decode_contextERKT0_:
   51|  4.30k|json_force_inline void require_bytes(const decode_context &context, const string_type &error) {
   52|  4.30k|  fail_if(context, context.remaining() < num_required_bytes, error);
   53|  4.30k|}
object.cpp:_ZN7spotify4json6detail13decode_objectINS0_5codec8string_tEZNKS3_12codec_detail13object_t_base6decodeERNS0_14decode_contextEPvE3$_0EEvS8_RKT0_:
  176|  2.31k|json_force_inline void decode_object(decode_context &context, const callback_function &callback) {
  177|  2.31k|  auto codec = key_codec_type();
  178|  2.31k|  decode_comma_separated(context, '{', '}', [&]{
  179|  2.31k|    auto key = codec.decode(context);
  180|  2.31k|    skip_any_whitespace(context);
  181|  2.31k|    skip_1(context, ':');
  182|  2.31k|    skip_any_whitespace(context);
  183|  2.31k|    callback(std::move(key));
  184|  2.31k|  });
  185|  2.31k|}
object.cpp:_ZN7spotify4json6detail22decode_comma_separatedIZNS1_13decode_objectINS0_5codec8string_tEZNKS4_12codec_detail13object_t_base6decodeERNS0_14decode_contextEPvE3$_0EEvS9_RKT0_EUlvE_EEvS9_ccT_:
  150|  2.31k|json_never_inline void decode_comma_separated(decode_context &context, char intro, char outro, parse_function parse) {
  151|  2.31k|  skip_1(context, intro);
  152|  2.31k|  skip_any_whitespace(context);
  153|       |
  154|  2.31k|  if (json_likely(peek(context) != outro)) {
  ------------------
  |  |   32|  2.31k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 2.24k, False: 73]
  |  |  ------------------
  ------------------
  155|  2.24k|    parse();
  156|  2.24k|    skip_any_whitespace(context);
  157|       |
  158|  16.8k|    while (json_likely(peek(context) != outro)) {
  ------------------
  |  |   32|  16.8k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 14.5k, False: 2.24k]
  |  |  ------------------
  ------------------
  159|  14.5k|      skip_1(context, ',');
  160|  14.5k|      skip_any_whitespace(context);
  161|  14.5k|      parse();
  162|  14.5k|      skip_any_whitespace(context);
  163|  14.5k|    }
  164|  2.24k|  }
  165|       |
  166|  2.31k|  context.position++;
  167|  2.31k|}
object.cpp:_ZZN7spotify4json6detail13decode_objectINS0_5codec8string_tEZNKS3_12codec_detail13object_t_base6decodeERNS0_14decode_contextEPvE3$_0EEvS8_RKT0_ENKUlvE_clEv:
  178|  16.6k|  decode_comma_separated(context, '{', '}', [&]{
  179|  16.6k|    auto key = codec.decode(context);
  180|  16.6k|    skip_any_whitespace(context);
  181|  16.6k|    skip_1(context, ':');
  182|  16.6k|    skip_any_whitespace(context);
  183|  16.6k|    callback(std::move(key));
  184|  16.6k|  });
_ZN7spotify4json6detail4nextIA20_cEEcRNS0_14decode_contextERKT_:
   91|   325k|json_force_inline char next(decode_context &context, const string_type &error) {
   92|   325k|  require_bytes<1>(context, error);
   93|   325k|  return next_unchecked(context);
   94|   325k|}
_ZN7spotify4json6detail13require_bytesILm1EA20_cEEvRKNS0_14decode_contextERKT0_:
   51|   325k|json_force_inline void require_bytes(const decode_context &context, const string_type &error) {
   52|   325k|  fail_if(context, context.remaining() < num_required_bytes, error);
   53|   325k|}
_ZN7spotify4json6detail13require_bytesILm4EA36_cEEvRKNS0_14decode_contextERKT0_:
   51|  56.4k|json_force_inline void require_bytes(const decode_context &context, const string_type &error) {
   52|  56.4k|  fail_if(context, context.remaining() < num_required_bytes, error);
   53|  56.4k|}

_ZNK7spotify4json6detail14field_registry19num_required_fieldsEv:
   73|  4.64k|  size_t num_required_fields() const noexcept { return _num_required_fields; }
_ZN7spotify4json6detail5fieldC2Ebm:
   39|  2.31k|      : _data(required ? required_field_idx : json_size_t_max) {}
  ------------------
  |  |   52|      0|#define json_size_t_max static_cast<size_t>(-1)
  ------------------
  |  Branch (39:15): [True: 2.31k, False: 0]
  ------------------
_ZN7spotify4json6detail5fieldD2Ev:
   40|  2.31k|  virtual ~field() = default;
_ZNK7spotify4json6detail5field11is_requiredEv:
   48|  1.36k|  json_force_inline bool is_required() const { return (_data != json_size_t_max); }
  ------------------
  |  |   52|  1.36k|#define json_size_t_max static_cast<size_t>(-1)
  ------------------
_ZNK7spotify4json6detail5field18required_field_idxEv:
   49|  1.36k|  json_force_inline size_t required_field_idx() const { return _data; }

_ZN7spotify4json6detail19skip_any_whitespaceERNS0_14decode_contextE:
   59|  1.29M|json_force_inline void skip_any_whitespace(decode_context &context) {
   60|       |#if defined(json_arch_x86_sse42)
   61|       |  if (json_likely(context.has_sse42)) {
   62|       |    return skip_any_whitespace_sse42(context);
   63|       |  }
   64|       |#endif  // defined(json_arch_x86_sse42)
   65|  1.29M|  skip_any_whitespace_scalar(context);
   66|  1.29M|}
_ZN7spotify4json6detail26skip_any_simple_charactersERNS0_14decode_contextE:
   38|   182k|json_force_inline void skip_any_simple_characters(decode_context &context) {
   39|   182k|#if defined(json_arch_x86_sse42)
   40|   182k|  if (json_likely(context.has_sse42)) {
  ------------------
  |  |   32|   182k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 182k, False: 0]
  |  |  ------------------
  ------------------
   41|   182k|    return skip_any_simple_characters_sse42(context);
   42|   182k|  }
   43|      0|#endif  // defined(json_arch_x86_sse42)
   44|      0|  return skip_any_simple_characters_scalar(context);
   45|   182k|}

_ZN7spotify4json6detail5stackIcLm64EE3popEv:
   43|  40.9k|  T pop() {
   44|  40.9k|    if (json_unlikely(_vector)) {
  ------------------
  |  |   33|  40.9k|  #define json_unlikely(expr) __builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (33:31): [True: 40.3k, False: 607]
  |  |  ------------------
  ------------------
   45|  40.3k|      auto top = _vector->back();
   46|  40.3k|      _vector->pop_back();
   47|  40.3k|      return top;
   48|  40.3k|    } else {
   49|    607|      assert(_inline_size);
  ------------------
  |  Branch (49:7): [True: 607, False: 0]
  ------------------
   50|    607|      return _array[--_inline_size];
   51|    607|    }
   52|  40.9k|  }
_ZN7spotify4json6detail5stackIcLm64EE4pushEc:
   32|  1.10M|  void push(T value) {
   33|  1.10M|    if (json_unlikely(_vector)) {
  ------------------
  |  |   33|  1.10M|  #define json_unlikely(expr) __builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (33:31): [True: 1.06M, False: 41.2k]
  |  |  ------------------
  ------------------
   34|  1.06M|      _vector->push_back(std::move(value));
   35|  1.06M|    } else if (json_likely(_inline_size < inline_capacity)) {
  ------------------
  |  |   32|  41.2k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 40.6k, False: 601]
  |  |  ------------------
  ------------------
   36|  40.6k|      _array[_inline_size++] = std::move(value);
   37|  40.6k|    } else {
   38|    601|      _vector.reset(new std::vector<T>(_array.begin(), _array.end()));
   39|    601|      _vector->push_back(std::move(value));
   40|    601|    }
   41|  1.10M|  }

_ZN7spotify4json14encode_context7reserveEm:
   37|  9.26k|  json_force_inline char *reserve(const std::size_t reserved_bytes) {
   38|  9.26k|    const auto remaining_bytes = static_cast<std::size_t>(_end - _ptr);  // _end is always >= _ptr
   39|  9.26k|    if (json_likely(remaining_bytes >= reserved_bytes)) {
  ------------------
  |  |   32|  9.26k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 9.26k, False: 0]
  |  |  ------------------
  ------------------
   40|  9.26k|      return _ptr;
   41|  9.26k|    } else {
   42|      0|      return grow_buffer(reserved_bytes);
   43|      0|    }
   44|  9.26k|  }
_ZN7spotify4json14encode_context7advanceEm:
   46|  9.26k|  json_force_inline void advance(const std::size_t num_bytes) {
   47|  9.26k|    _ptr += num_bytes;
   48|  9.26k|  }
_ZN7spotify4json14encode_context6appendEc:
   50|  6.94k|  json_force_inline void append(const char c) {
   51|  6.94k|    reserve(1)[0] = c;
   52|  6.94k|    advance(1);
   53|  6.94k|  }
_ZNK7spotify4json14encode_context4dataEv:
   72|  2.31k|  json_force_inline const char *data() const {
   73|  2.31k|    return _buf;
   74|  2.31k|  }
_ZNK7spotify4json14encode_context4sizeEv:
   76|  2.31k|  json_force_inline std::size_t size() const {
   77|  2.31k|    return static_cast<std::size_t>(_ptr - _buf);
   78|  2.31k|  }

_ZN7spotify4json5codec12codec_detail13object_t_baseC2Ev:
   24|  2.31k|object_t_base::object_t_base() = default;
_ZN7spotify4json5codec12codec_detail13object_t_baseD2Ev:
   28|  2.31k|object_t_base::~object_t_base() = default;
_ZNK7spotify4json5codec12codec_detail13object_t_base6decodeERNS0_14decode_contextEPv:
   30|  2.31k|void object_t_base::decode(decode_context &context, void *value) const {
   31|  2.31k|  uint_fast32_t uniq_seen_required = 0;
   32|  2.31k|  detail::bitset<64> seen_required(_fields.num_required_fields());
   33|       |
   34|  2.31k|  detail::decode_object<string_t>(context, [&](const std::string &key) {
   35|  2.31k|    const auto *field = _fields.find(key);
   36|  2.31k|    if (json_unlikely(!field)) {
   37|  2.31k|      return detail::skip_value(context);
   38|  2.31k|    }
   39|       |
   40|  2.31k|    field->decode(context, value);
   41|  2.31k|    if (field->is_required()) {
   42|  2.31k|      const auto seen = seen_required.test_and_set(field->required_field_idx());
   43|  2.31k|      uniq_seen_required += (1 - seen);  // 'seen' is 1 when the field is a duplicate; 0 otherwise
   44|  2.31k|    }
   45|  2.31k|  });
   46|       |
   47|  2.31k|  const auto is_missing_req_fields = (uniq_seen_required != _fields.num_required_fields());
   48|  2.31k|  detail::fail_if(context, is_missing_req_fields, "Missing required field(s)");
   49|  2.31k|}
object.cpp:_ZZNK7spotify4json5codec12codec_detail13object_t_base6decodeERNS0_14decode_contextEPvENK3$_0clERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEE:
   34|  15.6k|  detail::decode_object<string_t>(context, [&](const std::string &key) {
   35|  15.6k|    const auto *field = _fields.find(key);
   36|  15.6k|    if (json_unlikely(!field)) {
  ------------------
  |  |   33|  15.6k|  #define json_unlikely(expr) __builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (33:31): [True: 14.2k, False: 1.40k]
  |  |  ------------------
  ------------------
   37|  14.2k|      return detail::skip_value(context);
   38|  14.2k|    }
   39|       |
   40|  1.40k|    field->decode(context, value);
   41|  1.40k|    if (field->is_required()) {
  ------------------
  |  Branch (41:9): [True: 1.36k, False: 32]
  ------------------
   42|  1.36k|      const auto seen = seen_required.test_and_set(field->required_field_idx());
   43|  1.36k|      uniq_seen_required += (1 - seen);  // 'seen' is 1 when the field is a duplicate; 0 otherwise
   44|  1.36k|    }
   45|  1.40k|  });

_ZNK7spotify4json5codec8string_t6decodeERNS0_14decode_contextE:
  172|  18.0k|string_t::object_type string_t::decode(decode_context &context) const {
  173|  18.0k|  detail::skip_1(context, '"');
  174|  18.0k|  return decode_string(context);
  175|  18.0k|}
_ZNK7spotify4json5codec8string_t6encodeERNS0_14encode_contextENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  177|  2.31k|void string_t::encode(encode_context &context, const object_type value) const {
  178|  2.31k|  context.append('"');
  179|       |
  180|       |  // Write the strings in 1024 byte chunks, so that we do not have to reserve a
  181|       |  // potentially very large buffer for the escaped string. It is possible that
  182|       |  // the chunking will happen in the middle of a UTF-8 multi-byte character, but
  183|       |  // that is ok since write_escaped will not escape characters with the high bit
  184|       |  // set, so the combined escaped string contains the correct UTF-8 characters
  185|       |  // in the end.
  186|  2.31k|  auto chunk_begin = value.data();
  187|  2.31k|  const auto string_end = chunk_begin + value.size();
  188|       |
  189|  4.63k|  while (chunk_begin != string_end) {
  ------------------
  |  Branch (189:10): [True: 2.31k, False: 2.31k]
  ------------------
  190|  2.31k|    const auto chunk_end = std::min(chunk_begin + 1024, string_end);
  191|  2.31k|    detail::write_escaped(context, chunk_begin, chunk_end);
  192|  2.31k|    chunk_begin = chunk_end;
  193|  2.31k|  }
  194|       |
  195|  2.31k|  context.append('"');
  196|  2.31k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113decode_stringERNS0_14decode_contextE:
  159|  17.9k|string_t::object_type decode_string(decode_context &context) {
  160|  17.9k|  const auto begin_simple = context.position;
  161|  17.9k|  detail::skip_any_simple_characters(context);
  162|       |
  163|  17.9k|  switch (detail::next(context, "Unterminated string")) {
  164|  7.71k|    case '"': return std::string(begin_simple, context.position - 1);
  ------------------
  |  Branch (164:5): [True: 7.71k, False: 10.1k]
  ------------------
  165|  10.1k|    case '\\': return decode_escaped_string(context, begin_simple);
  ------------------
  |  Branch (165:5): [True: 10.1k, False: 7.78k]
  ------------------
  166|      0|    default: json_unreachable();
  ------------------
  |  |   34|      0|  #define json_unreachable() __builtin_unreachable()
  ------------------
  |  Branch (166:5): [True: 0, False: 17.9k]
  ------------------
  167|  17.9k|  }
  168|  17.9k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_121decode_escaped_stringERNS0_14decode_contextEPKc:
  140|  10.1k|string_t::object_type decode_escaped_string(decode_context &context, const char *begin) {
  141|  10.1k|  std::string unescaped(begin, context.position - 1);
  142|  10.1k|  decode_escape(context, unescaped);
  143|       |
  144|  60.4k|  while (json_likely(context.remaining())) {
  ------------------
  |  |   32|  60.4k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 60.0k, False: 427]
  |  |  ------------------
  ------------------
  145|  60.0k|    const auto begin_simple = context.position;
  146|  60.0k|    detail::skip_any_simple_characters(context);
  147|  60.0k|    unescaped.append(begin_simple, context.position);
  148|       |
  149|  60.0k|    switch (detail::next(context, "Unterminated string")) {
  150|  9.41k|      case '"': return unescaped;
  ------------------
  |  Branch (150:7): [True: 9.41k, False: 50.6k]
  ------------------
  151|  50.4k|      case '\\': decode_escape(context, unescaped); break;
  ------------------
  |  Branch (151:7): [True: 50.4k, False: 9.59k]
  ------------------
  152|      0|      default: json_unreachable();
  ------------------
  |  |   34|      0|  #define json_unreachable() __builtin_unreachable()
  ------------------
  |  Branch (152:7): [True: 0, False: 60.0k]
  ------------------
  153|  60.0k|    }
  154|  60.0k|  }
  155|       |
  156|    427|  detail::fail(context, "Unterminated string");
  157|  10.1k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113decode_escapeERNS0_14decode_contextERNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  124|  60.5k|void decode_escape(decode_context &context, std::string &out) {
  125|  60.5k|  const auto escape_character = detail::next(context, "Unterminated string");
  126|  60.5k|  switch (escape_character) {
  127|  13.6k|    case '"':  out.push_back('"');  break;
  ------------------
  |  Branch (127:5): [True: 13.6k, False: 46.9k]
  ------------------
  128|  1.87k|    case '/':  out.push_back('/');  break;
  ------------------
  |  Branch (128:5): [True: 1.87k, False: 58.7k]
  ------------------
  129|  9.19k|    case 'b':  out.push_back('\b'); break;
  ------------------
  |  Branch (129:5): [True: 9.19k, False: 51.3k]
  ------------------
  130|    938|    case 'f':  out.push_back('\f'); break;
  ------------------
  |  Branch (130:5): [True: 938, False: 59.6k]
  ------------------
  131|  1.13k|    case 'n':  out.push_back('\n'); break;
  ------------------
  |  Branch (131:5): [True: 1.13k, False: 59.4k]
  ------------------
  132|  1.47k|    case 'r':  out.push_back('\r'); break;
  ------------------
  |  Branch (132:5): [True: 1.47k, False: 59.1k]
  ------------------
  133|  1.69k|    case 't':  out.push_back('\t'); break;
  ------------------
  |  Branch (133:5): [True: 1.69k, False: 58.8k]
  ------------------
  134|  12.3k|    case '\\': out.push_back('\\'); break;
  ------------------
  |  Branch (134:5): [True: 12.3k, False: 48.1k]
  ------------------
  135|  18.0k|    case 'u': decode_unicode_escape(context, out); break;
  ------------------
  |  Branch (135:5): [True: 18.0k, False: 42.5k]
  ------------------
  136|     42|    default: detail::fail(context, "Invalid escape character", -1);
  ------------------
  |  Branch (136:5): [True: 42, False: 60.5k]
  ------------------
  137|  60.5k|  }
  138|  60.5k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_121decode_unicode_escapeERNS0_14decode_contextERNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  117|  18.0k|void decode_unicode_escape(decode_context &context, std::string &out) {
  118|  18.0k|  const auto p = decode_hex_number(context);
  119|  18.0k|  if (json_likely(!handle_surrogate_pair(context, out, p))) {
  ------------------
  |  |   32|  18.0k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 17.3k, False: 764]
  |  |  ------------------
  ------------------
  120|  17.3k|    encode_utf8(out, p);
  121|  17.3k|  }
  122|  18.0k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_117decode_hex_numberERNS0_14decode_contextE:
   49|  20.7k|unsigned decode_hex_number(decode_context &context) {
   50|  20.7k|  detail::require_bytes<4>(context, "\\u must be followed by 4 hex digits");
   51|  20.7k|  const auto a = decode_hex_nibble(context, *(context.position++));
   52|  20.7k|  const auto b = decode_hex_nibble(context, *(context.position++));
   53|  20.7k|  const auto c = decode_hex_nibble(context, *(context.position++));
   54|  20.7k|  const auto d = decode_hex_nibble(context, *(context.position++));
   55|  20.7k|  return unsigned((a << 12) | (b << 8) | (c << 4) | d);
   56|  20.7k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_117decode_hex_nibbleERNS0_14decode_contextEc:
   42|  82.9k|uint8_t decode_hex_nibble(decode_context &context, const char c) {
   43|  82.9k|  if (c >= '0' && c <= '9') { return c - '0'; }
  ------------------
  |  Branch (43:7): [True: 82.8k, False: 65]
  |  Branch (43:19): [True: 33.4k, False: 49.3k]
  ------------------
   44|  49.4k|  if (c >= 'a' && c <= 'f') { return c - 'a' + 0xA; }
  ------------------
  |  Branch (44:7): [True: 11.9k, False: 37.4k]
  |  Branch (44:19): [True: 11.9k, False: 21]
  ------------------
   45|  37.4k|  if (c >= 'A' && c <= 'F') { return c - 'A' + 0xA; }
  ------------------
  |  Branch (45:7): [True: 37.3k, False: 79]
  |  Branch (45:19): [True: 37.3k, False: 52]
  ------------------
   46|    131|  detail::fail(context, "\\u must be followed by 4 hex digits");
   47|  37.4k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_121handle_surrogate_pairERNS0_14decode_contextERNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEj:
   97|  17.9k|bool handle_surrogate_pair(decode_context &context, std::string &out, unsigned p) {
   98|  17.9k|  if (json_unlikely(is_high_surrogate(p))) {
  ------------------
  |  |   33|  17.9k|  #define json_unlikely(expr) __builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (33:31): [True: 5.80k, False: 12.1k]
  |  |  ------------------
  ------------------
   99|       |    // Parse low surrogate
  100|  5.80k|    if (detail::peek_2(context, '\\', 'u')) {
  ------------------
  |  Branch (100:9): [True: 2.70k, False: 3.10k]
  ------------------
  101|  2.70k|      detail::skip_unchecked_n(context, 2);
  102|  2.70k|      const auto n = decode_hex_number(context);
  103|  2.70k|      if (json_likely(is_low_surrogate(n))) {
  ------------------
  |  |   32|  2.70k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 620, False: 2.08k]
  |  |  ------------------
  ------------------
  104|       |        // Any Unicode codepoint encoded by a surrogate pair is 4 bytes in UTF-8
  105|    620|        encode_utf8_4(out, codepoint_from_surrogate_pair(p, n));
  106|    620|        return true;
  107|  2.08k|      } else {
  108|       |        // Rewind context to before the escape sequence
  109|  2.08k|        context.position -= 6;
  110|  2.08k|      }
  111|  2.70k|    }
  112|  5.80k|  }
  113|       |
  114|  17.3k|  return false;
  115|  17.9k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_117is_high_surrogateEj:
   30|  17.9k|bool is_high_surrogate(unsigned p) {
   31|  17.9k|  return (p & 0xFC00) == 0xD800;
   32|  17.9k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_116is_low_surrogateEj:
   34|  2.69k|bool is_low_surrogate(unsigned p) {
   35|  2.69k|  return (p & 0xFC00) == 0xDC00;
   36|  2.69k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113encode_utf8_4ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   58|    620|void encode_utf8_4(std::string &out, uint32_t p) {
   59|    620|  const char c0 = 0xF0 | ((p >> 18) & 0x07);
   60|    620|  const char c1 = 0x80 | ((p >> 12) & 0x3F);
   61|    620|  const char c2 = 0x80 | ((p >>  6) & 0x3F);
   62|    620|  const char c3 = 0x80 | ((p >>  0) & 0x3F);
   63|    620|  const char cc[] = { c0, c1, c2, c3 };
   64|    620|  out.append(&cc[0], 4);
   65|    620|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_129codepoint_from_surrogate_pairEjj:
   38|    620|uint32_t codepoint_from_surrogate_pair(uint32_t high, uint32_t low) {
   39|    620|  return (((high & 0x03FF) << 10) | (low & 0x03FF)) + 0x10000;
   40|    620|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_111encode_utf8ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   87|  17.3k|void encode_utf8(std::string &out, unsigned p) {
   88|  17.3k|  if (json_likely(p <= 0x7F)) {
  ------------------
  |  |   32|  17.3k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 808, False: 16.5k]
  |  |  ------------------
  ------------------
   89|    808|    encode_utf8_1(out, p);
   90|  16.5k|  } else if (json_likely(p <= 0x07FF)) {
  ------------------
  |  |   32|  16.5k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 5.09k, False: 11.4k]
  |  |  ------------------
  ------------------
   91|  5.09k|    encode_utf8_2(out, p);
   92|  11.4k|  } else {
   93|  11.4k|    encode_utf8_3(out, p);
   94|  11.4k|  }
   95|  17.3k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113encode_utf8_1ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   82|    808|void encode_utf8_1(std::string &out, unsigned p) {
   83|    808|  const char c0 = (p & 0x7F);
   84|    808|  out.push_back(c0);
   85|    808|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113encode_utf8_2ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   75|  5.09k|void encode_utf8_2(std::string &out, unsigned p) {
   76|  5.09k|  const char c0 = 0xC0 | ((p >> 6) & 0x1F);
   77|  5.09k|  const char c1 = 0x80 | ((p >> 0) & 0x3F);
   78|  5.09k|  const char cc[] = { c0, c1 };
   79|  5.09k|  out.append(&cc[0], 2);
   80|  5.09k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113encode_utf8_3ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   67|  11.4k|void encode_utf8_3(std::string &out, unsigned p) {
   68|  11.4k|  const char c0 = 0xE0 | ((p >> 12) & 0x0F);
   69|  11.4k|  const char c1 = 0x80 | ((p >>  6) & 0x3F);
   70|  11.4k|  const char c2 = 0x80 | ((p >>  0) & 0x3F);
   71|  11.4k|  const char cc[] = { c0, c1, c2 };
   72|  11.4k|  out.append(&cc[0], 3);
   73|  11.4k|}

_ZN7spotify4json14decode_contextC2EPKcS3_:
   23|  2.31k|    : has_sse42(detail::cpuid().has_sse42()),
   24|  2.31k|      position(begin),
   25|  2.31k|      begin(begin),
   26|  2.31k|      end(end) {}

_ZN7spotify4json16decode_exceptionC2EPKcm:
   23|  2.30k|    : runtime_error(what), _offset(offset) {}

_ZN7spotify4json6detail11bitset_baseD2Ev:
   23|  2.31k|bitset_base::~bitset_base() = default;
_ZN7spotify4json6detail11bitset_baseC2EmPh:
   25|  2.31k|bitset_base::bitset_base(const std::size_t size, uint8_t *inline_base) {
   26|  2.31k|  if (inline_base) {
  ------------------
  |  Branch (26:7): [True: 2.31k, False: 0]
  ------------------
   27|  2.31k|    _base = inline_base;
   28|  2.31k|  } else {
   29|      0|    _vector.reset(new std::vector<uint8_t>((size + 7) / 8));
   30|      0|    _base = _vector->data();
   31|      0|  }
   32|  2.31k|}

_ZN7spotify4json6detail4failERKNS0_14decode_contextEPKcl:
   23|  2.30k|json_noreturn void fail(const decode_context &context, const char *error, ptrdiff_t d ) {
   24|  2.30k|  throw decode_exception(error, context.offset(d));
   25|  2.30k|}

_ZN7spotify4json6detail13write_escapedERNS0_14encode_contextEPKcS5_:
   47|  2.31k|void write_escaped(encode_context &context, const char *begin, const char *end) {
   48|  2.31k|#if defined(json_arch_x86_sse42)
   49|  2.31k|  if (json_likely(context.has_sse42)) {
  ------------------
  |  |   32|  2.31k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 2.31k, False: 0]
  |  |  ------------------
  ------------------
   50|  2.31k|    return write_escaped_sse42(context, begin, end);
   51|  2.31k|  }
   52|      0|#endif  // defined(json_arch_x86_sse42)
   53|      0|  write_escaped_scalar(context, begin, end);
   54|      0|}

_ZN7spotify4json6detail15write_escaped_1ERPcRPKc:
   86|  2.31k|json_force_inline void write_escaped_1(char *&out, const char *&begin) {
   87|  2.31k|  struct blob_1_t { char a; };
   88|  2.31k|  const auto b = *reinterpret_cast<const blob_1_t *>(begin);
   89|  2.31k|  write_escaped_c(out, b.a);
   90|  2.31k|  begin += sizeof(blob_1_t);
   91|  2.31k|}
_ZN7spotify4json6detail15write_escaped_cERPcc:
   32|  2.31k|json_force_inline void write_escaped_c(char *&out, const char c) {
   33|  2.31k|  static const char HEX[] = "0123456789ABCDEF";
   34|  2.31k|  static const char POPULAR_CONTROL_CHARACTERS[] = {
   35|  2.31k|    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
   36|  2.31k|    'b', 't', 'n', 'u', 'f', 'r', 'u', 'u',
   37|  2.31k|    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
   38|  2.31k|    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u'
   39|  2.31k|  };
   40|       |
   41|       |  // All characters above 0x20 can be written as is, except for ", /. The former
   42|       |  // is below 0x30 and the latter is at 0x5C. As an optimization, for most
   43|       |  // simple strings (letters, numbers, some punctuation), check for this first
   44|       |  // before doing more complicated checks (more expensive checks).
   45|  2.31k|  if (json_likely(uint8_t(c) >= 0x30)) {
  ------------------
  |  |   32|  2.31k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 2.31k, False: 0]
  |  |  ------------------
  ------------------
   46|  2.31k|    if (json_likely(c != '\\')) {
  ------------------
  |  |   32|  2.31k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 2.31k, False: 0]
  |  |  ------------------
  ------------------
   47|  2.31k|      *(out++) = c;
   48|  2.31k|    } else {
   49|      0|      *(out++) = '\\';
   50|      0|      *(out++) = c;
   51|      0|    }
   52|  2.31k|    return;
   53|  2.31k|  }
   54|       |
   55|       |  // In the next step, consider the characters between 0x20 and 0x30, which are
   56|       |  // different punctuation and special characters. We will write most of them as
   57|       |  // is, except for ", which is trivially escaped. Note that JSON allows for /
   58|       |  // to be escaped as well, but most JSON serializers do not.
   59|      0|  if (json_likely(uint8_t(c) >= 0x20)) {
  ------------------
  |  |   32|      0|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   60|      0|    if (json_likely(c != '"')) {
  ------------------
  |  |   32|      0|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   61|      0|      *(out++) = c;
   62|      0|    } else {
   63|      0|      *(out++) = '\\';
   64|      0|      *(out++) = c;
   65|      0|    }
   66|      0|    return;
   67|      0|  }
   68|       |
   69|       |  // Finally handle all control characters (below 0x20). These all need escaping
   70|       |  // to some degree. There are some "popular" control characters, such as tabs,>
   71|       |  // newline, and carriage return, with simple escape codes. All other control
   72|       |  // characters get an escape code on the form \u00xx. Six bytes. Isch.
   73|      0|  const auto control_character = POPULAR_CONTROL_CHARACTERS[int(c)];
   74|      0|  if (json_likely(control_character != 'u')) {
  ------------------
  |  |   32|      0|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   75|      0|    out[0] = '\\';
   76|      0|    out[1] = control_character;
   77|      0|    out += 2;
   78|      0|  } else {
   79|      0|    memcpy(out, "\\u00", 4);
   80|      0|    out[4] = HEX[(c >> 4)];
   81|      0|    out[5] = HEX[(c & 0x0F)];
   82|      0|    out += 6;
   83|      0|  }
   84|      0|}

_ZN7spotify4json6detail19write_escaped_sse42ERNS0_14encode_contextEPKcS5_:
   51|  2.31k|    const char *end) {
   52|  2.31k|  const auto buf = context.reserve(6 * (end - begin));  // 6 is the length of \u00xx
   53|  2.31k|  auto out = buf;
   54|       |
   55|  2.31k|  const __m128i ranges = _mm_setr_epi8(
   56|  2.31k|    0x00, 0x1F,  // null byte & control characters
   57|  2.31k|    0x22, 0x22,  // double quotation mark
   58|  2.31k|    0x5C, 0x5C,  // reverse solidus (backslash)
   59|  2.31k|    0, 0, 0, 0, 0, 0, 0, 0, 0, 0
   60|  2.31k|  );
   61|       |
   62|  2.31k|  if (json_unaligned_2(begin) && (end - begin) >= 1) { write_escaped_1(out, begin); }
  ------------------
  |  |   64|  4.63k|#define json_unaligned_2(p)  (reinterpret_cast<intptr_t>(p) & 0x1)
  |  |  ------------------
  |  |  |  Branch (64:30): [True: 2.31k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (62:34): [True: 2.31k, False: 0]
  ------------------
   63|  2.31k|  if (json_unaligned_4(begin) && (end - begin) >= 2) { write_escaped_2(out, begin); }
  ------------------
  |  |   65|  4.63k|#define json_unaligned_4(p)  (reinterpret_cast<intptr_t>(p) & 0x3)
  |  |  ------------------
  |  |  |  Branch (65:30): [True: 2.31k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (63:34): [True: 0, False: 2.31k]
  ------------------
   64|  2.31k|  if (json_unaligned_8(begin) && (end - begin) >= 4) { write_escaped_4(out, begin); }
  ------------------
  |  |   66|  4.63k|#define json_unaligned_8(p)  (reinterpret_cast<intptr_t>(p) & 0x7)
  |  |  ------------------
  |  |  |  Branch (66:30): [True: 2.31k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (64:34): [True: 0, False: 2.31k]
  ------------------
   65|  2.31k|  if (json_unaligned_16(begin) && (end - begin) >= 8) { write_escaped_8(out, begin); }
  ------------------
  |  |   67|  4.63k|#define json_unaligned_16(p) (reinterpret_cast<intptr_t>(p) & 0xF)
  |  |  ------------------
  |  |  |  Branch (67:30): [True: 2.31k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (65:35): [True: 0, False: 2.31k]
  ------------------
   66|       |
   67|  2.31k|  for (; end - begin >= 16; begin += 16) {
  ------------------
  |  Branch (67:10): [True: 0, False: 2.31k]
  ------------------
   68|      0|    const __m128i chunk = _mm_load_si128(reinterpret_cast<const __m128i *>(begin));
   69|      0|    const unsigned has_character_in_ranges = _mm_cmpestrc(ranges, 6, chunk, 16, _SIDD_CMP_RANGES);
   70|      0|    if (json_likely(!has_character_in_ranges)) {
  ------------------
  |  |   32|      0|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   71|      0|      _mm_storeu_si128(reinterpret_cast<__m128i *>(out), chunk);
   72|      0|      out += 16;
   73|      0|    } else {
   74|      0|      write_escaped_16_sse42(out, chunk);
   75|      0|    }
   76|      0|  }
   77|       |
   78|  2.31k|  if ((end - begin) >= 8) { write_escaped_8(out, begin); }
  ------------------
  |  Branch (78:7): [True: 0, False: 2.31k]
  ------------------
   79|  2.31k|  if ((end - begin) >= 4) { write_escaped_4(out, begin); }
  ------------------
  |  Branch (79:7): [True: 0, False: 2.31k]
  ------------------
   80|  2.31k|  if ((end - begin) >= 2) { write_escaped_2(out, begin); }
  ------------------
  |  Branch (80:7): [True: 0, False: 2.31k]
  ------------------
   81|  2.31k|  if ((end - begin) >= 1) { write_escaped_1(out, begin); }
  ------------------
  |  Branch (81:7): [True: 0, False: 2.31k]
  ------------------
   82|       |
   83|  2.31k|  context.advance(out - buf);
   84|  2.31k|}

_ZN7spotify4json6detail14field_registryC2Ev:
   36|  2.31k|field_registry::field_registry() = default;
_ZN7spotify4json6detail14field_registryD2Ev:
   37|  2.31k|field_registry::~field_registry() = default;
_ZN7spotify4json6detail14field_registry4saveERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEbRKNS3_10shared_ptrINS1_5fieldEEE:
   42|  2.31k|                          const std::shared_ptr<field> &f) {
   43|  2.31k|  const auto was_saved =
   44|  2.31k|      _fields.insert(typename field_map::value_type(name, f)).second;
   45|  2.31k|  if (was_saved) {
  ------------------
  |  Branch (45:7): [True: 2.31k, False: 0]
  ------------------
   46|  2.31k|    _field_list.push_back(std::make_pair(escape_key(name), f));
   47|  2.31k|    _num_required_fields += required ? 1 : 0;
  ------------------
  |  Branch (47:29): [True: 2.31k, False: 0]
  ------------------
   48|  2.31k|  }
   49|  2.31k|}
_ZNK7spotify4json6detail14field_registry4findERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   51|  15.6k|const field *field_registry::find(const std::string &name) const noexcept {
   52|  15.6k|  const auto field_it = _fields.find(name);
   53|  15.6k|  if (json_likely(field_it != _fields.end())) {
  ------------------
  |  |   32|  15.6k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 1.40k, False: 14.2k]
  |  |  ------------------
  ------------------
   54|  1.40k|    return (*field_it).second.get();
   55|  14.2k|  } else {
   56|  14.2k|    return nullptr;
   57|  14.2k|  }
   58|  15.6k|}
field_registry.cpp:_ZN7spotify4json6detail12_GLOBAL__N_110escape_keyERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   27|  2.31k|std::string escape_key(const std::string &key) {
   28|  2.31k|  encode_context context;
   29|  2.31k|  codec::string().encode(context, key);
   30|  2.31k|  context.append(':');
   31|  2.31k|  return std::string(context.data(), context.size());
   32|  2.31k|}

_ZN7spotify4json6detail26skip_any_whitespace_scalarERNS0_14decode_contextE:
   40|  2.32k|void skip_any_whitespace_scalar(decode_context &context) {
   41|  2.32k|  const auto end = context.end;
   42|  2.32k|  auto pos = context.position;
   43|  3.38k|  while (pos < end && is_space(*pos)) {
  ------------------
  |  Branch (43:10): [True: 3.34k, False: 42]
  |  Branch (43:23): [True: 1.05k, False: 2.28k]
  ------------------
   44|  1.05k|    ++pos;
   45|  1.05k|  }
   46|  2.32k|  context.position = pos;
   47|  2.32k|}

_ZN7spotify4json6detail8is_spaceEc:
   33|  1.22M|json_force_inline bool is_space(const char c) {
   34|  1.22M|  return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
  ------------------
  |  Branch (34:11): [True: 13.2k, False: 1.21M]
  |  Branch (34:23): [True: 676, False: 1.21M]
  |  Branch (34:36): [True: 689, False: 1.21M]
  |  Branch (34:49): [True: 902, False: 1.21M]
  ------------------
   35|  1.22M|}

_ZN7spotify4json6detail32skip_any_simple_characters_sse42ERNS0_14decode_contextE:
   29|   182k|void skip_any_simple_characters_sse42(decode_context &context) {
   30|   182k|  const auto end = context.end;
   31|   182k|  auto pos = context.position;
   32|       |
   33|   182k|  JSON_STRING_SKIP_N_SIMPLE(1,  2, uint8_t,  if, done_x)
  ------------------
  |  |   22|   182k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   64|   182k|#define json_unaligned_2(p)  (reinterpret_cast<intptr_t>(p) & 0x1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (64:30): [True: 86.1k, False: 96.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 182k, False: 10]
  |  |  ------------------
  |  |   23|  86.1k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  86.1k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   59|  86.1k|#define json_haschar_1(v, c) (v == c)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:30): [True: 11.4k, False: 74.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  86.1k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   59|  74.6k|#define json_haschar_1(v, c) (v == c)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:30): [True: 21.0k, False: 53.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  74.6k|    pos += n; \
  |  |   27|  53.6k|  }
  ------------------
   34|   150k|  JSON_STRING_SKIP_N_SIMPLE(2,  4, uint16_t, if, done_2)
  ------------------
  |  |   22|   150k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   65|   150k|#define json_unaligned_4(p)  (reinterpret_cast<intptr_t>(p) & 0x3)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:30): [True: 76.0k, False: 74.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 150k, False: 209]
  |  |  ------------------
  |  |   23|  76.0k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  76.0k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   60|  76.0k|#define json_haschar_2(v, c) uint16_t(json_haszero_2((v) ^ (~0U/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  76.0k|#define json_haszero_2(v) uint16_t(((v) - 0x0101U) & ~(v) & 0x8080U)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:30): [True: 13.8k, False: 62.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  76.0k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   60|  62.2k|#define json_haschar_2(v, c) uint16_t(json_haszero_2((v) ^ (~0U/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  62.2k|#define json_haszero_2(v) uint16_t(((v) - 0x0101U) & ~(v) & 0x8080U)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:30): [True: 17.5k, False: 44.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  62.2k|    pos += n; \
  |  |   27|  44.6k|  }
  ------------------
   35|   118k|  JSON_STRING_SKIP_N_SIMPLE(4,  8, uint32_t, if, done_4)
  ------------------
  |  |   22|   118k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   66|   118k|#define json_unaligned_8(p)  (reinterpret_cast<intptr_t>(p) & 0x7)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:30): [True: 59.5k, False: 58.9k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 118k, False: 418]
  |  |  ------------------
  |  |   23|  59.5k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  59.5k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   61|  59.5k|#define json_haschar_4(v, c) uint32_t(json_haszero_4((v) ^ (~0UL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  59.5k|#define json_haszero_4(v) uint32_t(((v) - 0x01010101UL) & ~(v) & 0x80808080UL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:30): [True: 9.81k, False: 49.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  59.5k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   61|  49.7k|#define json_haschar_4(v, c) uint32_t(json_haszero_4((v) ^ (~0UL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  49.7k|#define json_haszero_4(v) uint32_t(((v) - 0x01010101UL) & ~(v) & 0x80808080UL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:30): [True: 13.9k, False: 35.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  49.7k|    pos += n; \
  |  |   27|  35.7k|  }
  ------------------
   36|  95.1k|  JSON_STRING_SKIP_N_SIMPLE(8, 16, uint64_t, if, done_8)
  ------------------
  |  |   22|  95.1k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   67|  94.5k|#define json_unaligned_16(p) (reinterpret_cast<intptr_t>(p) & 0xF)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (67:30): [True: 47.5k, False: 47.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 94.5k, False: 595]
  |  |  ------------------
  |  |   23|  47.5k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  47.5k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   62|  47.5k|#define json_haschar_8(v, c) uint64_t(json_haszero_8((v) ^ (~0ULL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   58|  47.5k|#define json_haszero_8(v) uint64_t(((v) - 0x0101010101010101ULL) & ~(v) & 0x8080808080808080ULL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (62:30): [True: 8.68k, False: 38.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  47.5k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   62|  38.8k|#define json_haschar_8(v, c) uint64_t(json_haszero_8((v) ^ (~0ULL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   58|  38.8k|#define json_haszero_8(v) uint64_t(((v) - 0x0101010101010101ULL) & ~(v) & 0x8080808080808080ULL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (62:30): [True: 13.4k, False: 25.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  38.8k|    pos += n; \
  |  |   27|  25.4k|  }
  ------------------
   37|       |
   38|  73.0k|  {
   39|  73.0k|    alignas(16) static const char CHARS[16] = "\"\\";
   40|  73.0k|    const auto chars = _mm_load_si128(reinterpret_cast<const __m128i *>(&CHARS[0]));
   41|       |
   42|  2.34M|    for (; end - pos >= 16; pos += 16) {
  ------------------
  |  Branch (42:12): [True: 2.34M, False: 986]
  ------------------
   43|  2.34M|      const auto chunk = _mm_load_si128(reinterpret_cast<const __m128i *>(pos));
   44|  2.34M|      constexpr auto flags = _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_POSITIVE_POLARITY | _SIDD_LEAST_SIGNIFICANT;
   45|  2.34M|      const auto index = _mm_cmpestri(chars, 2, chunk, 16, flags);
   46|  2.34M|      if (index != 16) {
  ------------------
  |  Branch (46:11): [True: 72.0k, False: 2.27M]
  ------------------
   47|  72.0k|        context.position = pos + index;
   48|  72.0k|        return;
   49|  72.0k|      }
   50|  2.34M|    }
   51|  73.0k|  }
   52|       |
   53|    986|          JSON_STRING_SKIP_N_SIMPLE(8, x, uint64_t, while, done_8)
  ------------------
  |  |   22|  1.10k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   19|    302|#define json_unaligned_x(ignore) true
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (19:34): [True: 302, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 302, False: 805]
  |  |  ------------------
  |  |   23|    302|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|    302|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   62|    302|#define json_haschar_8(v, c) uint64_t(json_haszero_8((v) ^ (~0ULL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   58|    302|#define json_haszero_8(v) uint64_t(((v) - 0x0101010101010101ULL) & ~(v) & 0x8080808080808080ULL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (62:30): [True: 90, False: 212]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|    302|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   62|    212|#define json_haschar_8(v, c) uint64_t(json_haszero_8((v) ^ (~0ULL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   58|    212|#define json_haszero_8(v) uint64_t(((v) - 0x0101010101010101ULL) & ~(v) & 0x8080808080808080ULL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (62:30): [True: 91, False: 121]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|    212|    pos += n; \
  |  |   27|    121|  }
  ------------------
   54|  23.1k|  done_8: JSON_STRING_SKIP_N_SIMPLE(4, x, uint32_t, while, done_4)
  ------------------
  |  |   22|  29.7k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   19|  29.0k|#define json_unaligned_x(ignore) true
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (19:34): [True: 29.0k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 29.0k, False: 645]
  |  |  ------------------
  |  |   23|  29.0k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  29.0k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   61|  29.0k|#define json_haschar_4(v, c) uint32_t(json_haszero_4((v) ^ (~0UL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  29.0k|#define json_haszero_4(v) uint32_t(((v) - 0x01010101UL) & ~(v) & 0x80808080UL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:30): [True: 7.86k, False: 21.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  29.0k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   61|  21.2k|#define json_haschar_4(v, c) uint32_t(json_haszero_4((v) ^ (~0UL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  21.2k|#define json_haszero_4(v) uint32_t(((v) - 0x01010101UL) & ~(v) & 0x80808080UL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:30): [True: 14.6k, False: 6.59k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  21.2k|    pos += n; \
  |  |   27|  6.59k|  }
  ------------------
   55|  46.8k|  done_4: JSON_STRING_SKIP_N_SIMPLE(2, x, uint16_t, while, done_2)
  ------------------
  |  |   22|  59.9k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   19|  59.4k|#define json_unaligned_x(ignore) true
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (19:34): [True: 59.4k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 59.4k, False: 422]
  |  |  ------------------
  |  |   23|  59.4k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  59.4k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   60|  59.4k|#define json_haschar_2(v, c) uint16_t(json_haszero_2((v) ^ (~0U/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  59.4k|#define json_haszero_2(v) uint16_t(((v) - 0x0101U) & ~(v) & 0x8080U)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:30): [True: 14.9k, False: 44.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  59.4k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   60|  44.5k|#define json_haschar_2(v, c) uint16_t(json_haszero_2((v) ^ (~0U/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  44.5k|#define json_haszero_2(v) uint16_t(((v) - 0x0101U) & ~(v) & 0x8080U)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:30): [True: 31.4k, False: 13.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  44.5k|    pos += n; \
  |  |   27|  13.0k|  }
  ------------------
   56|  78.2k|  done_2: JSON_STRING_SKIP_N_SIMPLE(1, x, uint8_t,  while, done_x)
  ------------------
  |  |   22|  99.8k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   19|  99.5k|#define json_unaligned_x(ignore) true
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (19:34): [True: 99.5k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 99.5k, False: 299]
  |  |  ------------------
  |  |   23|  99.5k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  99.5k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   59|  99.5k|#define json_haschar_1(v, c) (v == c)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:30): [True: 18.2k, False: 81.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  99.5k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   59|  81.2k|#define json_haschar_1(v, c) (v == c)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:30): [True: 59.7k, False: 21.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  81.2k|    pos += n; \
  |  |   27|  21.5k|  }
  ------------------
   57|   110k|  done_x: context.position = pos;
   58|   110k|}
_ZN7spotify4json6detail25skip_any_whitespace_sse42ERNS0_14decode_contextE:
   60|  1.29M|void skip_any_whitespace_sse42(decode_context &context) {
   61|  1.29M|  const auto end = context.end;
   62|  1.29M|  auto pos = context.position;
   63|       |
   64|  1.30M|  for (; pos < end && json_unaligned_16(pos); ++pos) {
  ------------------
  |  |   67|  1.30M|#define json_unaligned_16(p) (reinterpret_cast<intptr_t>(p) & 0xF)
  |  |  ------------------
  |  |  |  Branch (67:30): [True: 1.22M, False: 82.4k]
  |  |  ------------------
  ------------------
  |  Branch (64:10): [True: 1.30M, False: 385]
  ------------------
   65|  1.22M|    if (!is_space(*pos)) {
  ------------------
  |  Branch (65:9): [True: 1.21M, False: 14.2k]
  ------------------
   66|  1.21M|      context.position = pos;
   67|  1.21M|      return;
   68|  1.21M|    }
   69|  1.22M|  }
   70|       |
   71|  82.8k|  alignas(16) static const char CHARS[16] = " \t\n\r";
   72|  82.8k|  const auto chars = _mm_load_si128(reinterpret_cast<const __m128i *>(&CHARS[0]));
   73|       |
   74|  88.5k|  for (; end - pos >= 16; pos += 16) {
  ------------------
  |  Branch (74:10): [True: 87.7k, False: 788]
  ------------------
   75|  87.7k|    const auto chunk = _mm_load_si128(reinterpret_cast<const __m128i *>(pos));
   76|  87.7k|    constexpr auto flags = _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_NEGATIVE_POLARITY | _SIDD_LEAST_SIGNIFICANT;
   77|  87.7k|    const auto index = _mm_cmpestri(chars, 4, chunk, 16, flags);
   78|  87.7k|    if (index != 16) {
  ------------------
  |  Branch (78:9): [True: 82.0k, False: 5.69k]
  ------------------
   79|  82.0k|      context.position = pos + index;
   80|  82.0k|      return;
   81|  82.0k|    }
   82|  87.7k|  }
   83|       |
   84|    984|  while (pos < end && is_space(*pos)) {
  ------------------
  |  Branch (84:10): [True: 576, False: 408]
  |  Branch (84:23): [True: 196, False: 380]
  ------------------
   85|    196|    ++pos;
   86|    196|  }
   87|       |
   88|    788|  context.position = pos;
   89|    788|}

_ZN7spotify4json6detail10skip_valueERNS0_14decode_contextE:
  135|  14.2k|void skip_value(decode_context &context) {
  136|  14.2k|  enum state {
  137|  14.2k|    done = 0,
  138|  14.2k|    want = 1 << 0,
  139|  14.2k|    need = 1 << 1,
  140|  14.2k|    read_sep = 1 << 2,
  141|  14.2k|    read_key = 1 << 3,
  142|  14.2k|    read_val = 1 << 4,
  143|       |
  144|  14.2k|    want_sep = want | read_sep,
  145|  14.2k|    want_key = want | read_key,
  146|  14.2k|    need_key = need | read_key,
  147|  14.2k|    want_val = want | read_val,
  148|  14.2k|    need_val = need | read_val
  149|  14.2k|  };
  150|       |
  151|       |  // We can deal with the first 64 nesting levels {[[{[[ ... ]]}]]} without heap
  152|       |  // allocations. Most reasonable JSON will have way less than this, but in case
  153|       |  // we encounter an unusual JSON file (perhaps one designed to stack overflow),
  154|       |  // the nesting stack will be moved over to the heap.
  155|  14.2k|  detail::stack<char, 64> stack;
  156|       |
  157|  14.2k|  auto inside = 0;
  158|  14.2k|  auto closer = int_fast16_t(std::numeric_limits<int16_t>::max());  // a value outside the range of a 'char'
  159|  14.2k|  auto pstate = need_val;
  160|       |
  161|  1.23M|  while (json_likely(context.remaining() && pstate != done)) {
  ------------------
  |  |   32|  2.47M|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 1.22M, False: 14.2k]
  |  |  |  Branch (32:49): [True: 1.23M, False: 1.06k]
  |  |  |  Branch (32:49): [True: 1.22M, False: 13.1k]
  |  |  ------------------
  ------------------
  162|  1.22M|    if (json_likely(inside)) {
  ------------------
  |  |   32|  1.22M|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 1.21M, False: 14.0k]
  |  |  ------------------
  ------------------
  163|  1.21M|      skip_any_whitespace(context);
  164|  1.21M|    }
  165|       |
  166|  1.22M|    const auto c = peek_unchecked(context);
  167|       |
  168|  1.22M|    if (c == ',' && (pstate & read_sep)) {
  ------------------
  |  Branch (168:9): [True: 22.4k, False: 1.20M]
  |  Branch (168:21): [True: 22.4k, False: 3]
  ------------------
  169|  22.4k|      skip_unchecked_1(context);
  170|  22.4k|      pstate = (inside == '{' ? need_key : need_val);
  ------------------
  |  Branch (170:17): [True: 17.7k, False: 4.63k]
  ------------------
  171|  22.4k|      continue;
  172|  22.4k|    }
  173|       |
  174|  1.20M|    if (c == '"' && (pstate & read_key)) {
  ------------------
  |  Branch (174:9): [True: 22.6k, False: 1.17M]
  |  Branch (174:21): [True: 21.1k, False: 1.47k]
  ------------------
  175|  21.1k|      skip_string(context);
  176|  21.1k|      skip_any_whitespace(context);
  177|  21.1k|      skip_1(context, ':');
  178|  21.1k|      pstate = need_val;
  179|  21.1k|      continue;
  180|  21.1k|    }
  181|       |
  182|  1.18M|    if (c == closer && !(pstate & need)) {
  ------------------
  |  Branch (182:9): [True: 40.9k, False: 1.14M]
  |  Branch (182:24): [True: 40.9k, False: 1]
  ------------------
  183|  40.9k|      skip_unchecked_1(context);
  184|  40.9k|      inside = stack.pop();
  185|  40.9k|      closer = inside + 2;  // '{' + 2 == '}', '[' + 2 == ']'
  186|  40.9k|      pstate = (inside ? want_sep : done);
  ------------------
  |  Branch (186:17): [True: 40.4k, False: 542]
  ------------------
  187|  40.9k|      continue;
  188|  40.9k|    }
  189|       |
  190|  1.14M|    fail_if(context, pstate & read_key, "Expected '\"'");
  191|  1.14M|    fail_if(context, pstate & read_sep, inside == '{' ?
  ------------------
  |  Branch (191:41): [True: 21.0k, False: 1.11M]
  ------------------
  192|  21.0k|        "Expected ',' or '}'" :
  193|  1.14M|        "Expected ',' or ']");
  194|       |
  195|  1.14M|    if (c == '{' || c == '[') {
  ------------------
  |  Branch (195:9): [True: 3.64k, False: 1.13M]
  |  Branch (195:21): [True: 1.10M, False: 35.5k]
  ------------------
  196|  1.10M|      skip_unchecked_1(context);
  197|  1.10M|      stack.push(inside);
  198|  1.10M|      inside = c;
  199|  1.10M|      closer = inside + 2;  // '{' + 2 == '}', '[' + 2 == ']'
  200|  1.10M|      pstate = (inside == '{' ? want_key : want_val);
  ------------------
  |  Branch (200:17): [True: 3.60k, False: 1.10M]
  ------------------
  201|  1.10M|      continue;
  202|  1.10M|    }
  203|       |
  204|  35.5k|    skip_simple_value(context);
  205|  35.5k|    pstate = (inside ? want_sep : done);
  ------------------
  |  Branch (205:15): [True: 22.3k, False: 13.2k]
  ------------------
  206|  35.5k|  }
  207|       |
  208|  14.2k|  fail_if(context, inside == '{', "Expected '}'");
  209|  14.2k|  fail_if(context, inside == '[', "Expected ']'");
  210|  14.2k|  fail_if(context, pstate != done, "Unexpected EOF");
  211|  14.2k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_111skip_stringERNS0_14decode_contextE:
   62|  22.6k|void skip_string(decode_context &context) {
   63|  22.6k|  skip_1(context, '"');
   64|       |
   65|   104k|  while (json_likely(context.remaining())) {
  ------------------
  |  |   32|   104k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 104k, False: 112]
  |  |  ------------------
  ------------------
   66|   104k|    detail::skip_any_simple_characters(context);
   67|   104k|    switch (next(context, "Unterminated string")) {
   68|  22.3k|      case '"': return;
  ------------------
  |  Branch (68:7): [True: 22.3k, False: 82.5k]
  ------------------
   69|  82.4k|      case '\\': skip_escape(context); break;
  ------------------
  |  Branch (69:7): [True: 82.4k, False: 22.3k]
  ------------------
   70|      0|      default: json_unreachable();
  ------------------
  |  |   34|      0|  #define json_unreachable() __builtin_unreachable()
  ------------------
  |  Branch (70:7): [True: 0, False: 104k]
  ------------------
   71|   104k|    }
   72|   104k|  }
   73|       |
   74|    112|  detail::fail(context, "Unterminated string");
   75|  22.6k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_111skip_escapeERNS0_14decode_contextE:
   47|  82.4k|void skip_escape(decode_context &context) {
   48|  82.4k|  switch (next(context, "Unterminated string")) {
   49|  16.3k|    case '"':  break;
  ------------------
  |  Branch (49:5): [True: 16.3k, False: 66.1k]
  ------------------
   50|  1.14k|    case '/':  break;
  ------------------
  |  Branch (50:5): [True: 1.14k, False: 81.3k]
  ------------------
   51|  1.80k|    case 'b':  break;
  ------------------
  |  Branch (51:5): [True: 1.80k, False: 80.6k]
  ------------------
   52|  1.76k|    case 'f':  break;
  ------------------
  |  Branch (52:5): [True: 1.76k, False: 80.7k]
  ------------------
   53|  7.29k|    case 'n':  break;
  ------------------
  |  Branch (53:5): [True: 7.29k, False: 75.1k]
  ------------------
   54|  4.09k|    case 'r':  break;
  ------------------
  |  Branch (54:5): [True: 4.09k, False: 78.3k]
  ------------------
   55|  3.05k|    case 't':  break;
  ------------------
  |  Branch (55:5): [True: 3.05k, False: 79.4k]
  ------------------
   56|  11.3k|    case '\\': break;
  ------------------
  |  Branch (56:5): [True: 11.3k, False: 71.1k]
  ------------------
   57|  35.6k|    case 'u': skip_unicode_escape(context); break;
  ------------------
  |  Branch (57:5): [True: 35.6k, False: 46.8k]
  ------------------
   58|      9|    default: detail::fail(context, "Invalid escape character", -1);
  ------------------
  |  Branch (58:5): [True: 9, False: 82.4k]
  ------------------
   59|  82.4k|  }
   60|  82.4k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_119skip_unicode_escapeERNS0_14decode_contextE:
   38|  35.6k|void skip_unicode_escape(decode_context &context) {
   39|  35.6k|  require_bytes<4>(context, "\\u must be followed by 4 hex digits");
   40|  35.6k|  const bool h0 = is_hex_digit(*(context.position++));
   41|  35.6k|  const bool h1 = is_hex_digit(*(context.position++));
   42|  35.6k|  const bool h2 = is_hex_digit(*(context.position++));
   43|  35.6k|  const bool h3 = is_hex_digit(*(context.position++));
   44|  35.6k|  fail_if(context, !(h0 && h1 && h2 && h3), "\\u must be followed by 4 hex digits");
  ------------------
  |  Branch (44:22): [True: 35.5k, False: 66]
  |  Branch (44:28): [True: 35.5k, False: 36]
  |  Branch (44:34): [True: 35.5k, False: 15]
  |  Branch (44:40): [True: 35.5k, False: 12]
  ------------------
   45|  35.6k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_112is_hex_digitEc:
   34|   142k|json_force_inline bool is_hex_digit(const char c) {
   35|   142k|  return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
  ------------------
  |  Branch (35:11): [True: 142k, False: 147]
  |  Branch (35:23): [True: 60.0k, False: 82.3k]
  |  Branch (35:37): [True: 20.4k, False: 62.1k]
  |  Branch (35:49): [True: 20.3k, False: 55]
  |  Branch (35:63): [True: 61.9k, False: 183]
  |  Branch (35:75): [True: 61.8k, False: 125]
  ------------------
   36|   142k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_117skip_simple_valueERNS0_14decode_contextE:
  120|  35.5k|void skip_simple_value(decode_context &context) {
  121|  35.5k|  switch (peek(context)) {
  122|  2.73k|    case '-':  // fallthrough
  ------------------
  |  Branch (122:5): [True: 2.73k, False: 32.8k]
  ------------------
  123|  18.3k|    case '0': case '1': case '2': case '3': case '4':  // fallthrough
  ------------------
  |  Branch (123:5): [True: 2.41k, False: 33.1k]
  |  Branch (123:15): [True: 5.44k, False: 30.0k]
  |  Branch (123:25): [True: 4.15k, False: 31.3k]
  |  Branch (123:35): [True: 1.31k, False: 34.2k]
  |  Branch (123:45): [True: 2.26k, False: 33.2k]
  ------------------
  124|  29.6k|    case '5': case '6': case '7': case '8': case '9': skip_number(context); break;
  ------------------
  |  Branch (124:5): [True: 1.97k, False: 33.5k]
  |  Branch (124:15): [True: 1.49k, False: 34.0k]
  |  Branch (124:25): [True: 4.02k, False: 31.5k]
  |  Branch (124:35): [True: 2.43k, False: 33.1k]
  |  Branch (124:45): [True: 1.44k, False: 34.0k]
  ------------------
  125|  1.46k|    case '"': skip_string(context); break;
  ------------------
  |  Branch (125:5): [True: 1.46k, False: 34.0k]
  ------------------
  126|    829|    case 'f': skip_false(context); break;
  ------------------
  |  Branch (126:5): [True: 829, False: 34.7k]
  ------------------
  127|  2.15k|    case 't': skip_true(context); break;
  ------------------
  |  Branch (127:5): [True: 2.15k, False: 33.3k]
  ------------------
  128|  1.32k|    case 'n': skip_null(context); break;
  ------------------
  |  Branch (128:5): [True: 1.32k, False: 34.2k]
  ------------------
  129|     74|    default: fail(context, (std::string("Encountered token '") + peek(context) + "'").c_str());
  ------------------
  |  Branch (129:5): [True: 74, False: 35.4k]
  ------------------
  130|  35.5k|  }
  131|  35.5k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_111skip_numberERNS0_14decode_contextE:
   77|  29.6k|void skip_number(decode_context &context) {
   78|       |  // Parse negative sign
   79|  29.6k|  if (peek(context) == '-') {
  ------------------
  |  Branch (79:7): [True: 2.73k, False: 26.9k]
  ------------------
   80|  2.73k|    ++context.position;
   81|  2.73k|  }
   82|       |
   83|       |  // Parse integer part
   84|  29.6k|  if (peek(context) == '0') {
  ------------------
  |  Branch (84:7): [True: 2.41k, False: 27.2k]
  ------------------
   85|  2.41k|    ++context.position;
   86|  27.2k|  } else {
   87|  27.2k|    fail_if(context, !is_digit(peek(context)), "Expected digit");
   88|  40.6k|    do { ++context.position; } while (is_digit(peek(context)));
  ------------------
  |  Branch (88:39): [True: 13.3k, False: 27.2k]
  ------------------
   89|  27.2k|  }
   90|       |
   91|       |  // Parse fractional part
   92|  29.6k|  if (peek(context) == '.') {
  ------------------
  |  Branch (92:7): [True: 850, False: 28.8k]
  ------------------
   93|    850|    ++context.position;
   94|    850|    fail_if(context, !is_digit(peek(context)), "Expected digit after decimal point");
   95|  1.09k|    do { ++context.position; } while (is_digit(peek(context)));
  ------------------
  |  Branch (95:39): [True: 243, False: 850]
  ------------------
   96|    850|  }
   97|       |
   98|       |  // Parse exp part
   99|  29.6k|  const char maybe_e = peek(context);
  100|  29.6k|  if (maybe_e == 'e' || maybe_e == 'E') {
  ------------------
  |  Branch (100:7): [True: 1.53k, False: 28.1k]
  |  Branch (100:25): [True: 531, False: 27.6k]
  ------------------
  101|  2.01k|    ++context.position;
  102|  2.01k|    const char maybe_plus_minus = peek(context);
  103|  2.01k|    if (maybe_plus_minus == '+' || maybe_plus_minus == '-') {
  ------------------
  |  Branch (103:9): [True: 928, False: 1.09k]
  |  Branch (103:36): [True: 292, False: 798]
  ------------------
  104|  1.22k|      ++context.position;
  105|  1.22k|    }
  106|       |
  107|  2.01k|    fail_if(context, !is_digit(peek(context)), "Expected digit after exponent sign");
  108|  3.46k|    do { ++context.position; } while (is_digit(peek(context)));
  ------------------
  |  Branch (108:39): [True: 1.45k, False: 2.01k]
  ------------------
  109|  2.01k|  }
  110|  29.6k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_18is_digitEc:
   30|  75.3k|json_force_inline bool is_digit(const char c) {
   31|  75.3k|  return (c >= '0' && c <= '9');
  ------------------
  |  Branch (31:11): [True: 47.1k, False: 28.1k]
  |  Branch (31:23): [True: 45.1k, False: 1.97k]
  ------------------
   32|  75.3k|}

_ZN7spotify4json14encode_contextC2Em:
   27|  2.31k|    : has_sse42(detail::cpuid().has_sse42()),
   28|  2.31k|      _buf(static_cast<char *>(capacity ? std::malloc(capacity) : nullptr)),
  ------------------
  |  Branch (28:32): [True: 2.31k, False: 0]
  ------------------
   29|  2.31k|      _ptr(_buf),
   30|  2.31k|      _end(_buf + capacity),
   31|  2.31k|      _capacity(capacity) {
   32|  2.31k|  if (json_unlikely(!_buf && _capacity > 0)) {
  ------------------
  |  |   33|  2.31k|  #define json_unlikely(expr) __builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (33:31): [True: 0, False: 2.31k]
  |  |  |  Branch (33:51): [True: 0, False: 2.31k]
  |  |  |  Branch (33:51): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   33|      0|    throw std::bad_alloc();
   34|      0|  }
   35|  2.31k|}
_ZN7spotify4json14encode_contextD2Ev:
   37|  2.31k|encode_context::~encode_context() {
   38|  2.31k|  std::free(_buf);
   39|  2.31k|}