cJSON_Delete:
  254|   300k|{
  255|   300k|    cJSON *next = NULL;
  256|  1.03M|    while (item != NULL)
  ------------------
  |  Branch (256:12): [True: 734k, False: 300k]
  ------------------
  257|   734k|    {
  258|   734k|        next = item->next;
  259|   734k|        if (!(item->type & cJSON_IsReference) && (item->child != NULL))
  ------------------
  |  |   99|   734k|#define cJSON_IsReference 256
  ------------------
  |  Branch (259:13): [True: 734k, False: 0]
  |  Branch (259:50): [True: 246k, False: 487k]
  ------------------
  260|   246k|        {
  261|   246k|            cJSON_Delete(item->child);
  262|   246k|        }
  263|   734k|        if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL))
  ------------------
  |  |   99|   734k|#define cJSON_IsReference 256
  ------------------
  |  Branch (263:13): [True: 734k, False: 0]
  |  Branch (263:50): [True: 7.84k, False: 726k]
  ------------------
  264|  7.84k|        {
  265|  7.84k|            global_hooks.deallocate(item->valuestring);
  266|  7.84k|            item->valuestring = NULL;
  267|  7.84k|        }
  268|   734k|        if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
  ------------------
  |  |  100|   734k|#define cJSON_StringIsConst 512
  ------------------
  |  Branch (268:13): [True: 734k, False: 0]
  |  Branch (268:52): [True: 25.8k, False: 708k]
  ------------------
  269|  25.8k|        {
  270|  25.8k|            global_hooks.deallocate(item->string);
  271|       |            item->string = NULL;
  272|  25.8k|        }
  273|   734k|        global_hooks.deallocate(item);
  274|   734k|        item = next;
  275|   734k|    }
  276|   300k|}
cJSON_ParseWithOpts:
 1132|  2.01k|{
 1133|  2.01k|    size_t buffer_length;
 1134|       |
 1135|  2.01k|    if (NULL == value)
  ------------------
  |  Branch (1135:9): [True: 0, False: 2.01k]
  ------------------
 1136|      0|    {
 1137|      0|        return NULL;
 1138|      0|    }
 1139|       |
 1140|       |    /* Adding null character size due to require_null_terminated. */
 1141|  2.01k|    buffer_length = strlen(value) + sizeof("");
 1142|       |
 1143|  2.01k|    return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated);
 1144|  2.01k|}
cJSON_ParseWithLengthOpts:
 1148|  2.01k|{
 1149|  2.01k|    parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } };
 1150|  2.01k|    cJSON *item = NULL;
 1151|       |
 1152|       |    /* reset error position */
 1153|  2.01k|    global_error.json = NULL;
 1154|  2.01k|    global_error.position = 0;
 1155|       |
 1156|  2.01k|    if (value == NULL || 0 == buffer_length)
  ------------------
  |  Branch (1156:9): [True: 0, False: 2.01k]
  |  Branch (1156:26): [True: 0, False: 2.01k]
  ------------------
 1157|      0|    {
 1158|      0|        goto fail;
 1159|      0|    }
 1160|       |
 1161|  2.01k|    buffer.content = (const unsigned char*)value;
 1162|  2.01k|    buffer.length = buffer_length;
 1163|  2.01k|    buffer.offset = 0;
 1164|  2.01k|    buffer.hooks = global_hooks;
 1165|       |
 1166|  2.01k|    item = cJSON_New_Item(&global_hooks);
 1167|  2.01k|    if (item == NULL) /* memory fail */
  ------------------
  |  Branch (1167:9): [True: 0, False: 2.01k]
  ------------------
 1168|      0|    {
 1169|      0|        goto fail;
 1170|      0|    }
 1171|       |
 1172|  2.01k|    if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer))))
  ------------------
  |  Branch (1172:9): [True: 871, False: 1.14k]
  ------------------
 1173|    871|    {
 1174|       |        /* parse failure. ep is set. */
 1175|    871|        goto fail;
 1176|    871|    }
 1177|       |
 1178|       |    /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */
 1179|  1.14k|    if (require_null_terminated)
  ------------------
  |  Branch (1179:9): [True: 372, False: 770]
  ------------------
 1180|    372|    {
 1181|    372|        buffer_skip_whitespace(&buffer);
 1182|    372|        if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0')
  ------------------
  |  |  304|    372|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1182:13): [True: 0, False: 372]
  |  Branch (1182:49): [True: 47, False: 325]
  ------------------
 1183|     47|        {
 1184|     47|            goto fail;
 1185|     47|        }
 1186|    372|    }
 1187|  1.09k|    if (return_parse_end)
  ------------------
  |  Branch (1187:9): [True: 0, False: 1.09k]
  ------------------
 1188|      0|    {
 1189|      0|        *return_parse_end = (const char*)buffer_at_offset(&buffer);
  ------------------
  |  |  304|      0|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
 1190|      0|    }
 1191|       |
 1192|  1.09k|    return item;
 1193|       |
 1194|    918|fail:
 1195|    918|    if (item != NULL)
  ------------------
  |  Branch (1195:9): [True: 918, False: 0]
  ------------------
 1196|    918|    {
 1197|    918|        cJSON_Delete(item);
 1198|    918|    }
 1199|       |
 1200|    918|    if (value != NULL)
  ------------------
  |  Branch (1200:9): [True: 918, False: 0]
  ------------------
 1201|    918|    {
 1202|    918|        error local_error;
 1203|    918|        local_error.json = (const unsigned char*)value;
 1204|    918|        local_error.position = 0;
 1205|       |
 1206|    918|        if (buffer.offset < buffer.length)
  ------------------
  |  Branch (1206:13): [True: 809, False: 109]
  ------------------
 1207|    809|        {
 1208|    809|            local_error.position = buffer.offset;
 1209|    809|        }
 1210|    109|        else if (buffer.length > 0)
  ------------------
  |  Branch (1210:18): [True: 109, False: 0]
  ------------------
 1211|    109|        {
 1212|    109|            local_error.position = buffer.length - 1;
 1213|    109|        }
 1214|       |
 1215|    918|        if (return_parse_end != NULL)
  ------------------
  |  Branch (1215:13): [True: 0, False: 918]
  ------------------
 1216|      0|        {
 1217|      0|            *return_parse_end = (const char*)local_error.json + local_error.position;
 1218|      0|        }
 1219|       |
 1220|    918|        global_error = local_error;
 1221|    918|    }
 1222|       |
 1223|       |    return NULL;
 1224|  1.14k|}
cJSON_Print:
 1308|    248|{
 1309|    248|    return (char*)print(item, true, &global_hooks);
  ------------------
  |  |   65|    248|#define true ((cJSON_bool)1)
  ------------------
 1310|    248|}
cJSON_PrintUnformatted:
 1313|    272|{
 1314|    272|    return (char*)print(item, false, &global_hooks);
  ------------------
  |  |   70|    272|#define false ((cJSON_bool)0)
  ------------------
 1315|    272|}
cJSON_PrintBuffered:
 1318|    575|{
 1319|    575|    printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } };
 1320|       |
 1321|    575|    if (prebuffer < 0)
  ------------------
  |  Branch (1321:9): [True: 0, False: 575]
  ------------------
 1322|      0|    {
 1323|      0|        return NULL;
 1324|      0|    }
 1325|       |
 1326|    575|    p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer);
 1327|    575|    if (!p.buffer)
  ------------------
  |  Branch (1327:9): [True: 0, False: 575]
  ------------------
 1328|      0|    {
 1329|      0|        return NULL;
 1330|      0|    }
 1331|       |
 1332|    575|    p.length = (size_t)prebuffer;
 1333|    575|    p.offset = 0;
 1334|    575|    p.noalloc = false;
  ------------------
  |  |   70|    575|#define false ((cJSON_bool)0)
  ------------------
 1335|    575|    p.format = fmt;
 1336|    575|    p.hooks = global_hooks;
 1337|       |
 1338|    575|    if (!print_value(item, &p))
  ------------------
  |  Branch (1338:9): [True: 0, False: 575]
  ------------------
 1339|      0|    {
 1340|      0|        global_hooks.deallocate(p.buffer);
 1341|      0|        p.buffer = NULL;
 1342|      0|        return NULL;
 1343|      0|    }
 1344|       |
 1345|    575|    return (char*)p.buffer;
 1346|    575|}
cJSON_Minify:
 2925|    921|{
 2926|    921|    char *into = json;
 2927|       |
 2928|    921|    if (json == NULL)
  ------------------
  |  Branch (2928:9): [True: 0, False: 921]
  ------------------
 2929|      0|    {
 2930|      0|        return;
 2931|      0|    }
 2932|       |
 2933|  3.08M|    while (json[0] != '\0')
  ------------------
  |  Branch (2933:12): [True: 3.08M, False: 921]
  ------------------
 2934|  3.08M|    {
 2935|  3.08M|        switch (json[0])
 2936|  3.08M|        {
 2937|    888|            case ' ':
  ------------------
  |  Branch (2937:13): [True: 888, False: 3.08M]
  ------------------
 2938|  1.08k|            case '\t':
  ------------------
  |  Branch (2938:13): [True: 199, False: 3.08M]
  ------------------
 2939|  1.53k|            case '\r':
  ------------------
  |  Branch (2939:13): [True: 448, False: 3.08M]
  ------------------
 2940|  3.88k|            case '\n':
  ------------------
  |  Branch (2940:13): [True: 2.34k, False: 3.08M]
  ------------------
 2941|  3.88k|                json++;
 2942|  3.88k|                break;
 2943|       |
 2944|  4.80k|            case '/':
  ------------------
  |  Branch (2944:13): [True: 4.80k, False: 3.08M]
  ------------------
 2945|  4.80k|                if (json[1] == '/')
  ------------------
  |  Branch (2945:21): [True: 2.16k, False: 2.64k]
  ------------------
 2946|  2.16k|                {
 2947|  2.16k|                    skip_oneline_comment(&json);
 2948|  2.16k|                }
 2949|  2.64k|                else if (json[1] == '*')
  ------------------
  |  Branch (2949:26): [True: 310, False: 2.33k]
  ------------------
 2950|    310|                {
 2951|    310|                    skip_multiline_comment(&json);
 2952|  2.33k|                } else {
 2953|  2.33k|                    json++;
 2954|  2.33k|                }
 2955|  4.80k|                break;
 2956|       |
 2957|  19.4k|            case '\"':
  ------------------
  |  Branch (2957:13): [True: 19.4k, False: 3.06M]
  ------------------
 2958|  19.4k|                minify_string(&json, (char**)&into);
 2959|  19.4k|                break;
 2960|       |
 2961|  3.05M|            default:
  ------------------
  |  Branch (2961:13): [True: 3.05M, False: 28.1k]
  ------------------
 2962|  3.05M|                into[0] = json[0];
 2963|  3.05M|                json++;
 2964|  3.05M|                into++;
 2965|  3.08M|        }
 2966|  3.08M|    }
 2967|       |
 2968|       |    /* and null-terminate. */
 2969|    921|    *into = '\0';
 2970|    921|}
cJSON.c:cJSON_New_Item:
  242|   734k|{
  243|   734k|    cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON));
  244|   734k|    if (node)
  ------------------
  |  Branch (244:9): [True: 734k, False: 0]
  ------------------
  245|   734k|    {
  246|   734k|        memset(node, '\0', sizeof(cJSON));
  247|   734k|    }
  248|       |
  249|   734k|    return node;
  250|   734k|}
cJSON.c:buffer_skip_whitespace:
 1091|  2.16M|{
 1092|  2.16M|    if ((buffer == NULL) || (buffer->content == NULL))
  ------------------
  |  Branch (1092:9): [True: 0, False: 2.16M]
  |  Branch (1092:29): [True: 0, False: 2.16M]
  ------------------
 1093|      0|    {
 1094|      0|        return NULL;
 1095|      0|    }
 1096|       |
 1097|  2.16M|    if (cannot_access_at_index(buffer, 0))
  ------------------
  |  |  302|  2.16M|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
  |  |  ------------------
  |  |  |  |  301|  2.16M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (301:45): [True: 2.16M, False: 0]
  |  |  |  |  |  Branch (301:65): [True: 2.16M, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1098|      0|    {
 1099|      0|        return buffer;
 1100|      0|    }
 1101|       |
 1102|  3.31M|    while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
  ------------------
  |  |  301|  6.63M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 3.31M, False: 0]
  |  |  |  Branch (301:65): [True: 3.31M, False: 925]
  |  |  ------------------
  ------------------
                  while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32))
  ------------------
  |  |  304|  3.31M|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1102:46): [True: 1.15M, False: 2.16M]
  ------------------
 1103|  1.15M|    {
 1104|  1.15M|       buffer->offset++;
 1105|  1.15M|    }
 1106|       |
 1107|  2.16M|    if (buffer->offset == buffer->length)
  ------------------
  |  Branch (1107:9): [True: 925, False: 2.16M]
  ------------------
 1108|    925|    {
 1109|    925|        buffer->offset--;
 1110|    925|    }
 1111|       |
 1112|  2.16M|    return buffer;
 1113|  2.16M|}
