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

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

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

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

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

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

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

_ZN7spotify4json6detail5cpuidC2Ev:
   34|  4.56k|  cpuid() {
   35|  4.56k|#if defined(json_arch_x86)
   36|  4.56k|    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.56k|        "cpuid ;\n"
   42|  4.56k|        : "=a" (_registers[cpu_register::eax]),
   43|  4.56k|          "=b" (_registers[cpu_register::ebx]),
   44|  4.56k|          "=c" (_registers[cpu_register::ecx]),
   45|  4.56k|          "=d" (_registers[cpu_register::edx])
   46|  4.56k|        : "a" (cpuid_function)
   47|  4.56k|        :);
   48|  4.56k|#endif  // defined(_MSC_VER)
   49|  4.56k|#endif  // defined(json_arch_x86)
   50|  4.56k|  }
_ZNK7spotify4json6detail5cpuid9has_sse42Ev:
   52|  4.56k|  bool has_sse42() const {
   53|  4.56k|    return has_feature_bit(cpu_register::ecx, cpu_feature_bit::sse_42);
   54|  4.56k|  }
_ZNK7spotify4json6detail5cpuid15has_feature_bitERKNS2_12cpu_register4typeERKNS2_15cpu_feature_bit4typeE:
   74|  4.56k|      const cpu_feature_bit::type &bit) const {
   75|  4.56k|    return (_registers[reg] & (1 << bit)) != 0;
   76|  4.56k|  }

_ZN7spotify4json6detail7fail_ifERKNS0_14decode_contextEbPKcl:
   44|  2.90M|    const ptrdiff_t d = 0) {
   45|  2.90M|  if (json_unlikely(condition)) {
  ------------------
  |  |   33|  2.90M|  #define json_unlikely(expr) __builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (33:31): [True: 1.67k, False: 2.90M]
  |  |  ------------------
  ------------------
   46|  1.67k|    fail(context, error, d);
   47|  1.67k|  }
   48|  2.90M|}
_ZN7spotify4json6detail14peek_uncheckedERKNS0_14decode_contextE:
   60|  1.43M|json_force_inline char peek_unchecked(const decode_context &context) {
   61|  1.43M|  return *context.position;
   62|  1.43M|}
_ZN7spotify4json6detail4peekERKNS0_14decode_contextE:
   70|   225k|json_force_inline char peek(const decode_context &context) {
   71|   225k|  return (context.remaining() ? peek_unchecked(context) : 0);
  ------------------
  |  Branch (71:11): [True: 224k, False: 641]
  ------------------
   72|   225k|}
_ZN7spotify4json6detail6peek_2ERKNS0_14decode_contextEcc:
   79|  6.94k|json_force_inline bool peek_2(const decode_context &context, const char first, const char second) {
   80|  6.94k|  if (context.remaining() < 2) {
  ------------------
  |  Branch (80:7): [True: 41, False: 6.90k]
  ------------------
   81|     41|    return false;
   82|     41|  }
   83|  6.90k|  return first == *context.position && second == *(context.position + 1);
  ------------------
  |  Branch (83:10): [True: 3.82k, False: 3.07k]
  |  Branch (83:40): [True: 3.02k, False: 799]
  ------------------
   84|  6.94k|}
_ZN7spotify4json6detail14next_uncheckedERNS0_14decode_contextE:
   86|   396k|json_force_inline char next_unchecked(decode_context &context) {
   87|   396k|  return *(context.position++);
   88|   396k|}
_ZN7spotify4json6detail4nextERNS0_14decode_contextE:
   96|  88.7k|json_force_inline char next(decode_context &context) {
   97|  88.7k|  return next(context, "Unexpected end of input");
   98|  88.7k|}
_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|  3.02k|json_force_inline void skip_unchecked_n(decode_context &context, const size_t num_bytes) {
  105|  3.02k|  context.position += num_bytes;
  106|  3.02k|}
_ZN7spotify4json6detail6skip_1ERNS0_14decode_contextEc:
  122|  88.7k|json_force_inline void skip_1(decode_context &context, char character) {
  123|  88.7k|  fail_if(context, next(context) != character, "Unexpected input", -1);
  124|  88.7k|}
_ZN7spotify4json6detail6skip_4ERNS0_14decode_contextEPKc:
  131|  4.09k|json_force_inline void skip_4(decode_context &context, const char characters[4]) {
  132|  4.09k|  require_bytes<4>(context);
  133|  4.09k|  fail_if(context, memcmp(characters, context.position, 4) != 0, "Unexpected input");
  134|  4.09k|  context.position += 4;
  135|  4.09k|}
_ZN7spotify4json6detail9skip_trueERNS0_14decode_contextE:
  187|  2.04k|json_force_inline void skip_true(decode_context &context) {
  188|  2.04k|  skip_4(context, "true");
  189|  2.04k|}
_ZN7spotify4json6detail10skip_falseERNS0_14decode_contextE:
  191|    809|json_force_inline void skip_false(decode_context &context) {
  192|    809|  context.position++;  // skip past the 'f' in 'false', we know it is there
  193|    809|  skip_4(context, "alse");
  194|    809|}
_ZN7spotify4json6detail9skip_nullERNS0_14decode_contextE:
  196|  1.24k|json_force_inline void skip_null(decode_context &context) {
  197|  1.24k|  skip_4(context, "null");
  198|  1.24k|}
_ZN7spotify4json6detail4nextIA24_cEEcRNS0_14decode_contextERKT_:
   91|  88.7k|json_force_inline char next(decode_context &context, const string_type &error) {
   92|  88.7k|  require_bytes<1>(context, error);
   93|  88.7k|  return next_unchecked(context);
   94|  88.7k|}
_ZN7spotify4json6detail13require_bytesILm1EA24_cEEvRKNS0_14decode_contextERKT0_:
   51|  88.7k|json_force_inline void require_bytes(const decode_context &context, const string_type &error) {
   52|  88.7k|  fail_if(context, context.remaining() < num_required_bytes, error);
   53|  88.7k|}
_ZN7spotify4json6detail13require_bytesILm4EEEvRKNS0_14decode_contextE:
   56|  4.09k|json_force_inline void require_bytes(const decode_context &context) {
   57|  4.09k|  require_bytes<num_required_bytes>(context, "Unexpected end of input");
   58|  4.09k|}
_ZN7spotify4json6detail13require_bytesILm4EA24_cEEvRKNS0_14decode_contextERKT0_:
   51|  4.09k|json_force_inline void require_bytes(const decode_context &context, const string_type &error) {
   52|  4.09k|  fail_if(context, context.remaining() < num_required_bytes, error);
   53|  4.09k|}
object.cpp:_ZN7spotify4json6detail13decode_objectINS0_5codec8string_tEZNKS3_12codec_detail13object_t_base6decodeERNS0_14decode_contextEPvE3$_0EEvS8_RKT0_:
  176|  2.28k|json_force_inline void decode_object(decode_context &context, const callback_function &callback) {
  177|  2.28k|  auto codec = key_codec_type();
  178|  2.28k|  decode_comma_separated(context, '{', '}', [&]{
  179|  2.28k|    auto key = codec.decode(context);
  180|  2.28k|    skip_any_whitespace(context);
  181|  2.28k|    skip_1(context, ':');
  182|  2.28k|    skip_any_whitespace(context);
  183|  2.28k|    callback(std::move(key));
  184|  2.28k|  });
  185|  2.28k|}