cJSON.c:skip_utf8_bom:
 1117|  2.01k|{
 1118|  2.01k|    if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0))
  ------------------
  |  Branch (1118:9): [True: 0, False: 2.01k]
  |  Branch (1118:29): [True: 0, False: 2.01k]
  |  Branch (1118:58): [True: 0, False: 2.01k]
  ------------------
 1119|      0|    {
 1120|      0|        return NULL;
 1121|      0|    }
 1122|       |
 1123|  2.01k|    if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
  ------------------
  |  |  301|  4.02k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 2.01k, False: 0]
  |  |  |  Branch (301:65): [True: 1.72k, False: 286]
  |  |  ------------------
  ------------------
                  if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0))
  ------------------
  |  |  304|  1.72k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1123:43): [True: 86, False: 1.64k]
  ------------------
 1124|     86|    {
 1125|     86|        buffer->offset += 3;
 1126|     86|    }
 1127|       |
 1128|  2.01k|    return buffer;
 1129|  2.01k|}
cJSON.c:print:
 1240|    520|{
 1241|    520|    static const size_t default_buffer_size = 256;
 1242|    520|    printbuffer buffer[1];
 1243|    520|    unsigned char *printed = NULL;
 1244|       |
 1245|    520|    memset(buffer, 0, sizeof(buffer));
 1246|       |
 1247|       |    /* create buffer */
 1248|    520|    buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size);
 1249|    520|    buffer->length = default_buffer_size;
 1250|    520|    buffer->format = format;
 1251|    520|    buffer->hooks = *hooks;
 1252|    520|    if (buffer->buffer == NULL)
  ------------------
  |  Branch (1252:9): [True: 0, False: 520]
  ------------------
 1253|      0|    {
 1254|      0|        goto fail;
 1255|      0|    }
 1256|       |
 1257|       |    /* print the value */
 1258|    520|    if (!print_value(item, buffer))
  ------------------
  |  Branch (1258:9): [True: 0, False: 520]
  ------------------
 1259|      0|    {
 1260|      0|        goto fail;
 1261|      0|    }
 1262|    520|    update_offset(buffer);
 1263|       |
 1264|       |    /* check if reallocate is available */
 1265|    520|    if (hooks->reallocate != NULL)
  ------------------
  |  Branch (1265:9): [True: 520, False: 0]
  ------------------
 1266|    520|    {
 1267|    520|        printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1);
 1268|    520|        if (printed == NULL) {
  ------------------
  |  Branch (1268:13): [True: 0, False: 520]
  ------------------
 1269|      0|            goto fail;
 1270|      0|        }
 1271|    520|        buffer->buffer = NULL;
 1272|    520|    }
 1273|      0|    else /* otherwise copy the JSON over to a new buffer */
 1274|      0|    {
 1275|      0|        printed = (unsigned char*) hooks->allocate(buffer->offset + 1);
 1276|      0|        if (printed == NULL)
  ------------------
  |  Branch (1276:13): [True: 0, False: 0]
  ------------------
 1277|      0|        {
 1278|      0|            goto fail;
 1279|      0|        }
 1280|      0|        memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1));
  ------------------
  |  | 1237|      0|#define cjson_min(a, b) (((a) < (b)) ? (a) : (b))
  |  |  ------------------
  |  |  |  Branch (1237:26): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1281|      0|        printed[buffer->offset] = '\0'; /* just to be sure */
 1282|       |
 1283|       |        /* free the buffer */
 1284|      0|        hooks->deallocate(buffer->buffer);
 1285|      0|        buffer->buffer = NULL;
 1286|      0|    }
 1287|       |
 1288|    520|    return printed;
 1289|       |
 1290|      0|fail:
 1291|      0|    if (buffer->buffer != NULL)
  ------------------
  |  Branch (1291:9): [True: 0, False: 0]
  ------------------
 1292|      0|    {
 1293|      0|        hooks->deallocate(buffer->buffer);
 1294|      0|        buffer->buffer = NULL;
 1295|      0|    }
 1296|       |
 1297|      0|    if (printed != NULL)
  ------------------
  |  Branch (1297:9): [True: 0, False: 0]
  ------------------
 1298|      0|    {
 1299|      0|        hooks->deallocate(printed);
 1300|      0|        printed = NULL;
 1301|      0|    }
 1302|       |
 1303|       |    return NULL;
 1304|    520|}
cJSON.c:update_offset:
  577|   675k|{
  578|   675k|    const unsigned char *buffer_pointer = NULL;
  579|   675k|    if ((buffer == NULL) || (buffer->buffer == NULL))
  ------------------
  |  Branch (579:9): [True: 0, False: 675k]
  |  Branch (579:29): [True: 0, False: 675k]
  ------------------
  580|      0|    {
  581|      0|        return;
  582|      0|    }
  583|   675k|    buffer_pointer = buffer->buffer + buffer->offset;
  584|       |
  585|   675k|    buffer->offset += strlen((const char*)buffer_pointer);
  586|   675k|}
cJSON.c:parse_value:
 1369|   733k|{
 1370|   733k|    if ((input_buffer == NULL) || (input_buffer->content == NULL))
  ------------------
  |  Branch (1370:9): [True: 0, False: 733k]
  |  Branch (1370:35): [True: 0, False: 733k]
  ------------------
 1371|      0|    {
 1372|      0|        return false; /* no input */
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1373|      0|    }
 1374|       |
 1375|       |    /* parse the different types of values */
 1376|       |    /* null */
 1377|   733k|    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0))
  ------------------
  |  |  299|  1.46M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (299:33): [True: 733k, False: 0]
  |  |  |  Branch (299:53): [True: 733k, False: 850]
  |  |  ------------------
  ------------------
                  if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0))
  ------------------
  |  |  304|   733k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1377:38): [True: 550, False: 732k]
  ------------------
 1378|    550|    {
 1379|    550|        item->type = cJSON_NULL;
  ------------------
  |  |   92|    550|#define cJSON_NULL   (1 << 2)
  ------------------
 1380|    550|        input_buffer->offset += 4;
 1381|    550|        return true;
  ------------------
  |  |   65|    550|#define true ((cJSON_bool)1)
  ------------------
 1382|    550|    }
 1383|       |    /* false */
 1384|   733k|    if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0))
  ------------------
  |  |  299|  1.46M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (299:33): [True: 733k, False: 0]
  |  |  |  Branch (299:53): [True: 732k, False: 1.22k]
  |  |  ------------------
  ------------------
                  if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0))
  ------------------
  |  |  304|   732k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1384:38): [True: 793, False: 731k]
  ------------------
 1385|    793|    {
 1386|    793|        item->type = cJSON_False;
  ------------------
  |  |   90|    793|#define cJSON_False  (1 << 0)
  ------------------
 1387|    793|        input_buffer->offset += 5;
 1388|    793|        return true;
  ------------------
  |  |   65|    793|#define true ((cJSON_bool)1)
  ------------------
 1389|    793|    }
 1390|       |    /* true */
 1391|   732k|    if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0))
  ------------------
  |  |  299|  1.46M|#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (299:33): [True: 732k, False: 0]
  |  |  |  Branch (299:53): [True: 731k, False: 850]
  |  |  ------------------
  ------------------
                  if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0))
  ------------------
  |  |  304|   731k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1391:38): [True: 2.96k, False: 728k]
  ------------------
 1392|  2.96k|    {
 1393|  2.96k|        item->type = cJSON_True;
  ------------------
  |  |   91|  2.96k|#define cJSON_True   (1 << 1)
  ------------------
 1394|  2.96k|        item->valueint = 1;
 1395|  2.96k|        input_buffer->offset += 4;
 1396|  2.96k|        return true;
  ------------------
  |  |   65|  2.96k|#define true ((cJSON_bool)1)
  ------------------
 1397|  2.96k|    }
 1398|       |    /* string */
 1399|   729k|    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"'))
  ------------------
  |  |  301|  1.45M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 729k, False: 0]
  |  |  |  Branch (301:65): [True: 729k, False: 0]
  |  |  ------------------
  ------------------
                  if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"'))
  ------------------
  |  |  304|   729k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1399:49): [True: 8.04k, False: 721k]
  ------------------
 1400|  8.04k|    {
 1401|  8.04k|        return parse_string(item, input_buffer);
 1402|  8.04k|    }
 1403|       |    /* number */
 1404|   721k|    if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9'))))
  ------------------
  |  |  301|  1.44M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 721k, False: 0]
  |  |  |  Branch (301:65): [True: 721k, False: 0]
  |  |  ------------------
  ------------------
                  if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9'))))
  ------------------
  |  |  304|   721k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
                  if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9'))))
  ------------------
  |  |  304|   720k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
                  if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9'))))
  ------------------
  |  |  304|   720k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1404:50): [True: 902, False: 720k]
  |  Branch (1404:97): [True: 720k, False: 168]
  |  Branch (1404:143): [True: 23.4k, False: 697k]
  ------------------
 1405|  24.3k|    {
 1406|  24.3k|        return parse_number(item, input_buffer);
 1407|  24.3k|    }
 1408|       |    /* array */
 1409|   697k|    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '['))
  ------------------
  |  |  301|  1.39M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 697k, False: 0]
  |  |  |  Branch (301:65): [True: 697k, False: 0]
  |  |  ------------------
  ------------------
                  if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '['))
  ------------------
  |  |  304|   697k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1409:49): [True: 289k, False: 407k]
  ------------------
 1410|   289k|    {
 1411|   289k|        return parse_array(item, input_buffer);
 1412|   289k|    }
 1413|       |    /* object */
 1414|   407k|    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{'))
  ------------------
  |  |  301|   814k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 407k, False: 0]
  |  |  |  Branch (301:65): [True: 407k, False: 0]
  |  |  ------------------
  ------------------
                  if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{'))
  ------------------
  |  |  304|   407k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1414:49): [True: 406k, False: 320]
  ------------------
 1415|   406k|    {
 1416|   406k|        return parse_object(item, input_buffer);
 1417|   406k|    }
 1418|       |
 1419|    320|    return false;
  ------------------
  |  |   70|    320|#define false ((cJSON_bool)0)
  ------------------
 1420|   407k|}
cJSON.c:parse_string:
  825|  33.9k|{
  826|  33.9k|    const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1;
  ------------------
  |  |  304|  33.9k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  827|  33.9k|    const unsigned char *input_end = buffer_at_offset(input_buffer) + 1;
  ------------------
  |  |  304|  33.9k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  828|  33.9k|    unsigned char *output_pointer = NULL;
  829|  33.9k|    unsigned char *output = NULL;
  830|       |
  831|       |    /* not a string */
  832|  33.9k|    if (buffer_at_offset(input_buffer)[0] != '\"')
  ------------------
  |  |  304|  33.9k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (832:9): [True: 128, False: 33.8k]
  ------------------
  833|    128|    {
  834|    128|        goto fail;
  835|    128|    }
  836|       |
  837|  33.8k|    {
  838|       |        /* calculate approximate size of the output (overestimate) */
  839|  33.8k|        size_t allocation_length = 0;
  840|  33.8k|        size_t skipped_bytes = 0;
  841|  25.3M|        while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"'))
  ------------------
  |  Branch (841:16): [True: 25.3M, False: 82]
  |  Branch (841:88): [True: 25.2M, False: 33.7k]
  ------------------
  842|  25.2M|        {
  843|       |            /* is escape sequence */
  844|  25.2M|            if (input_end[0] == '\\')
  ------------------
  |  Branch (844:17): [True: 170k, False: 25.1M]
  ------------------
  845|   170k|            {
  846|   170k|                if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length)
  ------------------
  |  Branch (846:21): [True: 0, False: 170k]
  ------------------
  847|      0|                {
  848|       |                    /* prevent buffer overflow when last input character is a backslash */
  849|      0|                    goto fail;
  850|      0|                }
  851|   170k|                skipped_bytes++;
  852|   170k|                input_end++;
  853|   170k|            }
  854|  25.2M|            input_end++;
  855|  25.2M|        }
  856|  33.8k|        if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"'))
  ------------------
  |  Branch (856:13): [True: 82, False: 33.7k]
  |  Branch (856:86): [True: 0, False: 33.7k]
  ------------------
  857|     82|        {
  858|     82|            goto fail; /* string ended unexpectedly */
  859|     82|        }
  860|       |
  861|       |        /* This is at most how much we need for the output */
  862|  33.7k|        allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes;
  ------------------
  |  |  304|  33.7k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  863|  33.7k|        output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof(""));
  864|  33.7k|        if (output == NULL)
  ------------------
  |  Branch (864:13): [True: 0, False: 33.7k]
  ------------------
  865|      0|        {
  866|      0|            goto fail; /* allocation failure */
  867|      0|        }
  868|  33.7k|    }
  869|       |
  870|  33.7k|    output_pointer = output;
  871|       |    /* loop through the string literal */
  872|  23.6M|    while (input_pointer < input_end)
  ------------------
  |  Branch (872:12): [True: 23.6M, False: 33.6k]
  ------------------
  873|  23.6M|    {
  874|  23.6M|        if (*input_pointer != '\\')
  ------------------
  |  Branch (874:13): [True: 23.5M, False: 153k]
  ------------------
  875|  23.5M|        {
  876|  23.5M|            *output_pointer++ = *input_pointer++;
  877|  23.5M|        }
  878|       |        /* escape sequence */
  879|   153k|        else
  880|   153k|        {
  881|   153k|            unsigned char sequence_length = 2;
  882|   153k|            if ((input_end - input_pointer) < 1)
  ------------------
  |  Branch (882:17): [True: 0, False: 153k]
  ------------------
  883|      0|            {
  884|      0|                goto fail;
  885|      0|            }
  886|       |
  887|   153k|            switch (input_pointer[1])
  888|   153k|            {
  889|  12.6k|                case 'b':
  ------------------
  |  Branch (889:17): [True: 12.6k, False: 140k]
  ------------------
  890|  12.6k|                    *output_pointer++ = '\b';
  891|  12.6k|                    break;
  892|  6.84k|                case 'f':
  ------------------
  |  Branch (892:17): [True: 6.84k, False: 146k]
  ------------------
  893|  6.84k|                    *output_pointer++ = '\f';
  894|  6.84k|                    break;
  895|  9.66k|                case 'n':
  ------------------
  |  Branch (895:17): [True: 9.66k, False: 143k]
  ------------------
  896|  9.66k|                    *output_pointer++ = '\n';
  897|  9.66k|                    break;
  898|  6.49k|                case 'r':
  ------------------
  |  Branch (898:17): [True: 6.49k, False: 146k]
  ------------------
  899|  6.49k|                    *output_pointer++ = '\r';
  900|  6.49k|                    break;
  901|  19.0k|                case 't':
  ------------------
  |  Branch (901:17): [True: 19.0k, False: 134k]
  ------------------
  902|  19.0k|                    *output_pointer++ = '\t';
  903|  19.0k|                    break;
  904|  16.8k|                case '\"':
  ------------------
  |  Branch (904:17): [True: 16.8k, False: 136k]
  ------------------
  905|  29.7k|                case '\\':
  ------------------
  |  Branch (905:17): [True: 12.8k, False: 140k]
  ------------------
  906|  46.7k|                case '/':
  ------------------
  |  Branch (906:17): [True: 16.9k, False: 136k]
  ------------------
  907|  46.7k|                    *output_pointer++ = input_pointer[1];
  908|  46.7k|                    break;
  909|       |
  910|       |                /* UTF-16 literal */
  911|  51.8k|                case 'u':
  ------------------
  |  Branch (911:17): [True: 51.8k, False: 101k]
  ------------------
  912|  51.8k|                    sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer);
  913|  51.8k|                    if (sequence_length == 0)
  ------------------
  |  Branch (913:25): [True: 121, False: 51.7k]
  ------------------
  914|    121|                    {
  915|       |                        /* failed to convert UTF16-literal to UTF-8 */
  916|    121|                        goto fail;
  917|    121|                    }
  918|  51.7k|                    break;
  919|       |
  920|  51.7k|                default:
  ------------------
  |  Branch (920:17): [True: 8, False: 153k]
  ------------------
  921|      8|                    goto fail;
  922|   153k|            }
  923|   153k|            input_pointer += sequence_length;
  924|   153k|        }
  925|  23.6M|    }
  926|       |
  927|       |    /* zero terminate the output */
  928|  33.6k|    *output_pointer = '\0';
  929|       |
  930|  33.6k|    item->type = cJSON_String;
  ------------------
  |  |   94|  33.6k|#define cJSON_String (1 << 4)
  ------------------
  931|  33.6k|    item->valuestring = (char*)output;
  932|       |
  933|  33.6k|    input_buffer->offset = (size_t) (input_end - input_buffer->content);
  934|  33.6k|    input_buffer->offset++;
  935|       |
  936|  33.6k|    return true;
  ------------------
  |  |   65|  33.6k|#define true ((cJSON_bool)1)
  ------------------
  937|       |
  938|    339|fail:
  939|    339|    if (output != NULL)
  ------------------
  |  Branch (939:9): [True: 129, False: 210]
  ------------------
  940|    129|    {
  941|    129|        input_buffer->hooks.deallocate(output);
  942|    129|        output = NULL;
  943|    129|    }
  944|       |
  945|    339|    if (input_pointer != NULL)
  ------------------
  |  Branch (945:9): [True: 339, False: 0]
  ------------------
  946|    339|    {
  947|    339|        input_buffer->offset = (size_t)(input_pointer - input_buffer->content);
  948|    339|    }
  949|       |
  950|    339|    return false;
  ------------------
  |  |   70|    339|#define false ((cJSON_bool)0)
  ------------------
  951|  33.7k|}
cJSON.c:utf16_literal_to_utf8:
  704|  51.8k|{
  705|  51.8k|    long unsigned int codepoint = 0;
  706|  51.8k|    unsigned int first_code = 0;
  707|  51.8k|    const unsigned char *first_sequence = input_pointer;
  708|  51.8k|    unsigned char utf8_length = 0;
  709|  51.8k|    unsigned char utf8_position = 0;
  710|  51.8k|    unsigned char sequence_length = 0;
  711|  51.8k|    unsigned char first_byte_mark = 0;
  712|       |
  713|  51.8k|    if ((input_end - first_sequence) < 6)
  ------------------
  |  Branch (713:9): [True: 3, False: 51.8k]
  ------------------
  714|      3|    {
  715|       |        /* input ends unexpectedly */
  716|      3|        goto fail;
  717|      3|    }
  718|       |
  719|       |    /* get the first utf16 sequence */
  720|  51.8k|    first_code = parse_hex4(first_sequence + 2);
  721|       |
  722|       |    /* check that the code is valid */
  723|  51.8k|    if (((first_code >= 0xDC00) && (first_code <= 0xDFFF)))
  ------------------
  |  Branch (723:10): [True: 6.20k, False: 45.6k]
  |  Branch (723:36): [True: 14, False: 6.18k]
  ------------------
  724|     14|    {
  725|     14|        goto fail;
  726|     14|    }
  727|       |
  728|       |    /* UTF16 surrogate pair */
  729|  51.8k|    if ((first_code >= 0xD800) && (first_code <= 0xDBFF))
  ------------------
  |  Branch (729:9): [True: 9.43k, False: 42.3k]
  |  Branch (729:35): [True: 3.24k, False: 6.18k]
  ------------------
  730|  3.24k|    {
  731|  3.24k|        const unsigned char *second_sequence = first_sequence + 6;
  732|  3.24k|        unsigned int second_code = 0;
  733|  3.24k|        sequence_length = 12; /* \uXXXX\uXXXX */
  734|       |
  735|  3.24k|        if ((input_end - second_sequence) < 6)
  ------------------
  |  Branch (735:13): [True: 18, False: 3.22k]
  ------------------
  736|     18|        {
  737|       |            /* input ends unexpectedly */
  738|     18|            goto fail;
  739|     18|        }
  740|       |
  741|  3.22k|        if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u'))
  ------------------
  |  Branch (741:13): [True: 16, False: 3.20k]
  |  Branch (741:45): [True: 15, False: 3.19k]
  ------------------
  742|     31|        {
  743|       |            /* missing second half of the surrogate pair */
  744|     31|            goto fail;
  745|     31|        }
  746|       |
  747|       |        /* get the second utf16 sequence */
  748|  3.19k|        second_code = parse_hex4(second_sequence + 2);
  749|       |        /* check that the code is valid */
  750|  3.19k|        if ((second_code < 0xDC00) || (second_code > 0xDFFF))
  ------------------
  |  Branch (750:13): [True: 50, False: 3.14k]
  |  Branch (750:39): [True: 5, False: 3.13k]
  ------------------
  751|     55|        {
  752|       |            /* invalid second half of the surrogate pair */
  753|     55|            goto fail;
  754|     55|        }
  755|       |
  756|       |
  757|       |        /* calculate the unicode codepoint from the surrogate pair */
  758|  3.13k|        codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF));
  759|  3.13k|    }
  760|  48.5k|    else
  761|  48.5k|    {
  762|  48.5k|        sequence_length = 6; /* \uXXXX */
  763|  48.5k|        codepoint = first_code;
  764|  48.5k|    }
  765|       |
  766|       |    /* encode as UTF-8
  767|       |     * takes at maximum 4 bytes to encode:
  768|       |     * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
  769|  51.7k|    if (codepoint < 0x80)
  ------------------
  |  Branch (769:9): [True: 26.5k, False: 25.1k]
  ------------------
  770|  26.5k|    {
  771|       |        /* normal ascii, encoding 0xxxxxxx */
  772|  26.5k|        utf8_length = 1;
  773|  26.5k|    }
  774|  25.1k|    else if (codepoint < 0x800)
  ------------------
  |  Branch (774:14): [True: 4.81k, False: 20.3k]
  ------------------
  775|  4.81k|    {
  776|       |        /* two bytes, encoding 110xxxxx 10xxxxxx */
  777|  4.81k|        utf8_length = 2;
  778|  4.81k|        first_byte_mark = 0xC0; /* 11000000 */
  779|  4.81k|    }
  780|  20.3k|    else if (codepoint < 0x10000)
  ------------------
  |  Branch (780:14): [True: 17.1k, False: 3.13k]
  ------------------
  781|  17.1k|    {
  782|       |        /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */
  783|  17.1k|        utf8_length = 3;
  784|  17.1k|        first_byte_mark = 0xE0; /* 11100000 */
  785|  17.1k|    }
  786|  3.13k|    else if (codepoint <= 0x10FFFF)
  ------------------
  |  Branch (786:14): [True: 3.13k, False: 0]
  ------------------
  787|  3.13k|    {
  788|       |        /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */
  789|  3.13k|        utf8_length = 4;
  790|  3.13k|        first_byte_mark = 0xF0; /* 11110000 */
  791|  3.13k|    }
  792|      0|    else
  793|      0|    {
  794|       |        /* invalid unicode codepoint */
  795|      0|        goto fail;
  796|      0|    }
  797|       |
  798|       |    /* encode as utf8 */
  799|   100k|    for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--)
  ------------------
  |  Branch (799:60): [True: 48.5k, False: 51.7k]
  ------------------
  800|  48.5k|    {
  801|       |        /* 10xxxxxx */
  802|  48.5k|        (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF);
  803|  48.5k|        codepoint >>= 6;
  804|  48.5k|    }
  805|       |    /* encode first byte */
  806|  51.7k|    if (utf8_length > 1)
  ------------------
  |  Branch (806:9): [True: 25.1k, False: 26.5k]
  ------------------
  807|  25.1k|    {
  808|  25.1k|        (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF);
  809|  25.1k|    }
  810|  26.5k|    else
  811|  26.5k|    {
  812|  26.5k|        (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F);
  813|  26.5k|    }
  814|       |
  815|  51.7k|    *output_pointer += utf8_length;
  816|       |
  817|  51.7k|    return sequence_length;
  818|       |
  819|    121|fail:
  820|    121|    return 0;
  821|  51.7k|}