object.cpp:_ZN7spotify4json6detail22decode_comma_separatedIZNS1_13decode_objectINS0_5codec8string_tEZNKS4_12codec_detail13object_t_base6decodeERNS0_14decode_contextEPvE3$_0EEvS9_RKT0_EUlvE_EEvS9_ccT_:
  150|  2.28k|json_never_inline void decode_comma_separated(decode_context &context, char intro, char outro, parse_function parse) {
  151|  2.28k|  skip_1(context, intro);
  152|  2.28k|  skip_any_whitespace(context);
  153|       |
  154|  2.28k|  if (json_likely(peek(context) != outro)) {
  ------------------
  |  |   32|  2.28k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 2.20k, False: 73]
  |  |  ------------------
  ------------------
  155|  2.20k|    parse();
  156|  2.20k|    skip_any_whitespace(context);
  157|       |
  158|  16.7k|    while (json_likely(peek(context) != outro)) {
  ------------------
  |  |   32|  16.7k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 14.5k, False: 2.20k]
  |  |  ------------------
  ------------------
  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.20k|  }
  165|       |
  166|  2.28k|  context.position++;
  167|  2.28k|}
object.cpp:_ZZN7spotify4json6detail13decode_objectINS0_5codec8string_tEZNKS3_12codec_detail13object_t_base6decodeERNS0_14decode_contextEPvE3$_0EEvS8_RKT0_ENKUlvE_clEv:
  178|  16.5k|  decode_comma_separated(context, '{', '}', [&]{
  179|  16.5k|    auto key = codec.decode(context);
  180|  16.5k|    skip_any_whitespace(context);
  181|  16.5k|    skip_1(context, ':');
  182|  16.5k|    skip_any_whitespace(context);
  183|  16.5k|    callback(std::move(key));
  184|  16.5k|  });
_ZN7spotify4json6detail4nextIA20_cEEcRNS0_14decode_contextERKT_:
   91|   308k|json_force_inline char next(decode_context &context, const string_type &error) {
   92|   308k|  require_bytes<1>(context, error);
   93|   308k|  return next_unchecked(context);
   94|   308k|}
_ZN7spotify4json6detail13require_bytesILm1EA20_cEEvRKNS0_14decode_contextERKT0_:
   51|   308k|json_force_inline void require_bytes(const decode_context &context, const string_type &error) {
   52|   308k|  fail_if(context, context.remaining() < num_required_bytes, error);
   53|   308k|}
_ZN7spotify4json6detail13require_bytesILm4EA36_cEEvRKNS0_14decode_contextERKT0_:
   51|  52.6k|json_force_inline void require_bytes(const decode_context &context, const string_type &error) {
   52|  52.6k|  fail_if(context, context.remaining() < num_required_bytes, error);
   53|  52.6k|}

_ZNK7spotify4json6detail14field_registry19num_required_fieldsEv:
   73|  4.58k|  size_t num_required_fields() const noexcept { return _num_required_fields; }
_ZN7spotify4json6detail5fieldC2Ebm:
   39|  2.28k|      : _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.28k, False: 0]
  ------------------
_ZN7spotify4json6detail5fieldD2Ev:
   40|  2.28k|  virtual ~field() = default;
_ZNK7spotify4json6detail5field11is_requiredEv:
   48|  1.39k|  json_force_inline bool is_required() const { return (_data != json_size_t_max); }
  ------------------
  |  |   52|  1.39k|#define json_size_t_max static_cast<size_t>(-1)
  ------------------
_ZNK7spotify4json6detail5field18required_field_idxEv:
   49|  1.39k|  json_force_inline size_t required_field_idx() const { return _data; }

_ZN7spotify4json6detail19skip_any_whitespaceERNS0_14decode_contextE:
   59|  1.28M|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.28M|  skip_any_whitespace_scalar(context);
   66|  1.28M|}
_ZN7spotify4json6detail26skip_any_simple_charactersERNS0_14decode_contextE:
   38|   172k|json_force_inline void skip_any_simple_characters(decode_context &context) {
   39|   172k|#if defined(json_arch_x86_sse42)
   40|   172k|  if (json_likely(context.has_sse42)) {
  ------------------
  |  |   32|   172k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 172k, False: 0]
  |  |  ------------------
  ------------------
   41|   172k|    return skip_any_simple_characters_sse42(context);
   42|   172k|  }
   43|      0|#endif  // defined(json_arch_x86_sse42)
   44|      0|  return skip_any_simple_characters_scalar(context);
   45|   172k|}

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

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

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

_ZNK7spotify4json5codec8string_t6decodeERNS0_14decode_contextE:
  172|  17.9k|string_t::object_type string_t::decode(decode_context &context) const {
  173|  17.9k|  detail::skip_1(context, '"');
  174|  17.9k|  return decode_string(context);
  175|  17.9k|}