cJSON.c:parse_hex4:
  667|  55.0k|{
  668|  55.0k|    unsigned int h = 0;
  669|  55.0k|    size_t i = 0;
  670|       |
  671|   213k|    for (i = 0; i < 4; i++)
  ------------------
  |  Branch (671:17): [True: 181k, False: 31.4k]
  ------------------
  672|   181k|    {
  673|       |        /* parse digit */
  674|   181k|        if ((input[i] >= '0') && (input[i] <= '9'))
  ------------------
  |  Branch (674:13): [True: 177k, False: 3.98k]
  |  Branch (674:34): [True: 66.4k, False: 111k]
  ------------------
  675|  66.4k|        {
  676|  66.4k|            h += (unsigned int) input[i] - '0';
  677|  66.4k|        }
  678|   115k|        else if ((input[i] >= 'A') && (input[i] <= 'F'))
  ------------------
  |  Branch (678:18): [True: 109k, False: 6.03k]
  |  Branch (678:39): [True: 22.6k, False: 86.6k]
  ------------------
  679|  22.6k|        {
  680|  22.6k|            h += (unsigned int) 10 + input[i] - 'A';
  681|  22.6k|        }
  682|  92.6k|        else if ((input[i] >= 'a') && (input[i] <= 'f'))
  ------------------
  |  Branch (682:18): [True: 83.9k, False: 8.72k]
  |  Branch (682:39): [True: 69.0k, False: 14.8k]
  ------------------
  683|  69.0k|        {
  684|  69.0k|            h += (unsigned int) 10 + input[i] - 'a';
  685|  69.0k|        }
  686|  23.6k|        else /* invalid */
  687|  23.6k|        {
  688|  23.6k|            return 0;
  689|  23.6k|        }
  690|       |
  691|   158k|        if (i < 3)
  ------------------
  |  Branch (691:13): [True: 126k, False: 31.4k]
  ------------------
  692|   126k|        {
  693|       |            /* shift left to make place for the next nibble */
  694|   126k|            h = h << 4;
  695|   126k|        }
  696|   158k|    }
  697|       |
  698|  31.4k|    return h;
  699|  55.0k|}
cJSON.c:parse_number:
  308|  24.3k|{
  309|  24.3k|    double number = 0;
  310|  24.3k|    unsigned char *after_end = NULL;
  311|  24.3k|    unsigned char *number_c_string;
  312|  24.3k|    unsigned char decimal_point = get_decimal_point();
  313|  24.3k|    size_t i = 0;
  314|  24.3k|    size_t number_string_length = 0;
  315|  24.3k|    cJSON_bool has_decimal_point = false;
  ------------------
  |  |   70|  24.3k|#define false ((cJSON_bool)0)
  ------------------
  316|       |
  317|  24.3k|    if ((input_buffer == NULL) || (input_buffer->content == NULL))
  ------------------
  |  Branch (317:9): [True: 0, False: 24.3k]
  |  Branch (317:35): [True: 0, False: 24.3k]
  ------------------
  318|      0|    {
  319|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
  320|      0|    }
  321|       |
  322|       |    /* copy the number into a temporary buffer and replace '.' with the decimal point
  323|       |     * of the current locale (for strtod)
  324|       |     * This also takes care of '\0' not necessarily being available for marking the end of the input */
  325|   619k|    for (i = 0; can_access_at_index(input_buffer, i); i++)
  ------------------
  |  |  301|   619k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 619k, False: 0]
  |  |  |  Branch (301:65): [True: 619k, False: 0]
  |  |  ------------------
  ------------------
  326|   619k|    {
  327|   619k|        switch (buffer_at_offset(input_buffer)[i])
  ------------------
  |  |  304|   619k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  328|   619k|        {
  329|   393k|            case '0':
  ------------------
  |  Branch (329:13): [True: 393k, False: 225k]
  ------------------
  330|   425k|            case '1':
  ------------------
  |  Branch (330:13): [True: 31.2k, False: 588k]
  ------------------
  331|   439k|            case '2':
  ------------------
  |  Branch (331:13): [True: 14.2k, False: 605k]
  ------------------
  332|   445k|            case '3':
  ------------------
  |  Branch (332:13): [True: 6.56k, False: 613k]
  ------------------
  333|   457k|            case '4':
  ------------------
  |  Branch (333:13): [True: 11.1k, False: 608k]
  ------------------
  334|   465k|            case '5':
  ------------------
  |  Branch (334:13): [True: 8.25k, False: 611k]
  ------------------
  335|   486k|            case '6':
  ------------------
  |  Branch (335:13): [True: 20.8k, False: 598k]
  ------------------
  336|   499k|            case '7':
  ------------------
  |  Branch (336:13): [True: 13.4k, False: 606k]
  ------------------
  337|   510k|            case '8':
  ------------------
  |  Branch (337:13): [True: 11.2k, False: 608k]
  ------------------
  338|   531k|            case '9':
  ------------------
  |  Branch (338:13): [True: 20.4k, False: 599k]
  ------------------
  339|   532k|            case '+':
  ------------------
  |  Branch (339:13): [True: 1.11k, False: 618k]
  ------------------
  340|   581k|            case '-':
  ------------------
  |  Branch (340:13): [True: 48.8k, False: 570k]
  ------------------
  341|   584k|            case 'e':
  ------------------
  |  Branch (341:13): [True: 3.09k, False: 616k]
  ------------------
  342|   586k|            case 'E':
  ------------------
  |  Branch (342:13): [True: 2.24k, False: 617k]
  ------------------
  343|   586k|                number_string_length++;
  344|   586k|                break;
  345|       |
  346|  8.53k|            case '.':
  ------------------
  |  Branch (346:13): [True: 8.53k, False: 611k]
  ------------------
  347|  8.53k|                number_string_length++;
  348|  8.53k|                has_decimal_point = true;
  ------------------
  |  |   65|  8.53k|#define true ((cJSON_bool)1)
  ------------------
  349|  8.53k|                break;
  350|       |
  351|  24.3k|            default:
  ------------------
  |  Branch (351:13): [True: 24.3k, False: 595k]
  ------------------
  352|  24.3k|                goto loop_end;
  353|   619k|        }
  354|   619k|    }
  355|  24.3k|loop_end:
  356|       |    /* malloc for temporary buffer, add 1 for '\0' */
  357|  24.3k|    number_c_string = (unsigned char *) input_buffer->hooks.allocate(number_string_length + 1);
  358|  24.3k|    if (number_c_string == NULL)
  ------------------
  |  Branch (358:9): [True: 0, False: 24.3k]
  ------------------
  359|      0|    {
  360|      0|        return false; /* allocation failure */
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
  361|      0|    }
  362|       |
  363|  24.3k|    memcpy(number_c_string, buffer_at_offset(input_buffer), number_string_length);
  ------------------
  |  |  304|  24.3k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  364|  24.3k|    number_c_string[number_string_length] = '\0';
  365|       |
  366|  24.3k|    if (has_decimal_point)
  ------------------
  |  Branch (366:9): [True: 1.43k, False: 22.8k]
  ------------------
  367|  1.43k|    {
  368|   539k|        for (i = 0; i < number_string_length; i++)
  ------------------
  |  Branch (368:21): [True: 538k, False: 1.43k]
  ------------------
  369|   538k|        {
  370|   538k|            if (number_c_string[i] == '.')
  ------------------
  |  Branch (370:17): [True: 8.53k, False: 529k]
  ------------------
  371|  8.53k|            {
  372|       |                /* replace '.' with the decimal point of the current locale (for strtod) */
  373|  8.53k|                number_c_string[i] = decimal_point;
  374|  8.53k|            }
  375|   538k|        }
  376|  1.43k|    }
  377|       |
  378|  24.3k|    number = strtod((const char*)number_c_string, (char**)&after_end);
  379|  24.3k|    if (number_c_string == after_end)
  ------------------
  |  Branch (379:9): [True: 21, False: 24.3k]
  ------------------
  380|     21|    {
  381|       |        /* free the temporary buffer */
  382|     21|        input_buffer->hooks.deallocate(number_c_string);
  383|     21|        return false; /* parse_error */
  ------------------
  |  |   70|     21|#define false ((cJSON_bool)0)
  ------------------
  384|     21|    }
  385|       |
  386|  24.3k|    item->valuedouble = number;
  387|       |
  388|       |    /* use saturation in case of overflow */
  389|  24.3k|    if (number >= INT_MAX)
  ------------------
  |  Branch (389:9): [True: 3.12k, False: 21.1k]
  ------------------
  390|  3.12k|    {
  391|  3.12k|        item->valueint = INT_MAX;
  392|  3.12k|    }
  393|  21.1k|    else if (number <= (double)INT_MIN)
  ------------------
  |  Branch (393:14): [True: 331, False: 20.8k]
  ------------------
  394|    331|    {
  395|    331|        item->valueint = INT_MIN;
  396|    331|    }
  397|  20.8k|    else
  398|  20.8k|    {
  399|  20.8k|        item->valueint = (int)number;
  400|  20.8k|    }
  401|       |
  402|  24.3k|    item->type = cJSON_Number;
  ------------------
  |  |   93|  24.3k|#define cJSON_Number (1 << 3)
  ------------------
  403|       |
  404|  24.3k|    input_buffer->offset += (size_t)(after_end - number_c_string);
  405|       |    /* free the temporary buffer */
  406|  24.3k|    input_buffer->hooks.deallocate(number_c_string);
  407|  24.3k|    return true;
  ------------------
  |  |   65|  24.3k|#define true ((cJSON_bool)1)
  ------------------
  408|  24.3k|}
cJSON.c:get_decimal_point:
  280|  40.6k|{
  281|  40.6k|#ifdef ENABLE_LOCALES
  282|  40.6k|    struct lconv *lconv = localeconv();
  283|  40.6k|    return (unsigned char) lconv->decimal_point[0];
  284|       |#else
  285|       |    return '.';
  286|       |#endif
  287|  40.6k|}
cJSON.c:parse_array:
 1498|   289k|{
 1499|   289k|    cJSON *head = NULL; /* head of the linked list */
 1500|   289k|    cJSON *current_item = NULL;
 1501|       |
 1502|   289k|    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
  ------------------
  |  |  137|   289k|#define CJSON_NESTING_LIMIT 1000
  ------------------
  |  Branch (1502:9): [True: 1, False: 289k]
  ------------------
 1503|      1|    {
 1504|      1|        return false; /* to deeply nested */
  ------------------
  |  |   70|      1|#define false ((cJSON_bool)0)
  ------------------
 1505|      1|    }
 1506|   289k|    input_buffer->depth++;
 1507|       |
 1508|   289k|    if (buffer_at_offset(input_buffer)[0] != '[')
  ------------------
  |  |  304|   289k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1508:9): [True: 0, False: 289k]
  ------------------
 1509|      0|    {
 1510|       |        /* not an array */
 1511|      0|        goto fail;
 1512|      0|    }
 1513|       |
 1514|   289k|    input_buffer->offset++;
 1515|   289k|    buffer_skip_whitespace(input_buffer);
 1516|   289k|    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']'))
  ------------------
  |  |  301|   579k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 289k, False: 0]
  |  |  |  Branch (301:65): [True: 289k, False: 0]
  |  |  ------------------
  ------------------
                  if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']'))
  ------------------
  |  |  304|   289k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1516:49): [True: 3.44k, False: 286k]
  ------------------
 1517|  3.44k|    {
 1518|       |        /* empty array */
 1519|  3.44k|        goto success;
 1520|  3.44k|    }
 1521|       |
 1522|       |    /* check if we skipped to the end of the buffer */
 1523|   286k|    if (cannot_access_at_index(input_buffer, 0))
  ------------------
  |  |  302|   286k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
  |  |  ------------------
  |  |  |  |  301|   286k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (301:45): [True: 286k, False: 0]
  |  |  |  |  |  Branch (301:65): [True: 286k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1524|      0|    {
 1525|      0|        input_buffer->offset--;
 1526|      0|        goto fail;
 1527|      0|    }
 1528|       |
 1529|       |    /* step back to character in front of the first element */
 1530|   286k|    input_buffer->offset--;
 1531|       |    /* loop through the comma separated array elements */
 1532|   286k|    do
 1533|   706k|    {
 1534|       |        /* allocate next item */
 1535|   706k|        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
 1536|   706k|        if (new_item == NULL)
  ------------------
  |  Branch (1536:13): [True: 0, False: 706k]
  ------------------
 1537|      0|        {
 1538|      0|            goto fail; /* allocation failure */
 1539|      0|        }
 1540|       |
 1541|       |        /* attach next item to list */
 1542|   706k|        if (head == NULL)
  ------------------
  |  Branch (1542:13): [True: 286k, False: 419k]
  ------------------
 1543|   286k|        {
 1544|       |            /* start the linked list */
 1545|   286k|            current_item = head = new_item;
 1546|   286k|        }
 1547|   419k|        else
 1548|   419k|        {
 1549|       |            /* add to the end and advance */
 1550|   419k|            current_item->next = new_item;
 1551|   419k|            new_item->prev = current_item;
 1552|   419k|            current_item = new_item;
 1553|   419k|        }
 1554|       |
 1555|       |        /* parse next value */
 1556|   706k|        input_buffer->offset++;
 1557|   706k|        buffer_skip_whitespace(input_buffer);
 1558|   706k|        if (!parse_value(current_item, input_buffer))
  ------------------
  |  Branch (1558:13): [True: 48.9k, False: 657k]
  ------------------
 1559|  48.9k|        {
 1560|  48.9k|            goto fail; /* failed to parse value */
 1561|  48.9k|        }
 1562|   657k|        buffer_skip_whitespace(input_buffer);
 1563|   657k|    }
 1564|   657k|    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
  ------------------
  |  |  301|  1.31M|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 657k, False: 0]
  |  |  |  Branch (301:65): [True: 657k, False: 0]
  |  |  ------------------
  ------------------
                  while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
  ------------------
  |  |  304|   657k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1564:52): [True: 419k, False: 237k]
  ------------------
 1565|       |
 1566|   237k|    if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']')
  ------------------
  |  |  302|   474k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
  |  |  ------------------
  |  |  |  |  301|   237k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (301:45): [True: 237k, False: 0]
  |  |  |  |  |  Branch (301:65): [True: 237k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']')
  ------------------
  |  |  304|   237k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1566:52): [True: 111, False: 237k]
  ------------------
 1567|    111|    {
 1568|    111|        goto fail; /* expected end of array */
 1569|    111|    }
 1570|       |
 1571|   240k|success:
 1572|   240k|    input_buffer->depth--;
 1573|       |
 1574|   240k|    if (head != NULL) {
  ------------------
  |  Branch (1574:9): [True: 237k, False: 3.44k]
  ------------------
 1575|   237k|        head->prev = current_item;
 1576|   237k|    }
 1577|       |
 1578|   240k|    item->type = cJSON_Array;
  ------------------
  |  |   95|   240k|#define cJSON_Array  (1 << 5)
  ------------------
 1579|   240k|    item->child = head;
 1580|       |
 1581|   240k|    input_buffer->offset++;
 1582|       |
 1583|   240k|    return true;
  ------------------
  |  |   65|   240k|#define true ((cJSON_bool)1)
  ------------------
 1584|       |
 1585|  49.0k|fail:
 1586|  49.0k|    if (head != NULL)
  ------------------
  |  Branch (1586:9): [True: 49.0k, False: 0]
  ------------------
 1587|  49.0k|    {
 1588|  49.0k|        cJSON_Delete(head);
 1589|  49.0k|    }
 1590|       |
 1591|  49.0k|    return false;
  ------------------
  |  |   70|  49.0k|#define false ((cJSON_bool)0)
  ------------------
 1592|   237k|}
cJSON.c:parse_object:
 1663|   406k|{
 1664|   406k|    cJSON *head = NULL; /* linked list head */
 1665|   406k|    cJSON *current_item = NULL;
 1666|       |
 1667|   406k|    if (input_buffer->depth >= CJSON_NESTING_LIMIT)
  ------------------
  |  |  137|   406k|#define CJSON_NESTING_LIMIT 1000
  ------------------
  |  Branch (1667:9): [True: 2, False: 406k]
  ------------------
 1668|      2|    {
 1669|      2|        return false; /* to deeply nested */
  ------------------
  |  |   70|      2|#define false ((cJSON_bool)0)
  ------------------
 1670|      2|    }
 1671|   406k|    input_buffer->depth++;
 1672|       |
 1673|   406k|    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{'))
  ------------------
  |  |  302|   813k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
  |  |  ------------------
  |  |  |  |  301|   406k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (301:45): [True: 406k, False: 0]
  |  |  |  |  |  Branch (301:65): [True: 406k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{'))
  ------------------
  |  |  304|   406k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1673:52): [True: 0, False: 406k]
  ------------------
 1674|      0|    {
 1675|      0|        goto fail; /* not an object */
 1676|      0|    }
 1677|       |
 1678|   406k|    input_buffer->offset++;
 1679|   406k|    buffer_skip_whitespace(input_buffer);
 1680|   406k|    if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}'))
  ------------------
  |  |  301|   813k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 406k, False: 0]
  |  |  |  Branch (301:65): [True: 406k, False: 0]
  |  |  ------------------
  ------------------
                  if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}'))
  ------------------
  |  |  304|   406k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1680:49): [True: 395k, False: 11.6k]
  ------------------
 1681|   395k|    {
 1682|   395k|        goto success; /* empty object */
 1683|   395k|    }
 1684|       |
 1685|       |    /* check if we skipped to the end of the buffer */
 1686|  11.6k|    if (cannot_access_at_index(input_buffer, 0))
  ------------------
  |  |  302|  11.6k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
  |  |  ------------------
  |  |  |  |  301|  11.6k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (301:45): [True: 11.6k, False: 0]
  |  |  |  |  |  Branch (301:65): [True: 11.6k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1687|      0|    {
 1688|      0|        input_buffer->offset--;
 1689|      0|        goto fail;
 1690|      0|    }
 1691|       |
 1692|       |    /* step back to character in front of the first element */
 1693|  11.6k|    input_buffer->offset--;
 1694|       |    /* loop through the comma separated array elements */
 1695|  11.6k|    do
 1696|  25.9k|    {
 1697|       |        /* allocate next item */
 1698|  25.9k|        cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks));
 1699|  25.9k|        if (new_item == NULL)
  ------------------
  |  Branch (1699:13): [True: 0, False: 25.9k]
  ------------------
 1700|      0|        {
 1701|      0|            goto fail; /* allocation failure */
 1702|      0|        }
 1703|       |
 1704|       |        /* attach next item to list */
 1705|  25.9k|        if (head == NULL)
  ------------------
  |  Branch (1705:13): [True: 11.6k, False: 14.3k]
  ------------------
 1706|  11.6k|        {
 1707|       |            /* start the linked list */
 1708|  11.6k|            current_item = head = new_item;
 1709|  11.6k|        }
 1710|  14.3k|        else
 1711|  14.3k|        {
 1712|       |            /* add to the end and advance */
 1713|  14.3k|            current_item->next = new_item;
 1714|  14.3k|            new_item->prev = current_item;
 1715|  14.3k|            current_item = new_item;
 1716|  14.3k|        }
 1717|       |
 1718|  25.9k|        if (cannot_access_at_index(input_buffer, 1))
  ------------------
  |  |  302|  25.9k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
  |  |  ------------------
  |  |  |  |  301|  25.9k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (301:45): [True: 25.9k, False: 0]
  |  |  |  |  |  Branch (301:65): [True: 25.9k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1719|      0|        {
 1720|      0|            goto fail; /* nothing comes after the comma */
 1721|      0|        }
 1722|       |
 1723|       |        /* parse the name of the child */
 1724|  25.9k|        input_buffer->offset++;
 1725|  25.9k|        buffer_skip_whitespace(input_buffer);
 1726|  25.9k|        if (!parse_string(current_item, input_buffer))
  ------------------
  |  Branch (1726:13): [True: 142, False: 25.8k]
  ------------------
 1727|    142|        {
 1728|    142|            goto fail; /* failed to parse name */
 1729|    142|        }
 1730|  25.8k|        buffer_skip_whitespace(input_buffer);
 1731|       |
 1732|       |        /* swap valuestring and string, because we parsed the name */
 1733|  25.8k|        current_item->string = current_item->valuestring;
 1734|  25.8k|        current_item->valuestring = NULL;
 1735|       |
 1736|  25.8k|        if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':'))
  ------------------
  |  |  302|  51.6k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
  |  |  ------------------
  |  |  |  |  301|  25.8k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (301:45): [True: 25.8k, False: 0]
  |  |  |  |  |  Branch (301:65): [True: 25.8k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                      if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':'))
  ------------------
  |  |  304|  25.8k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1736:56): [True: 36, False: 25.7k]
  ------------------
 1737|     36|        {
 1738|     36|            goto fail; /* invalid object */
 1739|     36|        }
 1740|       |
 1741|       |        /* parse the value */
 1742|  25.7k|        input_buffer->offset++;
 1743|  25.7k|        buffer_skip_whitespace(input_buffer);
 1744|  25.7k|        if (!parse_value(current_item, input_buffer))
  ------------------
  |  Branch (1744:13): [True: 2.68k, False: 23.0k]
  ------------------
 1745|  2.68k|        {
 1746|  2.68k|            goto fail; /* failed to parse value */
 1747|  2.68k|        }
 1748|  23.0k|        buffer_skip_whitespace(input_buffer);
 1749|  23.0k|    }
 1750|  23.0k|    while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
  ------------------
  |  |  301|  46.1k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  ------------------
  |  |  |  Branch (301:45): [True: 23.0k, False: 0]
  |  |  |  Branch (301:65): [True: 23.0k, False: 0]
  |  |  ------------------
  ------------------
                  while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ','));
  ------------------
  |  |  304|  23.0k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1750:52): [True: 14.3k, False: 8.74k]
  ------------------
 1751|       |
 1752|  8.74k|    if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}'))
  ------------------
  |  |  302|  17.4k|#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index))
  |  |  ------------------
  |  |  |  |  301|  8.74k|#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (301:45): [True: 8.74k, False: 0]
  |  |  |  |  |  Branch (301:65): [True: 8.74k, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
                  if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}'))
  ------------------
  |  |  304|  8.74k|#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset)
  ------------------
  |  Branch (1752:52): [True: 41, False: 8.70k]
  ------------------
 1753|     41|    {
 1754|     41|        goto fail; /* expected end of object */
 1755|     41|    }
 1756|       |
 1757|   404k|success:
 1758|   404k|    input_buffer->depth--;
 1759|       |
 1760|   404k|    if (head != NULL) {
  ------------------
  |  Branch (1760:9): [True: 8.70k, False: 395k]
  ------------------
 1761|  8.70k|        head->prev = current_item;
 1762|  8.70k|    }
 1763|       |
 1764|   404k|    item->type = cJSON_Object;
  ------------------
  |  |   96|   404k|#define cJSON_Object (1 << 6)
  ------------------
 1765|   404k|    item->child = head;
 1766|       |
 1767|   404k|    input_buffer->offset++;
 1768|   404k|    return true;
  ------------------
  |  |   65|   404k|#define true ((cJSON_bool)1)
  ------------------
 1769|       |
 1770|  2.90k|fail:
 1771|  2.90k|    if (head != NULL)
  ------------------
  |  Branch (1771:9): [True: 2.90k, False: 0]
  ------------------
 1772|  2.90k|    {
 1773|  2.90k|        cJSON_Delete(head);
 1774|  2.90k|    }
 1775|       |
 1776|  2.90k|    return false;
  ------------------
  |  |   70|  2.90k|#define false ((cJSON_bool)0)
  ------------------
 1777|  8.74k|}