_ZNK7spotify4json5codec8string_t6encodeERNS0_14encode_contextENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  177|  2.28k|void string_t::encode(encode_context &context, const object_type value) const {
  178|  2.28k|  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.28k|  auto chunk_begin = value.data();
  187|  2.28k|  const auto string_end = chunk_begin + value.size();
  188|       |
  189|  4.56k|  while (chunk_begin != string_end) {
  ------------------
  |  Branch (189:10): [True: 2.28k, False: 2.28k]
  ------------------
  190|  2.28k|    const auto chunk_end = std::min(chunk_begin + 1024, string_end);
  191|  2.28k|    detail::write_escaped(context, chunk_begin, chunk_end);
  192|  2.28k|    chunk_begin = chunk_end;
  193|  2.28k|  }
  194|       |
  195|  2.28k|  context.append('"');
  196|  2.28k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113decode_stringERNS0_14decode_contextE:
  159|  17.8k|string_t::object_type decode_string(decode_context &context) {
  160|  17.8k|  const auto begin_simple = context.position;
  161|  17.8k|  detail::skip_any_simple_characters(context);
  162|       |
  163|  17.8k|  switch (detail::next(context, "Unterminated string")) {
  164|  7.76k|    case '"': return std::string(begin_simple, context.position - 1);
  ------------------
  |  Branch (164:5): [True: 7.76k, False: 10.1k]
  ------------------
  165|  10.0k|    case '\\': return decode_escaped_string(context, begin_simple);
  ------------------
  |  Branch (165:5): [True: 10.0k, False: 7.84k]
  ------------------
  166|      0|    default: json_unreachable();
  ------------------
  |  |   34|      0|  #define json_unreachable() __builtin_unreachable()
  ------------------
  |  Branch (166:5): [True: 0, False: 17.8k]
  ------------------
  167|  17.8k|  }
  168|  17.8k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_121decode_escaped_stringERNS0_14decode_contextEPKc:
  140|  10.0k|string_t::object_type decode_escaped_string(decode_context &context, const char *begin) {
  141|  10.0k|  std::string unescaped(begin, context.position - 1);
  142|  10.0k|  decode_escape(context, unescaped);
  143|       |
  144|  63.2k|  while (json_likely(context.remaining())) {
  ------------------
  |  |   32|  63.2k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 62.8k, False: 424]
  |  |  ------------------
  ------------------
  145|  62.8k|    const auto begin_simple = context.position;
  146|  62.8k|    detail::skip_any_simple_characters(context);
  147|  62.8k|    unescaped.append(begin_simple, context.position);
  148|       |
  149|  62.8k|    switch (detail::next(context, "Unterminated string")) {
  150|  9.35k|      case '"': return unescaped;
  ------------------
  |  Branch (150:7): [True: 9.35k, False: 53.5k]
  ------------------
  151|  53.3k|      case '\\': decode_escape(context, unescaped); break;
  ------------------
  |  Branch (151:7): [True: 53.3k, False: 9.53k]
  ------------------
  152|      0|      default: json_unreachable();
  ------------------
  |  |   34|      0|  #define json_unreachable() __builtin_unreachable()
  ------------------
  |  Branch (152:7): [True: 0, False: 62.8k]
  ------------------
  153|  62.8k|    }
  154|  62.8k|  }
  155|       |
  156|    424|  detail::fail(context, "Unterminated string");
  157|  10.0k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113decode_escapeERNS0_14decode_contextERNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  124|  63.3k|void decode_escape(decode_context &context, std::string &out) {
  125|  63.3k|  const auto escape_character = detail::next(context, "Unterminated string");
  126|  63.3k|  switch (escape_character) {
  127|  14.4k|    case '"':  out.push_back('"');  break;
  ------------------
  |  Branch (127:5): [True: 14.4k, False: 48.9k]
  ------------------
  128|  2.22k|    case '/':  out.push_back('/');  break;
  ------------------
  |  Branch (128:5): [True: 2.22k, False: 61.1k]
  ------------------
  129|  9.24k|    case 'b':  out.push_back('\b'); break;
  ------------------
  |  Branch (129:5): [True: 9.24k, False: 54.1k]
  ------------------
  130|    825|    case 'f':  out.push_back('\f'); break;
  ------------------
  |  Branch (130:5): [True: 825, False: 62.5k]
  ------------------
  131|  1.26k|    case 'n':  out.push_back('\n'); break;
  ------------------
  |  Branch (131:5): [True: 1.26k, False: 62.1k]
  ------------------
  132|  1.58k|    case 'r':  out.push_back('\r'); break;
  ------------------
  |  Branch (132:5): [True: 1.58k, False: 61.7k]
  ------------------
  133|  1.66k|    case 't':  out.push_back('\t'); break;
  ------------------
  |  Branch (133:5): [True: 1.66k, False: 61.7k]
  ------------------
  134|  12.8k|    case '\\': out.push_back('\\'); break;
  ------------------
  |  Branch (134:5): [True: 12.8k, False: 50.4k]
  ------------------
  135|  19.0k|    case 'u': decode_unicode_escape(context, out); break;
  ------------------
  |  Branch (135:5): [True: 19.0k, False: 44.2k]
  ------------------
  136|     41|    default: detail::fail(context, "Invalid escape character", -1);
  ------------------
  |  Branch (136:5): [True: 41, False: 63.3k]
  ------------------
  137|  63.3k|  }
  138|  63.3k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_121decode_unicode_escapeERNS0_14decode_contextERNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  117|  19.0k|void decode_unicode_escape(decode_context &context, std::string &out) {
  118|  19.0k|  const auto p = decode_hex_number(context);
  119|  19.0k|  if (json_likely(!handle_surrogate_pair(context, out, p))) {
  ------------------
  |  |   32|  19.0k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 18.3k, False: 740]
  |  |  ------------------
  ------------------
  120|  18.3k|    encode_utf8(out, p);
  121|  18.3k|  }
  122|  19.0k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_117decode_hex_numberERNS0_14decode_contextE:
   49|  22.1k|unsigned decode_hex_number(decode_context &context) {
   50|  22.1k|  detail::require_bytes<4>(context, "\\u must be followed by 4 hex digits");
   51|  22.1k|  const auto a = decode_hex_nibble(context, *(context.position++));
   52|  22.1k|  const auto b = decode_hex_nibble(context, *(context.position++));
   53|  22.1k|  const auto c = decode_hex_nibble(context, *(context.position++));
   54|  22.1k|  const auto d = decode_hex_nibble(context, *(context.position++));
   55|  22.1k|  return unsigned((a << 12) | (b << 8) | (c << 4) | d);
   56|  22.1k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_117decode_hex_nibbleERNS0_14decode_contextEc:
   42|  88.2k|uint8_t decode_hex_nibble(decode_context &context, const char c) {
   43|  88.2k|  if (c >= '0' && c <= '9') { return c - '0'; }
  ------------------
  |  Branch (43:7): [True: 88.1k, False: 62]
  |  Branch (43:19): [True: 35.6k, False: 52.5k]
  ------------------
   44|  52.6k|  if (c >= 'a' && c <= 'f') { return c - 'a' + 0xA; }
  ------------------
  |  Branch (44:7): [True: 13.7k, False: 38.8k]
  |  Branch (44:19): [True: 13.7k, False: 21]
  ------------------
   45|  38.8k|  if (c >= 'A' && c <= 'F') { return c - 'A' + 0xA; }
  ------------------
  |  Branch (45:7): [True: 38.7k, False: 75]
  |  Branch (45:19): [True: 38.7k, False: 53]
  ------------------
   46|    128|  detail::fail(context, "\\u must be followed by 4 hex digits");
   47|  38.8k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_121handle_surrogate_pairERNS0_14decode_contextERNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEj:
   97|  18.9k|bool handle_surrogate_pair(decode_context &context, std::string &out, unsigned p) {
   98|  18.9k|  if (json_unlikely(is_high_surrogate(p))) {
  ------------------
  |  |   33|  18.9k|  #define json_unlikely(expr) __builtin_expect(!!(expr), 0)
  |  |  ------------------
  |  |  |  Branch (33:31): [True: 6.94k, False: 12.0k]
  |  |  ------------------
  ------------------
   99|       |    // Parse low surrogate
  100|  6.94k|    if (detail::peek_2(context, '\\', 'u')) {
  ------------------
  |  Branch (100:9): [True: 3.02k, False: 3.91k]
  ------------------
  101|  3.02k|      detail::skip_unchecked_n(context, 2);
  102|  3.02k|      const auto n = decode_hex_number(context);
  103|  3.02k|      if (json_likely(is_low_surrogate(n))) {
  ------------------
  |  |   32|  3.02k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 597, False: 2.42k]
  |  |  ------------------
  ------------------
  104|       |        // Any Unicode codepoint encoded by a surrogate pair is 4 bytes in UTF-8
  105|    597|        encode_utf8_4(out, codepoint_from_surrogate_pair(p, n));
  106|    597|        return true;
  107|  2.42k|      } else {
  108|       |        // Rewind context to before the escape sequence
  109|  2.42k|        context.position -= 6;
  110|  2.42k|      }
  111|  3.02k|    }
  112|  6.94k|  }
  113|       |
  114|  18.3k|  return false;
  115|  18.9k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_117is_high_surrogateEj:
   30|  18.9k|bool is_high_surrogate(unsigned p) {
   31|  18.9k|  return (p & 0xFC00) == 0xD800;
   32|  18.9k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_116is_low_surrogateEj:
   34|  3.01k|bool is_low_surrogate(unsigned p) {
   35|  3.01k|  return (p & 0xFC00) == 0xDC00;
   36|  3.01k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113encode_utf8_4ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   58|    597|void encode_utf8_4(std::string &out, uint32_t p) {
   59|    597|  const char c0 = 0xF0 | ((p >> 18) & 0x07);
   60|    597|  const char c1 = 0x80 | ((p >> 12) & 0x3F);
   61|    597|  const char c2 = 0x80 | ((p >>  6) & 0x3F);
   62|    597|  const char c3 = 0x80 | ((p >>  0) & 0x3F);
   63|    597|  const char cc[] = { c0, c1, c2, c3 };
   64|    597|  out.append(&cc[0], 4);
   65|    597|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_129codepoint_from_surrogate_pairEjj:
   38|    597|uint32_t codepoint_from_surrogate_pair(uint32_t high, uint32_t low) {
   39|    597|  return (((high & 0x03FF) << 10) | (low & 0x03FF)) + 0x10000;
   40|    597|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_111encode_utf8ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   87|  18.3k|void encode_utf8(std::string &out, unsigned p) {
   88|  18.3k|  if (json_likely(p <= 0x7F)) {
  ------------------
  |  |   32|  18.3k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 991, False: 17.3k]
  |  |  ------------------
  ------------------
   89|    991|    encode_utf8_1(out, p);
   90|  17.3k|  } else if (json_likely(p <= 0x07FF)) {
  ------------------
  |  |   32|  17.3k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 4.59k, False: 12.7k]
  |  |  ------------------
  ------------------
   91|  4.59k|    encode_utf8_2(out, p);
   92|  12.7k|  } else {
   93|  12.7k|    encode_utf8_3(out, p);
   94|  12.7k|  }
   95|  18.3k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113encode_utf8_1ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   82|    991|void encode_utf8_1(std::string &out, unsigned p) {
   83|    991|  const char c0 = (p & 0x7F);
   84|    991|  out.push_back(c0);
   85|    991|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113encode_utf8_2ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   75|  4.59k|void encode_utf8_2(std::string &out, unsigned p) {
   76|  4.59k|  const char c0 = 0xC0 | ((p >> 6) & 0x1F);
   77|  4.59k|  const char c1 = 0x80 | ((p >> 0) & 0x3F);
   78|  4.59k|  const char cc[] = { c0, c1 };
   79|  4.59k|  out.append(&cc[0], 2);
   80|  4.59k|}
string.cpp:_ZN7spotify4json5codec12_GLOBAL__N_113encode_utf8_3ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEj:
   67|  12.7k|void encode_utf8_3(std::string &out, unsigned p) {
   68|  12.7k|  const char c0 = 0xE0 | ((p >> 12) & 0x0F);
   69|  12.7k|  const char c1 = 0x80 | ((p >>  6) & 0x3F);
   70|  12.7k|  const char c2 = 0x80 | ((p >>  0) & 0x3F);
   71|  12.7k|  const char cc[] = { c0, c1, c2 };
   72|  12.7k|  out.append(&cc[0], 3);
   73|  12.7k|}

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

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

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

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

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

_ZN7spotify4json6detail15write_escaped_1ERPcRPKc:
   86|  2.28k|json_force_inline void write_escaped_1(char *&out, const char *&begin) {
   87|  2.28k|  struct blob_1_t { char a; };
   88|  2.28k|  const auto b = *reinterpret_cast<const blob_1_t *>(begin);
   89|  2.28k|  write_escaped_c(out, b.a);
   90|  2.28k|  begin += sizeof(blob_1_t);
   91|  2.28k|}
_ZN7spotify4json6detail15write_escaped_cERPcc:
   32|  2.28k|json_force_inline void write_escaped_c(char *&out, const char c) {
   33|  2.28k|  static const char HEX[] = "0123456789ABCDEF";
   34|  2.28k|  static const char POPULAR_CONTROL_CHARACTERS[] = {
   35|  2.28k|    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
   36|  2.28k|    'b', 't', 'n', 'u', 'f', 'r', 'u', 'u',
   37|  2.28k|    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u',
   38|  2.28k|    'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u'
   39|  2.28k|  };
   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.28k|  if (json_likely(uint8_t(c) >= 0x30)) {
  ------------------
  |  |   32|  2.28k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 2.28k, False: 0]
  |  |  ------------------
  ------------------
   46|  2.28k|    if (json_likely(c != '\\')) {
  ------------------
  |  |   32|  2.28k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 2.28k, False: 0]
  |  |  ------------------
  ------------------
   47|  2.28k|      *(out++) = c;
   48|  2.28k|    } else {
   49|      0|      *(out++) = '\\';
   50|      0|      *(out++) = c;
   51|      0|    }
   52|  2.28k|    return;
   53|  2.28k|  }
   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.28k|    const char *end) {
   52|  2.28k|  const auto buf = context.reserve(6 * (end - begin));  // 6 is the length of \u00xx
   53|  2.28k|  auto out = buf;
   54|       |
   55|  2.28k|  const __m128i ranges = _mm_setr_epi8(
   56|  2.28k|    0x00, 0x1F,  // null byte & control characters
   57|  2.28k|    0x22, 0x22,  // double quotation mark
   58|  2.28k|    0x5C, 0x5C,  // reverse solidus (backslash)
   59|  2.28k|    0, 0, 0, 0, 0, 0, 0, 0, 0, 0
   60|  2.28k|  );
   61|       |
   62|  2.28k|  if (json_unaligned_2(begin) && (end - begin) >= 1) { write_escaped_1(out, begin); }
  ------------------
  |  |   64|  4.56k|#define json_unaligned_2(p)  (reinterpret_cast<intptr_t>(p) & 0x1)
  |  |  ------------------
  |  |  |  Branch (64:30): [True: 2.28k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (62:34): [True: 2.28k, False: 0]
  ------------------
   63|  2.28k|  if (json_unaligned_4(begin) && (end - begin) >= 2) { write_escaped_2(out, begin); }
  ------------------
  |  |   65|  4.56k|#define json_unaligned_4(p)  (reinterpret_cast<intptr_t>(p) & 0x3)
  |  |  ------------------
  |  |  |  Branch (65:30): [True: 2.28k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (63:34): [True: 0, False: 2.28k]
  ------------------
   64|  2.28k|  if (json_unaligned_8(begin) && (end - begin) >= 4) { write_escaped_4(out, begin); }
  ------------------
  |  |   66|  4.56k|#define json_unaligned_8(p)  (reinterpret_cast<intptr_t>(p) & 0x7)
  |  |  ------------------
  |  |  |  Branch (66:30): [True: 2.28k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (64:34): [True: 0, False: 2.28k]
  ------------------
   65|  2.28k|  if (json_unaligned_16(begin) && (end - begin) >= 8) { write_escaped_8(out, begin); }
  ------------------
  |  |   67|  4.56k|#define json_unaligned_16(p) (reinterpret_cast<intptr_t>(p) & 0xF)
  |  |  ------------------
  |  |  |  Branch (67:30): [True: 2.28k, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (65:35): [True: 0, False: 2.28k]
  ------------------
   66|       |
   67|  2.28k|  for (; end - begin >= 16; begin += 16) {
  ------------------
  |  Branch (67:10): [True: 0, False: 2.28k]
  ------------------
   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.28k|  if ((end - begin) >= 8) { write_escaped_8(out, begin); }
  ------------------
  |  Branch (78:7): [True: 0, False: 2.28k]
  ------------------
   79|  2.28k|  if ((end - begin) >= 4) { write_escaped_4(out, begin); }
  ------------------
  |  Branch (79:7): [True: 0, False: 2.28k]
  ------------------
   80|  2.28k|  if ((end - begin) >= 2) { write_escaped_2(out, begin); }
  ------------------
  |  Branch (80:7): [True: 0, False: 2.28k]
  ------------------
   81|  2.28k|  if ((end - begin) >= 1) { write_escaped_1(out, begin); }
  ------------------
  |  Branch (81:7): [True: 0, False: 2.28k]
  ------------------
   82|       |
   83|  2.28k|  context.advance(out - buf);
   84|  2.28k|}

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

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

_ZN7spotify4json6detail8is_spaceEc:
   33|  1.21M|json_force_inline bool is_space(const char c) {
   34|  1.21M|  return (c == ' ' || c == '\t' || c == '\n' || c == '\r');
  ------------------
  |  Branch (34:11): [True: 12.0k, False: 1.20M]
  |  Branch (34:23): [True: 669, False: 1.20M]
  |  Branch (34:36): [True: 583, False: 1.20M]
  |  Branch (34:49): [True: 413, False: 1.20M]
  ------------------
   35|  1.21M|}

_ZN7spotify4json6detail32skip_any_simple_characters_sse42ERNS0_14decode_contextE:
   29|   172k|void skip_any_simple_characters_sse42(decode_context &context) {
   30|   172k|  const auto end = context.end;
   31|   172k|  auto pos = context.position;
   32|       |
   33|   172k|  JSON_STRING_SKIP_N_SIMPLE(1,  2, uint8_t,  if, done_x)
  ------------------
  |  |   22|   172k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   64|   172k|#define json_unaligned_2(p)  (reinterpret_cast<intptr_t>(p) & 0x1)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (64:30): [True: 80.8k, False: 91.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 172k, False: 11]
  |  |  ------------------
  |  |   23|  80.8k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  80.8k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   59|  80.8k|#define json_haschar_1(v, c) (v == c)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:30): [True: 10.6k, False: 70.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  80.8k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   59|  70.2k|#define json_haschar_1(v, c) (v == c)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:30): [True: 19.9k, False: 50.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  70.2k|    pos += n; \
  |  |   27|  50.2k|  }
  ------------------
   34|   142k|  JSON_STRING_SKIP_N_SIMPLE(2,  4, uint16_t, if, done_2)
  ------------------
  |  |   22|   142k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   65|   141k|#define json_unaligned_4(p)  (reinterpret_cast<intptr_t>(p) & 0x3)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (65:30): [True: 71.7k, False: 70.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 141k, False: 215]
  |  |  ------------------
  |  |   23|  71.7k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  71.7k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   60|  71.7k|#define json_haschar_2(v, c) uint16_t(json_haszero_2((v) ^ (~0U/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  71.7k|#define json_haszero_2(v) uint16_t(((v) - 0x0101U) & ~(v) & 0x8080U)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:30): [True: 13.0k, False: 58.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  71.7k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   60|  58.6k|#define json_haschar_2(v, c) uint16_t(json_haszero_2((v) ^ (~0U/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  58.6k|#define json_haszero_2(v) uint16_t(((v) - 0x0101U) & ~(v) & 0x8080U)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:30): [True: 17.0k, False: 41.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  58.6k|    pos += n; \
  |  |   27|  41.6k|  }
  ------------------
   35|   112k|  JSON_STRING_SKIP_N_SIMPLE(4,  8, uint32_t, if, done_4)
  ------------------
  |  |   22|   112k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   66|   111k|#define json_unaligned_8(p)  (reinterpret_cast<intptr_t>(p) & 0x7)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (66:30): [True: 56.4k, False: 55.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 111k, False: 420]
  |  |  ------------------
  |  |   23|  56.4k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  56.4k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   61|  56.4k|#define json_haschar_4(v, c) uint32_t(json_haszero_4((v) ^ (~0UL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  56.4k|#define json_haszero_4(v) uint32_t(((v) - 0x01010101UL) & ~(v) & 0x80808080UL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:30): [True: 9.38k, False: 47.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  56.4k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   61|  47.0k|#define json_haschar_4(v, c) uint32_t(json_haszero_4((v) ^ (~0UL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  47.0k|#define json_haszero_4(v) uint32_t(((v) - 0x01010101UL) & ~(v) & 0x80808080UL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:30): [True: 13.2k, False: 33.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  47.0k|    pos += n; \
  |  |   27|  33.8k|  }
  ------------------
   36|  89.4k|  JSON_STRING_SKIP_N_SIMPLE(8, 16, uint64_t, if, done_8)
  ------------------
  |  |   22|  89.4k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   67|  88.8k|#define json_unaligned_16(p) (reinterpret_cast<intptr_t>(p) & 0xF)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (67:30): [True: 44.7k, False: 44.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 88.8k, False: 592]
  |  |  ------------------
  |  |   23|  44.7k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  44.7k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   62|  44.7k|#define json_haschar_8(v, c) uint64_t(json_haszero_8((v) ^ (~0ULL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   58|  44.7k|#define json_haszero_8(v) uint64_t(((v) - 0x0101010101010101ULL) & ~(v) & 0x8080808080808080ULL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (62:30): [True: 8.27k, False: 36.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  44.7k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   62|  36.4k|#define json_haschar_8(v, c) uint64_t(json_haszero_8((v) ^ (~0ULL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   58|  36.4k|#define json_haszero_8(v) uint64_t(((v) - 0x0101010101010101ULL) & ~(v) & 0x8080808080808080ULL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (62:30): [True: 12.5k, False: 23.9k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  36.4k|    pos += n; \
  |  |   27|  23.9k|  }
  ------------------
   37|       |
   38|  68.6k|  {
   39|  68.6k|    alignas(16) static const char CHARS[16] = "\"\\";
   40|  68.6k|    const auto chars = _mm_load_si128(reinterpret_cast<const __m128i *>(&CHARS[0]));
   41|       |
   42|  2.23M|    for (; end - pos >= 16; pos += 16) {
  ------------------
  |  Branch (42:12): [True: 2.23M, False: 981]
  ------------------
   43|  2.23M|      const auto chunk = _mm_load_si128(reinterpret_cast<const __m128i *>(pos));
   44|  2.23M|      constexpr auto flags = _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_POSITIVE_POLARITY | _SIDD_LEAST_SIGNIFICANT;
   45|  2.23M|      const auto index = _mm_cmpestri(chars, 2, chunk, 16, flags);
   46|  2.23M|      if (index != 16) {
  ------------------
  |  Branch (46:11): [True: 67.6k, False: 2.16M]
  ------------------
   47|  67.6k|        context.position = pos + index;
   48|  67.6k|        return;
   49|  67.6k|      }
   50|  2.23M|    }
   51|  68.6k|  }
   52|       |
   53|    981|          JSON_STRING_SKIP_N_SIMPLE(8, x, uint64_t, while, done_8)
  ------------------
  |  |   22|  1.09k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   19|    298|#define json_unaligned_x(ignore) true
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (19:34): [True: 298, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 298, False: 801]
  |  |  ------------------
  |  |   23|    298|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|    298|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   62|    298|#define json_haschar_8(v, c) uint64_t(json_haszero_8((v) ^ (~0ULL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   58|    298|#define json_haszero_8(v) uint64_t(((v) - 0x0101010101010101ULL) & ~(v) & 0x8080808080808080ULL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (62:30): [True: 93, False: 205]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|    298|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   62|    205|#define json_haschar_8(v, c) uint64_t(json_haszero_8((v) ^ (~0ULL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   58|    205|#define json_haszero_8(v) uint64_t(((v) - 0x0101010101010101ULL) & ~(v) & 0x8080808080808080ULL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (62:30): [True: 87, False: 118]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|    205|    pos += n; \
  |  |   27|    118|  }
  ------------------
   54|  21.7k|  done_8: JSON_STRING_SKIP_N_SIMPLE(4, x, uint32_t, while, done_4)
  ------------------
  |  |   22|  27.8k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   19|  27.2k|#define json_unaligned_x(ignore) true
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (19:34): [True: 27.2k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 27.2k, False: 648]
  |  |  ------------------
  |  |   23|  27.2k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  27.2k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   61|  27.2k|#define json_haschar_4(v, c) uint32_t(json_haszero_4((v) ^ (~0UL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  27.2k|#define json_haszero_4(v) uint32_t(((v) - 0x01010101UL) & ~(v) & 0x80808080UL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:30): [True: 7.59k, False: 19.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  27.2k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   61|  19.6k|#define json_haschar_4(v, c) uint32_t(json_haszero_4((v) ^ (~0UL/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  19.6k|#define json_haszero_4(v) uint32_t(((v) - 0x01010101UL) & ~(v) & 0x80808080UL)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (61:30): [True: 13.5k, False: 6.08k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  19.6k|    pos += n; \
  |  |   27|  6.08k|  }
  ------------------
   55|  44.3k|  done_4: JSON_STRING_SKIP_N_SIMPLE(2, x, uint16_t, while, done_2)
  ------------------
  |  |   22|  56.6k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   19|  56.2k|#define json_unaligned_x(ignore) true
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (19:34): [True: 56.2k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 56.2k, False: 423]
  |  |  ------------------
  |  |   23|  56.2k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  56.2k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   60|  56.2k|#define json_haschar_2(v, c) uint16_t(json_haszero_2((v) ^ (~0U/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  56.2k|#define json_haszero_2(v) uint16_t(((v) - 0x0101U) & ~(v) & 0x8080U)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:30): [True: 14.4k, False: 41.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  56.2k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   60|  41.8k|#define json_haschar_2(v, c) uint16_t(json_haszero_2((v) ^ (~0U/255 * (c))))
  |  |  |  |  ------------------
  |  |  |  |  |  |   56|  41.8k|#define json_haszero_2(v) uint16_t(((v) - 0x0101U) & ~(v) & 0x8080U)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (60:30): [True: 29.5k, False: 12.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  41.8k|    pos += n; \
  |  |   27|  12.3k|  }
  ------------------
   56|  74.4k|  done_2: JSON_STRING_SKIP_N_SIMPLE(1, x, uint8_t,  while, done_x)
  ------------------
  |  |   22|  94.6k|  control ((end - pos) >= n && json_unaligned_ ## n_plus_one(pos)) { \
  |  |  ------------------
  |  |  |  |   19|  94.3k|#define json_unaligned_x(ignore) true
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (19:34): [True: 94.3k, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (22:12): [True: 94.3k, False: 298]
  |  |  ------------------
  |  |   23|  94.3k|    const auto cc = *reinterpret_cast<const type *>(pos); \
  |  |   24|  94.3k|    if (json_haschar_ ## n(cc, '"')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   59|  94.3k|#define json_haschar_1(v, c) (v == c)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:30): [True: 17.1k, False: 77.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   25|  94.3k|    if (json_haschar_ ## n(cc, '\\')) { goto goto_label; } \
  |  |  ------------------
  |  |  |  |   59|  77.2k|#define json_haschar_1(v, c) (v == c)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (59:30): [True: 57.0k, False: 20.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   26|  77.2k|    pos += n; \
  |  |   27|  20.1k|  }
  ------------------
   57|   105k|  done_x: context.position = pos;
   58|   105k|}
_ZN7spotify4json6detail25skip_any_whitespace_sse42ERNS0_14decode_contextE:
   60|  1.27M|void skip_any_whitespace_sse42(decode_context &context) {
   61|  1.27M|  const auto end = context.end;
   62|  1.27M|  auto pos = context.position;
   63|       |
   64|  1.29M|  for (; pos < end && json_unaligned_16(pos); ++pos) {
  ------------------
  |  |   67|  1.29M|#define json_unaligned_16(p) (reinterpret_cast<intptr_t>(p) & 0xF)
  |  |  ------------------
  |  |  |  Branch (67:30): [True: 1.21M, False: 81.3k]
  |  |  ------------------
  ------------------
  |  Branch (64:10): [True: 1.29M, False: 377]
  ------------------
   65|  1.21M|    if (!is_space(*pos)) {
  ------------------
  |  Branch (65:9): [True: 1.19M, False: 12.5k]
  ------------------
   66|  1.19M|      context.position = pos;
   67|  1.19M|      return;
   68|  1.19M|    }
   69|  1.21M|  }
   70|       |
   71|  81.7k|  alignas(16) static const char CHARS[16] = " \t\n\r";
   72|  81.7k|  const auto chars = _mm_load_si128(reinterpret_cast<const __m128i *>(&CHARS[0]));
   73|       |
   74|  87.2k|  for (; end - pos >= 16; pos += 16) {
  ------------------
  |  Branch (74:10): [True: 86.5k, False: 766]
  ------------------
   75|  86.5k|    const auto chunk = _mm_load_si128(reinterpret_cast<const __m128i *>(pos));
   76|  86.5k|    constexpr auto flags = _SIDD_UBYTE_OPS | _SIDD_CMP_EQUAL_ANY | _SIDD_NEGATIVE_POLARITY | _SIDD_LEAST_SIGNIFICANT;
   77|  86.5k|    const auto index = _mm_cmpestri(chars, 4, chunk, 16, flags);
   78|  86.5k|    if (index != 16) {
  ------------------
  |  Branch (78:9): [True: 80.9k, False: 5.54k]
  ------------------
   79|  80.9k|      context.position = pos + index;
   80|  80.9k|      return;
   81|  80.9k|    }
   82|  86.5k|  }
   83|       |
   84|    943|  while (pos < end && is_space(*pos)) {
  ------------------
  |  Branch (84:10): [True: 543, False: 400]
  |  Branch (84:23): [True: 177, False: 366]
  ------------------
   85|    177|    ++pos;
   86|    177|  }
   87|       |
   88|    766|  context.position = pos;
   89|    766|}

_ZN7spotify4json6detail10skip_valueERNS0_14decode_contextE:
  135|  14.1k|void skip_value(decode_context &context) {
  136|  14.1k|  enum state {
  137|  14.1k|    done = 0,
  138|  14.1k|    want = 1 << 0,
  139|  14.1k|    need = 1 << 1,
  140|  14.1k|    read_sep = 1 << 2,
  141|  14.1k|    read_key = 1 << 3,
  142|  14.1k|    read_val = 1 << 4,
  143|       |
  144|  14.1k|    want_sep = want | read_sep,
  145|  14.1k|    want_key = want | read_key,
  146|  14.1k|    need_key = need | read_key,
  147|  14.1k|    want_val = want | read_val,
  148|  14.1k|    need_val = need | read_val
  149|  14.1k|  };
  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.1k|  detail::stack<char, 64> stack;
  156|       |
  157|  14.1k|  auto inside = 0;
  158|  14.1k|  auto closer = int_fast16_t(std::numeric_limits<int16_t>::max());  // a value outside the range of a 'char'
  159|  14.1k|  auto pstate = need_val;
  160|       |
  161|  1.22M|  while (json_likely(context.remaining() && pstate != done)) {
  ------------------
  |  |   32|  2.45M|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 1.21M, False: 14.1k]
  |  |  |  Branch (32:49): [True: 1.22M, False: 1.06k]
  |  |  |  Branch (32:49): [True: 1.21M, False: 13.0k]
  |  |  ------------------
  ------------------
  162|  1.21M|    if (json_likely(inside)) {
  ------------------
  |  |   32|  1.21M|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 1.19M, False: 14.0k]
  |  |  ------------------
  ------------------
  163|  1.19M|      skip_any_whitespace(context);
  164|  1.19M|    }
  165|       |
  166|  1.21M|    const auto c = peek_unchecked(context);
  167|       |
  168|  1.21M|    if (c == ',' && (pstate & read_sep)) {
  ------------------
  |  Branch (168:9): [True: 19.8k, False: 1.19M]
  |  Branch (168:21): [True: 19.8k, False: 2]
  ------------------
  169|  19.8k|      skip_unchecked_1(context);
  170|  19.8k|      pstate = (inside == '{' ? need_key : need_val);
  ------------------
  |  Branch (170:17): [True: 15.2k, False: 4.63k]
  ------------------
  171|  19.8k|      continue;
  172|  19.8k|    }
  173|       |
  174|  1.19M|    if (c == '"' && (pstate & read_key)) {
  ------------------
  |  Branch (174:9): [True: 19.9k, False: 1.17M]
  |  Branch (174:21): [True: 18.2k, False: 1.64k]
  ------------------
  175|  18.2k|      skip_string(context);
  176|  18.2k|      skip_any_whitespace(context);
  177|  18.2k|      skip_1(context, ':');
  178|  18.2k|      pstate = need_val;
  179|  18.2k|      continue;
  180|  18.2k|    }
  181|       |
  182|  1.17M|    if (c == closer && !(pstate & need)) {
  ------------------
  |  Branch (182:9): [True: 44.9k, False: 1.12M]
  |  Branch (182:24): [True: 44.9k, False: 2]
  ------------------
  183|  44.9k|      skip_unchecked_1(context);
  184|  44.9k|      inside = stack.pop();
  185|  44.9k|      closer = inside + 2;  // '{' + 2 == '}', '[' + 2 == ']'
  186|  44.9k|      pstate = (inside ? want_sep : done);
  ------------------
  |  Branch (186:17): [True: 44.3k, False: 605]
  ------------------
  187|  44.9k|      continue;
  188|  44.9k|    }
  189|       |
  190|  1.12M|    fail_if(context, pstate & read_key, "Expected '\"'");
  191|  1.12M|    fail_if(context, pstate & read_sep, inside == '{' ?
  ------------------
  |  Branch (191:41): [True: 18.1k, False: 1.11M]
  ------------------
  192|  18.1k|        "Expected ',' or '}'" :
  193|  1.12M|        "Expected ',' or ']");
  194|       |
  195|  1.12M|    if (c == '{' || c == '[') {
  ------------------
  |  Branch (195:9): [True: 3.33k, False: 1.12M]
  |  Branch (195:21): [True: 1.09M, False: 32.8k]
  ------------------
  196|  1.09M|      skip_unchecked_1(context);
  197|  1.09M|      stack.push(inside);
  198|  1.09M|      inside = c;
  199|  1.09M|      closer = inside + 2;  // '{' + 2 == '}', '[' + 2 == ']'
  200|  1.09M|      pstate = (inside == '{' ? want_key : want_val);
  ------------------
  |  Branch (200:17): [True: 3.30k, False: 1.09M]
  ------------------
  201|  1.09M|      continue;
  202|  1.09M|    }
  203|       |
  204|  32.8k|    skip_simple_value(context);
  205|  32.8k|    pstate = (inside ? want_sep : done);
  ------------------
  |  Branch (205:15): [True: 19.7k, False: 13.1k]
  ------------------
  206|  32.8k|  }
  207|       |
  208|  14.1k|  fail_if(context, inside == '{', "Expected '}'");
  209|  14.1k|  fail_if(context, inside == '[', "Expected ']'");
  210|  14.1k|  fail_if(context, pstate != done, "Unexpected EOF");
  211|  14.1k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_111skip_stringERNS0_14decode_contextE:
   62|  19.9k|void skip_string(decode_context &context) {
   63|  19.9k|  skip_1(context, '"');
   64|       |
   65|  92.0k|  while (json_likely(context.remaining())) {
  ------------------
  |  |   32|  92.0k|  #define json_likely(expr) __builtin_expect(!!(expr), 1)
  |  |  ------------------
  |  |  |  Branch (32:29): [True: 91.9k, False: 115]
  |  |  ------------------
  ------------------
   66|  91.9k|    detail::skip_any_simple_characters(context);
   67|  91.9k|    switch (next(context, "Unterminated string")) {
   68|  19.6k|      case '"': return;
  ------------------
  |  Branch (68:7): [True: 19.6k, False: 72.3k]
  ------------------
   69|  72.2k|      case '\\': skip_escape(context); break;
  ------------------
  |  Branch (69:7): [True: 72.2k, False: 19.6k]
  ------------------
   70|      0|      default: json_unreachable();
  ------------------
  |  |   34|      0|  #define json_unreachable() __builtin_unreachable()
  ------------------
  |  Branch (70:7): [True: 0, False: 91.9k]
  ------------------
   71|  91.9k|    }
   72|  91.9k|  }
   73|       |
   74|    115|  detail::fail(context, "Unterminated string");
   75|  19.9k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_111skip_escapeERNS0_14decode_contextE:
   47|  72.2k|void skip_escape(decode_context &context) {
   48|  72.2k|  switch (next(context, "Unterminated string")) {
   49|  14.4k|    case '"':  break;
  ------------------
  |  Branch (49:5): [True: 14.4k, False: 57.8k]
  ------------------
   50|    985|    case '/':  break;
  ------------------
  |  Branch (50:5): [True: 985, False: 71.3k]
  ------------------
   51|  1.70k|    case 'b':  break;
  ------------------
  |  Branch (51:5): [True: 1.70k, False: 70.5k]
  ------------------
   52|  1.81k|    case 'f':  break;
  ------------------
  |  Branch (52:5): [True: 1.81k, False: 70.4k]
  ------------------
   53|  6.57k|    case 'n':  break;
  ------------------
  |  Branch (53:5): [True: 6.57k, False: 65.7k]
  ------------------
   54|  3.88k|    case 'r':  break;
  ------------------
  |  Branch (54:5): [True: 3.88k, False: 68.4k]
  ------------------
   55|  2.47k|    case 't':  break;
  ------------------
  |  Branch (55:5): [True: 2.47k, False: 69.8k]
  ------------------
   56|  9.83k|    case '\\': break;
  ------------------
  |  Branch (56:5): [True: 9.83k, False: 62.4k]
  ------------------
   57|  30.5k|    case 'u': skip_unicode_escape(context); break;
  ------------------
  |  Branch (57:5): [True: 30.5k, False: 41.7k]
  ------------------
   58|     10|    default: detail::fail(context, "Invalid escape character", -1);
  ------------------
  |  Branch (58:5): [True: 10, False: 72.2k]
  ------------------
   59|  72.2k|  }
   60|  72.2k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_119skip_unicode_escapeERNS0_14decode_contextE:
   38|  30.5k|void skip_unicode_escape(decode_context &context) {
   39|  30.5k|  require_bytes<4>(context, "\\u must be followed by 4 hex digits");
   40|  30.5k|  const bool h0 = is_hex_digit(*(context.position++));
   41|  30.5k|  const bool h1 = is_hex_digit(*(context.position++));
   42|  30.5k|  const bool h2 = is_hex_digit(*(context.position++));
   43|  30.5k|  const bool h3 = is_hex_digit(*(context.position++));
   44|  30.5k|  fail_if(context, !(h0 && h1 && h2 && h3), "\\u must be followed by 4 hex digits");
  ------------------
  |  Branch (44:22): [True: 30.5k, False: 55]
  |  Branch (44:28): [True: 30.4k, False: 40]
  |  Branch (44:34): [True: 30.4k, False: 20]
  |  Branch (44:40): [True: 30.4k, False: 19]
  ------------------
   45|  30.5k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_112is_hex_digitEc:
   34|   122k|json_force_inline bool is_hex_digit(const char c) {
   35|   122k|  return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
  ------------------
  |  Branch (35:11): [True: 122k, False: 149]
  |  Branch (35:23): [True: 49.6k, False: 72.4k]
  |  Branch (35:37): [True: 18.0k, False: 54.5k]
  |  Branch (35:49): [True: 18.0k, False: 51]
  |  Branch (35:63): [True: 54.4k, False: 185]
  |  Branch (35:75): [True: 54.3k, False: 113]
  ------------------
   36|   122k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_117skip_simple_valueERNS0_14decode_contextE:
  120|  32.8k|void skip_simple_value(decode_context &context) {
  121|  32.8k|  switch (peek(context)) {
  122|  2.72k|    case '-':  // fallthrough
  ------------------
  |  Branch (122:5): [True: 2.72k, False: 30.1k]
  ------------------
  123|  16.0k|    case '0': case '1': case '2': case '3': case '4':  // fallthrough
  ------------------
  |  Branch (123:5): [True: 2.18k, False: 30.6k]
  |  Branch (123:15): [True: 4.91k, False: 27.9k]
  |  Branch (123:25): [True: 3.16k, False: 29.6k]
  |  Branch (123:35): [True: 1.14k, False: 31.6k]
  |  Branch (123:45): [True: 1.93k, False: 30.8k]
  ------------------
  124|  27.0k|    case '5': case '6': case '7': case '8': case '9': skip_number(context); break;
  ------------------
  |  Branch (124:5): [True: 1.77k, False: 31.0k]
  |  Branch (124:15): [True: 1.47k, False: 31.3k]
  |  Branch (124:25): [True: 3.93k, False: 28.8k]
  |  Branch (124:35): [True: 2.35k, False: 30.4k]
  |  Branch (124:45): [True: 1.42k, False: 31.4k]
  ------------------
  125|  1.63k|    case '"': skip_string(context); break;
  ------------------
  |  Branch (125:5): [True: 1.63k, False: 31.1k]
  ------------------
  126|    809|    case 'f': skip_false(context); break;
  ------------------
  |  Branch (126:5): [True: 809, False: 32.0k]
  ------------------
  127|  2.04k|    case 't': skip_true(context); break;
  ------------------
  |  Branch (127:5): [True: 2.04k, False: 30.7k]
  ------------------
  128|  1.24k|    case 'n': skip_null(context); break;
  ------------------
  |  Branch (128:5): [True: 1.24k, False: 31.5k]
  ------------------
  129|     68|    default: fail(context, (std::string("Encountered token '") + peek(context) + "'").c_str());
  ------------------
  |  Branch (129:5): [True: 68, False: 32.7k]
  ------------------
  130|  32.8k|  }
  131|  32.8k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_111skip_numberERNS0_14decode_contextE:
   77|  27.0k|void skip_number(decode_context &context) {
   78|       |  // Parse negative sign
   79|  27.0k|  if (peek(context) == '-') {
  ------------------
  |  Branch (79:7): [True: 2.72k, False: 24.3k]
  ------------------
   80|  2.72k|    ++context.position;
   81|  2.72k|  }
   82|       |
   83|       |  // Parse integer part
   84|  27.0k|  if (peek(context) == '0') {
  ------------------
  |  Branch (84:7): [True: 2.18k, False: 24.8k]
  ------------------
   85|  2.18k|    ++context.position;
   86|  24.8k|  } else {
   87|  24.8k|    fail_if(context, !is_digit(peek(context)), "Expected digit");
   88|  34.7k|    do { ++context.position; } while (is_digit(peek(context)));
  ------------------
  |  Branch (88:39): [True: 9.95k, False: 24.8k]
  ------------------
   89|  24.8k|  }
   90|       |
   91|       |  // Parse fractional part
   92|  27.0k|  if (peek(context) == '.') {
  ------------------
  |  Branch (92:7): [True: 893, False: 26.1k]
  ------------------
   93|    893|    ++context.position;
   94|    893|    fail_if(context, !is_digit(peek(context)), "Expected digit after decimal point");
   95|  1.12k|    do { ++context.position; } while (is_digit(peek(context)));
  ------------------
  |  Branch (95:39): [True: 235, False: 893]
  ------------------
   96|    893|  }
   97|       |
   98|       |  // Parse exp part
   99|  27.0k|  const char maybe_e = peek(context);
  100|  27.0k|  if (maybe_e == 'e' || maybe_e == 'E') {
  ------------------
  |  Branch (100:7): [True: 1.13k, False: 25.8k]
  |  Branch (100:25): [True: 506, False: 25.3k]
  ------------------
  101|  1.59k|    ++context.position;
  102|  1.59k|    const char maybe_plus_minus = peek(context);
  103|  1.59k|    if (maybe_plus_minus == '+' || maybe_plus_minus == '-') {
  ------------------
  |  Branch (103:9): [True: 658, False: 939]
  |  Branch (103:36): [True: 250, False: 689]
  ------------------
  104|    908|      ++context.position;
  105|    908|    }
  106|       |
  107|  1.59k|    fail_if(context, !is_digit(peek(context)), "Expected digit after exponent sign");
  108|  2.54k|    do { ++context.position; } while (is_digit(peek(context)));
  ------------------
  |  Branch (108:39): [True: 950, False: 1.59k]
  ------------------
  109|  1.59k|  }
  110|  27.0k|}
skip_value.cpp:_ZN7spotify4json6detail12_GLOBAL__N_18is_digitEc:
   30|  65.7k|json_force_inline bool is_digit(const char c) {
   31|  65.7k|  return (c >= '0' && c <= '9');
  ------------------
  |  Branch (31:11): [True: 39.9k, False: 25.7k]
  |  Branch (31:23): [True: 38.3k, False: 1.53k]
  ------------------
   32|  65.7k|}

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