cJSON.c:print_value:
 1424|   659k|{
 1425|   659k|    unsigned char *output = NULL;
 1426|       |
 1427|   659k|    if ((item == NULL) || (output_buffer == NULL))
  ------------------
  |  Branch (1427:9): [True: 0, False: 659k]
  |  Branch (1427:27): [True: 0, False: 659k]
  ------------------
 1428|      0|    {
 1429|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1430|      0|    }
 1431|       |
 1432|   659k|    switch ((item->type) & 0xFF)
 1433|   659k|    {
 1434|    354|        case cJSON_NULL:
  ------------------
  |  |   92|    354|#define cJSON_NULL   (1 << 2)
  ------------------
  |  Branch (1434:9): [True: 354, False: 658k]
  ------------------
 1435|    354|            output = ensure(output_buffer, 5);
 1436|    354|            if (output == NULL)
  ------------------
  |  Branch (1436:17): [True: 0, False: 354]
  ------------------
 1437|      0|            {
 1438|      0|                return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1439|      0|            }
 1440|    354|            strcpy((char*)output, "null");
 1441|    354|            return true;
  ------------------
  |  |   65|    354|#define true ((cJSON_bool)1)
  ------------------
 1442|       |
 1443|    527|        case cJSON_False:
  ------------------
  |  |   90|    527|#define cJSON_False  (1 << 0)
  ------------------
  |  Branch (1443:9): [True: 527, False: 658k]
  ------------------
 1444|    527|            output = ensure(output_buffer, 6);
 1445|    527|            if (output == NULL)
  ------------------
  |  Branch (1445:17): [True: 0, False: 527]
  ------------------
 1446|      0|            {
 1447|      0|                return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1448|      0|            }
 1449|    527|            strcpy((char*)output, "false");
 1450|    527|            return true;
  ------------------
  |  |   65|    527|#define true ((cJSON_bool)1)
  ------------------
 1451|       |
 1452|  1.81k|        case cJSON_True:
  ------------------
  |  |   91|  1.81k|#define cJSON_True   (1 << 1)
  ------------------
  |  Branch (1452:9): [True: 1.81k, False: 657k]
  ------------------
 1453|  1.81k|            output = ensure(output_buffer, 5);
 1454|  1.81k|            if (output == NULL)
  ------------------
  |  Branch (1454:17): [True: 0, False: 1.81k]
  ------------------
 1455|      0|            {
 1456|      0|                return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1457|      0|            }
 1458|  1.81k|            strcpy((char*)output, "true");
 1459|  1.81k|            return true;
  ------------------
  |  |   65|  1.81k|#define true ((cJSON_bool)1)
  ------------------
 1460|       |
 1461|  16.3k|        case cJSON_Number:
  ------------------
  |  |   93|  16.3k|#define cJSON_Number (1 << 3)
  ------------------
  |  Branch (1461:9): [True: 16.3k, False: 642k]
  ------------------
 1462|  16.3k|            return print_number(item, output_buffer);
 1463|       |
 1464|      0|        case cJSON_Raw:
  ------------------
  |  |   97|      0|#define cJSON_Raw    (1 << 7) /* raw json */
  ------------------
  |  Branch (1464:9): [True: 0, False: 659k]
  ------------------
 1465|      0|        {
 1466|      0|            size_t raw_length = 0;
 1467|      0|            if (item->valuestring == NULL)
  ------------------
  |  Branch (1467:17): [True: 0, False: 0]
  ------------------
 1468|      0|            {
 1469|      0|                return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1470|      0|            }
 1471|       |
 1472|      0|            raw_length = strlen(item->valuestring) + sizeof("");
 1473|      0|            output = ensure(output_buffer, raw_length);
 1474|      0|            if (output == NULL)
  ------------------
  |  Branch (1474:17): [True: 0, False: 0]
  ------------------
 1475|      0|            {
 1476|      0|                return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1477|      0|            }
 1478|      0|            memcpy(output, item->valuestring, raw_length);
 1479|      0|            return true;
  ------------------
  |  |   65|      0|#define true ((cJSON_bool)1)
  ------------------
 1480|      0|        }
 1481|       |
 1482|  2.90k|        case cJSON_String:
  ------------------
  |  |   94|  2.90k|#define cJSON_String (1 << 4)
  ------------------
  |  Branch (1482:9): [True: 2.90k, False: 656k]
  ------------------
 1483|  2.90k|            return print_string(item, output_buffer);
 1484|       |
 1485|   236k|        case cJSON_Array:
  ------------------
  |  |   95|   236k|#define cJSON_Array  (1 << 5)
  ------------------
  |  Branch (1485:9): [True: 236k, False: 422k]
  ------------------
 1486|   236k|            return print_array(item, output_buffer);
 1487|       |
 1488|   400k|        case cJSON_Object:
  ------------------
  |  |   96|   400k|#define cJSON_Object (1 << 6)
  ------------------
  |  Branch (1488:9): [True: 400k, False: 258k]
  ------------------
 1489|   400k|            return print_object(item, output_buffer);
 1490|       |
 1491|      0|        default:
  ------------------
  |  Branch (1491:9): [True: 0, False: 659k]
  ------------------
 1492|      0|            return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1493|   659k|    }
 1494|   659k|}
cJSON.c:ensure:
  491|  1.76M|{
  492|  1.76M|    unsigned char *newbuffer = NULL;
  493|  1.76M|    size_t newsize = 0;
  494|       |
  495|  1.76M|    if ((p == NULL) || (p->buffer == NULL))
  ------------------
  |  Branch (495:9): [True: 0, False: 1.76M]
  |  Branch (495:24): [True: 0, False: 1.76M]
  ------------------
  496|      0|    {
  497|      0|        return NULL;
  498|      0|    }
  499|       |
  500|  1.76M|    if ((p->length > 0) && (p->offset >= p->length))
  ------------------
  |  Branch (500:9): [True: 1.76M, False: 0]
  |  Branch (500:28): [True: 0, False: 1.76M]
  ------------------
  501|      0|    {
  502|       |        /* make sure that offset is valid */
  503|      0|        return NULL;
  504|      0|    }
  505|       |
  506|  1.76M|    if (needed > INT_MAX)
  ------------------
  |  Branch (506:9): [True: 0, False: 1.76M]
  ------------------
  507|      0|    {
  508|       |        /* sizes bigger than INT_MAX are currently not supported */
  509|      0|        return NULL;
  510|      0|    }
  511|       |
  512|  1.76M|    needed += p->offset + 1;
  513|  1.76M|    if (needed <= p->length)
  ------------------
  |  Branch (513:9): [True: 1.76M, False: 1.91k]
  ------------------
  514|  1.76M|    {
  515|  1.76M|        return p->buffer + p->offset;
  516|  1.76M|    }
  517|       |
  518|  1.91k|    if (p->noalloc) {
  ------------------
  |  Branch (518:9): [True: 0, False: 1.91k]
  ------------------
  519|      0|        return NULL;
  520|      0|    }
  521|       |
  522|       |    /* calculate new buffer size */
  523|  1.91k|    if (needed > (INT_MAX / 2))
  ------------------
  |  Branch (523:9): [True: 0, False: 1.91k]
  ------------------
  524|      0|    {
  525|       |        /* overflow of int, use INT_MAX if possible */
  526|      0|        if (needed <= INT_MAX)
  ------------------
  |  Branch (526:13): [True: 0, False: 0]
  ------------------
  527|      0|        {
  528|      0|            newsize = INT_MAX;
  529|      0|        }
  530|      0|        else
  531|      0|        {
  532|      0|            return NULL;
  533|      0|        }
  534|      0|    }
  535|  1.91k|    else
  536|  1.91k|    {
  537|  1.91k|        newsize = needed * 2;
  538|  1.91k|    }
  539|       |
  540|  1.91k|    if (p->hooks.reallocate != NULL)
  ------------------
  |  Branch (540:9): [True: 1.91k, False: 0]
  ------------------
  541|  1.91k|    {
  542|       |        /* reallocate with realloc if available */
  543|  1.91k|        newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize);
  544|  1.91k|        if (newbuffer == NULL)
  ------------------
  |  Branch (544:13): [True: 0, False: 1.91k]
  ------------------
  545|      0|        {
  546|      0|            p->hooks.deallocate(p->buffer);
  547|      0|            p->length = 0;
  548|      0|            p->buffer = NULL;
  549|       |
  550|      0|            return NULL;
  551|      0|        }
  552|  1.91k|    }
  553|      0|    else
  554|      0|    {
  555|       |        /* otherwise reallocate manually */
  556|      0|        newbuffer = (unsigned char*)p->hooks.allocate(newsize);
  557|      0|        if (!newbuffer)
  ------------------
  |  Branch (557:13): [True: 0, False: 0]
  ------------------
  558|      0|        {
  559|      0|            p->hooks.deallocate(p->buffer);
  560|      0|            p->length = 0;
  561|      0|            p->buffer = NULL;
  562|       |
  563|      0|            return NULL;
  564|      0|        }
  565|       |
  566|      0|        memcpy(newbuffer, p->buffer, p->offset + 1);
  567|      0|        p->hooks.deallocate(p->buffer);
  568|      0|    }
  569|  1.91k|    p->length = newsize;
  570|  1.91k|    p->buffer = newbuffer;
  571|       |
  572|  1.91k|    return newbuffer + p->offset;
  573|  1.91k|}
cJSON.c:print_number:
  597|  16.3k|{
  598|  16.3k|    unsigned char *output_pointer = NULL;
  599|  16.3k|    double d = item->valuedouble;
  600|  16.3k|    int length = 0;
  601|  16.3k|    size_t i = 0;
  602|  16.3k|    unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */
  603|  16.3k|    unsigned char decimal_point = get_decimal_point();
  604|  16.3k|    double test = 0.0;
  605|       |
  606|  16.3k|    if (output_buffer == NULL)
  ------------------
  |  Branch (606:9): [True: 0, False: 16.3k]
  ------------------
  607|      0|    {
  608|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
  609|      0|    }
  610|       |
  611|       |    /* This checks for NaN and Infinity */
  612|  16.3k|    if (isnan(d) || isinf(d))
  ------------------
  |  |   77|  32.7k|#define isnan(d) (d != d)
  |  |  ------------------
  |  |  |  Branch (77:18): [True: 0, False: 16.3k]
  |  |  ------------------
  ------------------
                  if (isnan(d) || isinf(d))
  ------------------
  |  |   74|  16.3k|#define isinf(d) (isnan((d - d)) && !isnan(d))
  |  |  ------------------
  |  |  |  |   77|  32.7k|#define isnan(d) (d != d)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (77:18): [True: 914, False: 15.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |               #define isinf(d) (isnan((d - d)) && !isnan(d))
  |  |  ------------------
  |  |  |  |   77|    914|#define isnan(d) (d != d)
  |  |  ------------------
  |  |  |  Branch (74:37): [True: 914, False: 0]
  |  |  ------------------
  ------------------
  613|    914|    {
  614|    914|        length = sprintf((char*)number_buffer, "null");
  615|    914|    }
  616|  15.4k|    else if(d == (double)item->valueint)
  ------------------
  |  Branch (616:13): [True: 14.0k, False: 1.38k]
  ------------------
  617|  14.0k|    {
  618|  14.0k|        length = sprintf((char*)number_buffer, "%d", item->valueint);
  619|  14.0k|    }
  620|  1.38k|    else
  621|  1.38k|    {
  622|       |        /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */
  623|  1.38k|        length = sprintf((char*)number_buffer, "%1.15g", d);
  624|       |
  625|       |        /* Check whether the original double can be recovered */
  626|  1.38k|        if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d))
  ------------------
  |  Branch (626:13): [True: 0, False: 1.38k]
  |  Branch (626:66): [True: 678, False: 709]
  ------------------
  627|    678|        {
  628|       |            /* If not, print with 17 decimal places of precision */
  629|    678|            length = sprintf((char*)number_buffer, "%1.17g", d);
  630|    678|        }
  631|  1.38k|    }
  632|       |
  633|       |    /* sprintf failed or buffer overrun occurred */
  634|  16.3k|    if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1)))
  ------------------
  |  Branch (634:9): [True: 0, False: 16.3k]
  |  Branch (634:25): [True: 0, False: 16.3k]
  ------------------
  635|      0|    {
  636|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
  637|      0|    }
  638|       |
  639|       |    /* reserve appropriate space in the output */
  640|  16.3k|    output_pointer = ensure(output_buffer, (size_t)length + sizeof(""));
  641|  16.3k|    if (output_pointer == NULL)
  ------------------
  |  Branch (641:9): [True: 0, False: 16.3k]
  ------------------
  642|      0|    {
  643|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
  644|      0|    }
  645|       |
  646|       |    /* copy the printed number to the output and replace locale
  647|       |     * dependent decimal point with '.' */
  648|  52.0k|    for (i = 0; i < ((size_t)length); i++)
  ------------------
  |  Branch (648:17): [True: 35.6k, False: 16.3k]
  ------------------
  649|  35.6k|    {
  650|  35.6k|        if (number_buffer[i] == decimal_point)
  ------------------
  |  Branch (650:13): [True: 448, False: 35.2k]
  ------------------
  651|    448|        {
  652|    448|            output_pointer[i] = '.';
  653|    448|            continue;
  654|    448|        }
  655|       |
  656|  35.2k|        output_pointer[i] = number_buffer[i];
  657|  35.2k|    }
  658|  16.3k|    output_pointer[i] = '\0';
  659|       |
  660|  16.3k|    output_buffer->offset += (size_t)length;
  661|       |
  662|  16.3k|    return true;
  ------------------
  |  |   65|  16.3k|#define true ((cJSON_bool)1)
  ------------------
  663|  16.3k|}
cJSON.c:print_string:
 1077|  2.90k|{
 1078|  2.90k|    return print_string_ptr((unsigned char*)item->valuestring, p);
 1079|  2.90k|}
cJSON.c:print_string_ptr:
  955|  19.4k|{
  956|  19.4k|    const unsigned char *input_pointer = NULL;
  957|  19.4k|    unsigned char *output = NULL;
  958|  19.4k|    unsigned char *output_pointer = NULL;
  959|  19.4k|    size_t output_length = 0;
  960|       |    /* numbers of additional characters needed for escaping */
  961|  19.4k|    size_t escape_characters = 0;
  962|       |
  963|  19.4k|    if (output_buffer == NULL)
  ------------------
  |  Branch (963:9): [True: 0, False: 19.4k]
  ------------------
  964|      0|    {
  965|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
  966|      0|    }
  967|       |
  968|       |    /* empty string */
  969|  19.4k|    if (input == NULL)
  ------------------
  |  Branch (969:9): [True: 0, False: 19.4k]
  ------------------
  970|      0|    {
  971|      0|        output = ensure(output_buffer, sizeof("\"\""));
  972|      0|        if (output == NULL)
  ------------------
  |  Branch (972:13): [True: 0, False: 0]
  ------------------
  973|      0|        {
  974|      0|            return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
  975|      0|        }
  976|      0|        strcpy((char*)output, "\"\"");
  977|       |
  978|      0|        return true;
  ------------------
  |  |   65|      0|#define true ((cJSON_bool)1)
  ------------------
  979|      0|    }
  980|       |
  981|       |    /* set "flag" to 1 if something needs to be escaped */
  982|  10.5M|    for (input_pointer = input; *input_pointer; input_pointer++)
  ------------------
  |  Branch (982:33): [True: 10.5M, False: 19.4k]
  ------------------
  983|  10.5M|    {
  984|  10.5M|        switch (*input_pointer)
  985|  10.5M|        {
  986|  2.33k|            case '\"':
  ------------------
  |  Branch (986:13): [True: 2.33k, False: 10.5M]
  ------------------
  987|  3.85k|            case '\\':
  ------------------
  |  Branch (987:13): [True: 1.51k, False: 10.5M]
  ------------------
  988|  12.6k|            case '\b':
  ------------------
  |  Branch (988:13): [True: 8.77k, False: 10.5M]
  ------------------
  989|  27.3k|            case '\f':
  ------------------
  |  Branch (989:13): [True: 14.7k, False: 10.5M]
  ------------------
  990|  82.2k|            case '\n':
  ------------------
  |  Branch (990:13): [True: 54.8k, False: 10.5M]
  ------------------
  991|  88.4k|            case '\r':
  ------------------
  |  Branch (991:13): [True: 6.18k, False: 10.5M]
  ------------------
  992|   242k|            case '\t':
  ------------------
  |  Branch (992:13): [True: 153k, False: 10.4M]
  ------------------
  993|       |                /* one character escape sequence */
  994|   242k|                escape_characters++;
  995|   242k|                break;
  996|  10.3M|            default:
  ------------------
  |  Branch (996:13): [True: 10.3M, False: 242k]
  ------------------
  997|  10.3M|                if (*input_pointer < 32)
  ------------------
  |  Branch (997:21): [True: 7.97M, False: 2.35M]
  ------------------
  998|  7.97M|                {
  999|       |                    /* UTF-16 escape sequence uXXXX */
 1000|  7.97M|                    escape_characters += 5;
 1001|  7.97M|                }
 1002|  10.3M|                break;
 1003|  10.5M|        }
 1004|  10.5M|    }
 1005|  19.4k|    output_length = (size_t)(input_pointer - input) + escape_characters;
 1006|       |
 1007|  19.4k|    output = ensure(output_buffer, output_length + sizeof("\"\""));
 1008|  19.4k|    if (output == NULL)
  ------------------
  |  Branch (1008:9): [True: 0, False: 19.4k]
  ------------------
 1009|      0|    {
 1010|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1011|      0|    }
 1012|       |
 1013|       |    /* no characters have to be escaped */
 1014|  19.4k|    if (escape_characters == 0)
  ------------------
  |  Branch (1014:9): [True: 16.4k, False: 2.99k]
  ------------------
 1015|  16.4k|    {
 1016|  16.4k|        output[0] = '\"';
 1017|  16.4k|        memcpy(output + 1, input, output_length);
 1018|  16.4k|        output[output_length + 1] = '\"';
 1019|  16.4k|        output[output_length + 2] = '\0';
 1020|       |
 1021|  16.4k|        return true;
  ------------------
  |  |   65|  16.4k|#define true ((cJSON_bool)1)
  ------------------
 1022|  16.4k|    }
 1023|       |
 1024|  2.99k|    output[0] = '\"';
 1025|  2.99k|    output_pointer = output + 1;
 1026|       |    /* copy the string */
 1027|  10.5M|    for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++)
  ------------------
  |  Branch (1027:33): [True: 10.5M, False: 2.99k]
  ------------------
 1028|  10.5M|    {
 1029|  10.5M|        if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\'))
  ------------------
  |  Branch (1029:13): [True: 2.33M, False: 8.21M]
  |  Branch (1029:38): [True: 2.33M, False: 2.33k]
  |  Branch (1029:66): [True: 2.33M, False: 1.51k]
  ------------------
 1030|  2.33M|        {
 1031|       |            /* normal character, copy */
 1032|  2.33M|            *output_pointer = *input_pointer;
 1033|  2.33M|        }
 1034|  8.21M|        else
 1035|  8.21M|        {
 1036|       |            /* character needs to be escaped */
 1037|  8.21M|            *output_pointer++ = '\\';
 1038|  8.21M|            switch (*input_pointer)
 1039|  8.21M|            {
 1040|  1.51k|                case '\\':
  ------------------
  |  Branch (1040:17): [True: 1.51k, False: 8.21M]
  ------------------
 1041|  1.51k|                    *output_pointer = '\\';
 1042|  1.51k|                    break;
 1043|  2.33k|                case '\"':
  ------------------
  |  Branch (1043:17): [True: 2.33k, False: 8.21M]
  ------------------
 1044|  2.33k|                    *output_pointer = '\"';
 1045|  2.33k|                    break;
 1046|  8.77k|                case '\b':
  ------------------
  |  Branch (1046:17): [True: 8.77k, False: 8.20M]
  ------------------
 1047|  8.77k|                    *output_pointer = 'b';
 1048|  8.77k|                    break;
 1049|  14.7k|                case '\f':
  ------------------
  |  Branch (1049:17): [True: 14.7k, False: 8.19M]
  ------------------
 1050|  14.7k|                    *output_pointer = 'f';
 1051|  14.7k|                    break;
 1052|  54.8k|                case '\n':
  ------------------
  |  Branch (1052:17): [True: 54.8k, False: 8.15M]
  ------------------
 1053|  54.8k|                    *output_pointer = 'n';
 1054|  54.8k|                    break;
 1055|  6.18k|                case '\r':
  ------------------
  |  Branch (1055:17): [True: 6.18k, False: 8.20M]
  ------------------
 1056|  6.18k|                    *output_pointer = 'r';
 1057|  6.18k|                    break;
 1058|   153k|                case '\t':
  ------------------
  |  Branch (1058:17): [True: 153k, False: 8.06M]
  ------------------
 1059|   153k|                    *output_pointer = 't';
 1060|   153k|                    break;
 1061|  7.97M|                default:
  ------------------
  |  Branch (1061:17): [True: 7.97M, False: 242k]
  ------------------
 1062|       |                    /* escape and print as unicode codepoint */
 1063|  7.97M|                    sprintf((char*)output_pointer, "u%04x", *input_pointer);
 1064|  7.97M|                    output_pointer += 4;
 1065|  7.97M|                    break;
 1066|  8.21M|            }
 1067|  8.21M|        }
 1068|  10.5M|    }
 1069|  2.99k|    output[output_length + 1] = '\"';
 1070|  2.99k|    output[output_length + 2] = '\0';
 1071|       |
 1072|  2.99k|    return true;
  ------------------
  |  |   65|  2.99k|#define true ((cJSON_bool)1)
  ------------------
 1073|  2.99k|}
cJSON.c:print_array:
 1596|   236k|{
 1597|   236k|    unsigned char *output_pointer = NULL;
 1598|   236k|    size_t length = 0;
 1599|   236k|    cJSON *current_element = item->child;
 1600|       |
 1601|   236k|    if (output_buffer == NULL)
  ------------------
  |  Branch (1601:9): [True: 0, False: 236k]
  ------------------
 1602|      0|    {
 1603|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1604|      0|    }
 1605|       |
 1606|   236k|    if (output_buffer->depth >= CJSON_NESTING_LIMIT)
  ------------------
  |  |  137|   236k|#define CJSON_NESTING_LIMIT 1000
  ------------------
  |  Branch (1606:9): [True: 0, False: 236k]
  ------------------
 1607|      0|    {
 1608|      0|        return false; /* nesting is too deep */
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1609|      0|    }
 1610|       |
 1611|       |    /* Compose the output array. */
 1612|       |    /* opening square bracket */
 1613|   236k|    output_pointer = ensure(output_buffer, 1);
 1614|   236k|    if (output_pointer == NULL)
  ------------------
  |  Branch (1614:9): [True: 0, False: 236k]
  ------------------
 1615|      0|    {
 1616|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1617|      0|    }
 1618|       |
 1619|   236k|    *output_pointer = '[';
 1620|   236k|    output_buffer->offset++;
 1621|   236k|    output_buffer->depth++;
 1622|       |
 1623|   878k|    while (current_element != NULL)
  ------------------
  |  Branch (1623:12): [True: 641k, False: 236k]
  ------------------
 1624|   641k|    {
 1625|   641k|        if (!print_value(current_element, output_buffer))
  ------------------
  |  Branch (1625:13): [True: 0, False: 641k]
  ------------------
 1626|      0|        {
 1627|      0|            return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1628|      0|        }
 1629|   641k|        update_offset(output_buffer);
 1630|   641k|        if (current_element->next)
  ------------------
  |  Branch (1630:13): [True: 407k, False: 234k]
  ------------------
 1631|   407k|        {
 1632|   407k|            length = (size_t) (output_buffer->format ? 2 : 1);
  ------------------
  |  Branch (1632:32): [True: 397k, False: 9.62k]
  ------------------
 1633|   407k|            output_pointer = ensure(output_buffer, length + 1);
 1634|   407k|            if (output_pointer == NULL)
  ------------------
  |  Branch (1634:17): [True: 0, False: 407k]
  ------------------
 1635|      0|            {
 1636|      0|                return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1637|      0|            }
 1638|   407k|            *output_pointer++ = ',';
 1639|   407k|            if(output_buffer->format)
  ------------------
  |  Branch (1639:16): [True: 397k, False: 9.62k]
  ------------------
 1640|   397k|            {
 1641|   397k|                *output_pointer++ = ' ';
 1642|   397k|            }
 1643|   407k|            *output_pointer = '\0';
 1644|   407k|            output_buffer->offset += length;
 1645|   407k|        }
 1646|   641k|        current_element = current_element->next;
 1647|   641k|    }
 1648|       |
 1649|   236k|    output_pointer = ensure(output_buffer, 2);
 1650|   236k|    if (output_pointer == NULL)
  ------------------
  |  Branch (1650:9): [True: 0, False: 236k]
  ------------------
 1651|      0|    {
 1652|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1653|      0|    }
 1654|   236k|    *output_pointer++ = ']';
 1655|   236k|    *output_pointer = '\0';
 1656|   236k|    output_buffer->depth--;
 1657|       |
 1658|   236k|    return true;
  ------------------
  |  |   65|   236k|#define true ((cJSON_bool)1)
  ------------------
 1659|   236k|}
cJSON.c:print_object:
 1781|   400k|{
 1782|   400k|    unsigned char *output_pointer = NULL;
 1783|   400k|    size_t length = 0;
 1784|   400k|    cJSON *current_item = item->child;
 1785|       |
 1786|   400k|    if (output_buffer == NULL)
  ------------------
  |  Branch (1786:9): [True: 0, False: 400k]
  ------------------
 1787|      0|    {
 1788|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1789|      0|    }
 1790|       |
 1791|   400k|    if (output_buffer->depth >= CJSON_NESTING_LIMIT)
  ------------------
  |  |  137|   400k|#define CJSON_NESTING_LIMIT 1000
  ------------------
  |  Branch (1791:9): [True: 0, False: 400k]
  ------------------
 1792|      0|    {
 1793|      0|        return false; /* nesting is too deep */
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1794|      0|    }
 1795|       |
 1796|       |    /* Compose the output: */
 1797|   400k|    length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */
  ------------------
  |  Branch (1797:24): [True: 399k, False: 501]
  ------------------
 1798|   400k|    output_pointer = ensure(output_buffer, length + 1);
 1799|   400k|    if (output_pointer == NULL)
  ------------------
  |  Branch (1799:9): [True: 0, False: 400k]
  ------------------
 1800|      0|    {
 1801|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1802|      0|    }
 1803|       |
 1804|   400k|    *output_pointer++ = '{';
 1805|   400k|    output_buffer->depth++;
 1806|   400k|    if (output_buffer->format)
  ------------------
  |  Branch (1806:9): [True: 399k, False: 501]
  ------------------
 1807|   399k|    {
 1808|   399k|        *output_pointer++ = '\n';
 1809|   399k|    }
 1810|   400k|    output_buffer->offset += length;
 1811|       |
 1812|   416k|    while (current_item)
  ------------------
  |  Branch (1812:12): [True: 16.5k, False: 400k]
  ------------------
 1813|  16.5k|    {
 1814|  16.5k|        if (output_buffer->format)
  ------------------
  |  Branch (1814:13): [True: 11.5k, False: 5.02k]
  ------------------
 1815|  11.5k|        {
 1816|  11.5k|            size_t i;
 1817|  11.5k|            output_pointer = ensure(output_buffer, output_buffer->depth);
 1818|  11.5k|            if (output_pointer == NULL)
  ------------------
  |  Branch (1818:17): [True: 0, False: 11.5k]
  ------------------
 1819|      0|            {
 1820|      0|                return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1821|      0|            }
 1822|  4.11M|            for (i = 0; i < output_buffer->depth; i++)
  ------------------
  |  Branch (1822:25): [True: 4.10M, False: 11.5k]
  ------------------
 1823|  4.10M|            {
 1824|  4.10M|                *output_pointer++ = '\t';
 1825|  4.10M|            }
 1826|  11.5k|            output_buffer->offset += output_buffer->depth;
 1827|  11.5k|        }
 1828|       |
 1829|       |        /* print key */
 1830|  16.5k|        if (!print_string_ptr((unsigned char*)current_item->string, output_buffer))
  ------------------
  |  Branch (1830:13): [True: 0, False: 16.5k]
  ------------------
 1831|      0|        {
 1832|      0|            return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1833|      0|        }
 1834|  16.5k|        update_offset(output_buffer);
 1835|       |
 1836|  16.5k|        length = (size_t) (output_buffer->format ? 2 : 1);
  ------------------
  |  Branch (1836:28): [True: 11.5k, False: 5.02k]
  ------------------
 1837|  16.5k|        output_pointer = ensure(output_buffer, length);
 1838|  16.5k|        if (output_pointer == NULL)
  ------------------
  |  Branch (1838:13): [True: 0, False: 16.5k]
  ------------------
 1839|      0|        {
 1840|      0|            return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1841|      0|        }
 1842|  16.5k|        *output_pointer++ = ':';
 1843|  16.5k|        if (output_buffer->format)
  ------------------
  |  Branch (1843:13): [True: 11.5k, False: 5.02k]
  ------------------
 1844|  11.5k|        {
 1845|  11.5k|            *output_pointer++ = '\t';
 1846|  11.5k|        }
 1847|  16.5k|        output_buffer->offset += length;
 1848|       |
 1849|       |        /* print value */
 1850|  16.5k|        if (!print_value(current_item, output_buffer))
  ------------------
  |  Branch (1850:13): [True: 0, False: 16.5k]
  ------------------
 1851|      0|        {
 1852|      0|            return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1853|      0|        }
 1854|  16.5k|        update_offset(output_buffer);
 1855|       |
 1856|       |        /* print comma if not last */
 1857|  16.5k|        length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0));
  ------------------
  |  Branch (1857:28): [True: 11.5k, False: 5.02k]
  |  Branch (1857:70): [True: 8.10k, False: 8.47k]
  ------------------
 1858|  16.5k|        output_pointer = ensure(output_buffer, length + 1);
 1859|  16.5k|        if (output_pointer == NULL)
  ------------------
  |  Branch (1859:13): [True: 0, False: 16.5k]
  ------------------
 1860|      0|        {
 1861|      0|            return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1862|      0|        }
 1863|  16.5k|        if (current_item->next)
  ------------------
  |  Branch (1863:13): [True: 8.10k, False: 8.47k]
  ------------------
 1864|  8.10k|        {
 1865|  8.10k|            *output_pointer++ = ',';
 1866|  8.10k|        }
 1867|       |
 1868|  16.5k|        if (output_buffer->format)
  ------------------
  |  Branch (1868:13): [True: 11.5k, False: 5.02k]
  ------------------
 1869|  11.5k|        {
 1870|  11.5k|            *output_pointer++ = '\n';
 1871|  11.5k|        }
 1872|  16.5k|        *output_pointer = '\0';
 1873|  16.5k|        output_buffer->offset += length;
 1874|       |
 1875|  16.5k|        current_item = current_item->next;
 1876|  16.5k|    }
 1877|       |
 1878|   400k|    output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2);
  ------------------
  |  Branch (1878:44): [True: 399k, False: 501]
  ------------------
 1879|   400k|    if (output_pointer == NULL)
  ------------------
  |  Branch (1879:9): [True: 0, False: 400k]
  ------------------
 1880|      0|    {
 1881|      0|        return false;
  ------------------
  |  |   70|      0|#define false ((cJSON_bool)0)
  ------------------
 1882|      0|    }
 1883|   400k|    if (output_buffer->format)
  ------------------
  |  Branch (1883:9): [True: 399k, False: 501]
  ------------------
 1884|   399k|    {
 1885|   399k|        size_t i;
 1886|   220M|        for (i = 0; i < (output_buffer->depth - 1); i++)
  ------------------
  |  Branch (1886:21): [True: 219M, False: 399k]
  ------------------
 1887|   219M|        {
 1888|   219M|            *output_pointer++ = '\t';
 1889|   219M|        }
 1890|   399k|    }
 1891|   400k|    *output_pointer++ = '}';
 1892|   400k|    *output_pointer = '\0';
 1893|   400k|    output_buffer->depth--;
 1894|       |
 1895|   400k|    return true;
  ------------------
  |  |   65|   400k|#define true ((cJSON_bool)1)
  ------------------
 1896|   400k|}
cJSON.c:skip_oneline_comment:
 2876|  2.16k|{
 2877|  2.16k|    *input += static_strlen("//");
  ------------------
  |  |  184|  2.16k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2878|       |
 2879|  50.1k|    for (; (*input)[0] != '\0'; ++(*input))
  ------------------
  |  Branch (2879:12): [True: 50.1k, False: 20]
  ------------------
 2880|  50.1k|    {
 2881|  50.1k|        if ((*input)[0] == '\n') {
  ------------------
  |  Branch (2881:13): [True: 2.14k, False: 48.0k]
  ------------------
 2882|  2.14k|            *input += static_strlen("\n");
  ------------------
  |  |  184|  2.14k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2883|  2.14k|            return;
 2884|  2.14k|        }
 2885|  50.1k|    }
 2886|  2.16k|}
cJSON.c:skip_multiline_comment:
 2889|    310|{
 2890|    310|    *input += static_strlen("/*");
  ------------------
  |  |  184|    310|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2891|       |
 2892|  2.26k|    for (; (*input)[0] != '\0'; ++(*input))
  ------------------
  |  Branch (2892:12): [True: 2.22k, False: 43]
  ------------------
 2893|  2.22k|    {
 2894|  2.22k|        if (((*input)[0] == '*') && ((*input)[1] == '/'))
  ------------------
  |  Branch (2894:13): [True: 600, False: 1.62k]
  |  Branch (2894:37): [True: 267, False: 333]
  ------------------
 2895|    267|        {
 2896|    267|            *input += static_strlen("*/");
  ------------------
  |  |  184|    267|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2897|    267|            return;
 2898|    267|        }
 2899|  2.22k|    }
 2900|    310|}
cJSON.c:minify_string:
 2902|  19.4k|static void minify_string(char **input, char **output) {
 2903|  19.4k|    (*output)[0] = (*input)[0];
 2904|  19.4k|    *input += static_strlen("\"");
  ------------------
  |  |  184|  19.4k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2905|  19.4k|    *output += static_strlen("\"");
  ------------------
  |  |  184|  19.4k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2906|       |
 2907|       |
 2908|  10.3M|    for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) {
  ------------------
  |  Branch (2908:12): [True: 10.3M, False: 41]
  ------------------
 2909|  10.3M|        (*output)[0] = (*input)[0];
 2910|       |
 2911|  10.3M|        if ((*input)[0] == '\"') {
  ------------------
  |  Branch (2911:13): [True: 19.4k, False: 10.3M]
  ------------------
 2912|  19.4k|            (*output)[0] = '\"';
 2913|  19.4k|            *input += static_strlen("\"");
  ------------------
  |  |  184|  19.4k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2914|  19.4k|            *output += static_strlen("\"");
  ------------------
  |  |  184|  19.4k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2915|  19.4k|            return;
 2916|  10.3M|        } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) {
  ------------------
  |  Branch (2916:20): [True: 33.6k, False: 10.3M]
  |  Branch (2916:45): [True: 2.71k, False: 30.9k]
  ------------------
 2917|  2.71k|            (*output)[1] = (*input)[1];
 2918|  2.71k|            *input += static_strlen("\"");
  ------------------
  |  |  184|  2.71k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2919|  2.71k|            *output += static_strlen("\"");
  ------------------
  |  |  184|  2.71k|#define static_strlen(string_literal) (sizeof(string_literal) - sizeof(""))
  ------------------
 2920|  2.71k|        }
 2921|  10.3M|    }
 2922|  19.4k|}
cJSON.c:compare_double:
  590|  1.38k|{
  591|  1.38k|    double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b);
  ------------------
  |  Branch (591:21): [True: 642, False: 745]
  ------------------
  592|       |    return (fabs(a - b) <= maxVal * DBL_EPSILON);
  593|  1.38k|}

LLVMFuzzerTestOneInput:
   14|  2.08k|{
   15|  2.08k|    cJSON *json;
   16|  2.08k|    size_t offset = 4;
   17|  2.08k|    unsigned char *copied;
   18|  2.08k|    char *printed_json = NULL;
   19|  2.08k|    int minify, require_termination, formatted, buffered;
   20|       |
   21|       |
   22|  2.08k|    if(size <= offset) return 0;
  ------------------
  |  Branch (22:8): [True: 4, False: 2.07k]
  ------------------
   23|  2.07k|    if(data[size-1] != '\0') return 0;
  ------------------
  |  Branch (23:8): [True: 10, False: 2.06k]
  ------------------
   24|  2.06k|    if(data[0] != '1' && data[0] != '0') return 0;
  ------------------
  |  Branch (24:8): [True: 402, False: 1.66k]
  |  Branch (24:26): [True: 17, False: 385]
  ------------------
   25|  2.05k|    if(data[1] != '1' && data[1] != '0') return 0;
  ------------------
  |  Branch (25:8): [True: 1.40k, False: 651]
  |  Branch (25:26): [True: 13, False: 1.38k]
  ------------------
   26|  2.03k|    if(data[2] != '1' && data[2] != '0') return 0;
  ------------------
  |  Branch (26:8): [True: 1.03k, False: 1.00k]
  |  Branch (26:26): [True: 14, False: 1.02k]
  ------------------
   27|  2.02k|    if(data[3] != '1' && data[3] != '0') return 0;
  ------------------
  |  Branch (27:8): [True: 989, False: 1.03k]
  |  Branch (27:26): [True: 12, False: 977]
  ------------------
   28|       |
   29|  2.01k|    minify              = data[0] == '1' ? 1 : 0;
  ------------------
  |  Branch (29:27): [True: 1.64k, False: 370]
  ------------------
   30|  2.01k|    require_termination = data[1] == '1' ? 1 : 0;
  ------------------
  |  Branch (30:27): [True: 642, False: 1.37k]
  ------------------
   31|  2.01k|    formatted           = data[2] == '1' ? 1 : 0;
  ------------------
  |  Branch (31:27): [True: 1.00k, False: 1.01k]
  ------------------
   32|  2.01k|    buffered            = data[3] == '1' ? 1 : 0;
  ------------------
  |  Branch (32:27): [True: 1.03k, False: 977]
  ------------------
   33|       |
   34|  2.01k|    json = cJSON_ParseWithOpts((const char*)data + offset, NULL, require_termination);
   35|       |
   36|  2.01k|    if(json == NULL) return 0;
  ------------------
  |  Branch (36:8): [True: 918, False: 1.09k]
  ------------------
   37|       |
   38|  1.09k|    if(buffered)
  ------------------
  |  Branch (38:8): [True: 575, False: 520]
  ------------------
   39|    575|    {
   40|    575|        printed_json = cJSON_PrintBuffered(json, 1, formatted);
   41|    575|    }
   42|    520|    else
   43|    520|    {
   44|       |        /* unbuffered printing */
   45|    520|        if(formatted)
  ------------------
  |  Branch (45:12): [True: 248, False: 272]
  ------------------
   46|    248|        {
   47|    248|            printed_json = cJSON_Print(json);
   48|    248|        }
   49|    272|        else
   50|    272|        {
   51|    272|            printed_json = cJSON_PrintUnformatted(json);
   52|    272|        }
   53|    520|    }
   54|       |
   55|  1.09k|    if(printed_json != NULL) free(printed_json);
  ------------------
  |  Branch (55:8): [True: 1.09k, False: 0]
  ------------------
   56|       |
   57|  1.09k|    if(minify)
  ------------------
  |  Branch (57:8): [True: 921, False: 174]
  ------------------
   58|    921|    {
   59|    921|        copied = (unsigned char*)malloc(size);
   60|    921|        if(copied == NULL) return 0;
  ------------------
  |  Branch (60:12): [True: 0, False: 921]
  ------------------
   61|       |
   62|    921|        memcpy(copied, data, size);
   63|       |
   64|    921|        cJSON_Minify((char*)copied + offset);
   65|       |
   66|    921|        free(copied);
   67|    921|    }
   68|       |
   69|  1.09k|    cJSON_Delete(json);
   70|       |
   71|  1.09k|    return 0;
   72|  1.09k|}

