LLVMFuzzerTestOneInput:
   51|  1.07k|{
   52|  1.07k|  if (size > MAXDATASIZE)	/* same as max_len = <MAXDATASIZE> in .options file */
  ------------------
  |  |   47|  1.07k|#define MAXDATASIZE (100 * sizeof(struct fuzz_elem))
  ------------------
  |  Branch (52:7): [True: 8, False: 1.06k]
  ------------------
   53|      8|    return 0;
   54|       |
   55|  1.06k|  struct fuzz_elem *elem = (struct fuzz_elem *) malloc (size);
   56|  1.06k|  assert (elem != NULL);
   57|      0|  memcpy (elem, data, size);
   58|       |
   59|  1.06k|  int nelem = size / sizeof (struct fuzz_elem);
   60|  1.06k|  asn1_static_node tab[MAXELEM + 1];	/* avoid VLA here */
   61|  1.06k|  int it;
   62|       |
   63|  9.44k|  for (it = 0; it < nelem; it++)
  ------------------
  |  Branch (63:16): [True: 8.38k, False: 1.06k]
  ------------------
   64|  8.38k|    {
   65|  8.38k|      tab[it].type = elem[it].type;
   66|  8.38k|      elem[it].name[NAMESIZE - 1] = 0;
  ------------------
  |  |   37|  8.38k|#define NAMESIZE  20
  ------------------
   67|  8.38k|      if (strcmp (elem[it].name, "NULL"))
  ------------------
  |  Branch (67:11): [True: 8.24k, False: 138]
  ------------------
   68|  8.24k|	tab[it].name = elem[it].name;
   69|    138|      else
   70|    138|	tab[it].name = NULL;
   71|  8.38k|      elem[it].value[VALUESIZE - 1] = 0;
  ------------------
  |  |   38|  8.38k|#define VALUESIZE 20
  ------------------
   72|  8.38k|      if (strcmp (elem[it].value, "NULL"))
  ------------------
  |  Branch (72:11): [True: 7.48k, False: 901]
  ------------------
   73|  7.48k|	tab[it].value = elem[it].value;
   74|    901|      else
   75|    901|	tab[it].value = NULL;
   76|  8.38k|    }
   77|       |
   78|       |  /* end-of-array indicator */
   79|  1.06k|  tab[nelem].type = 0;
   80|  1.06k|  tab[nelem].name = NULL;
   81|  1.06k|  tab[nelem].value = NULL;
   82|       |
   83|  1.06k|  int result;
   84|  1.06k|  asn1_node node = NULL;
   85|  1.06k|  char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
   86|       |
   87|  1.06k|  result = asn1_array2tree (tab, &node, errorDescription);
   88|       |
   89|  1.06k|  if (result == ASN1_SUCCESS)
  ------------------
  |  |  116|  1.06k|# define ASN1_SUCCESS			0
  ------------------
  |  Branch (89:7): [True: 500, False: 564]
  ------------------
   90|    500|    asn1_delete_structure (&node);
   91|       |
   92|  1.06k|  free (elem);
   93|       |
   94|  1.06k|  return 0;
   95|  1.07k|}

asn1_length_der:
   76|    599|{
   77|    599|  int k;
   78|    599|  unsigned char temp[ASN1_MAX_LENGTH_SIZE];
   79|       |#if SIZEOF_UNSIGNED_LONG_INT > 8
   80|       |  len &= 0xFFFFFFFFFFFFFFFF;
   81|       |#endif
   82|       |
   83|    599|  if (len < 128)
  ------------------
  |  Branch (83:7): [True: 599, False: 0]
  ------------------
   84|    599|    {
   85|       |      /* short form */
   86|    599|      if (der != NULL)
  ------------------
  |  Branch (86:11): [True: 599, False: 0]
  ------------------
   87|    599|	der[0] = (unsigned char) len;
   88|    599|      *der_len = 1;
   89|    599|    }
   90|      0|  else
   91|      0|    {
   92|       |      /* Long form */
   93|      0|      k = 0;
   94|      0|      while (len)
  ------------------
  |  Branch (94:14): [True: 0, False: 0]
  ------------------
   95|      0|	{
   96|      0|	  temp[k++] = len & 0xFF;
   97|      0|	  len = len >> 8;
   98|      0|	}
   99|      0|      *der_len = k + 1;
  100|      0|      if (der != NULL)
  ------------------
  |  Branch (100:11): [True: 0, False: 0]
  ------------------
  101|      0|	{
  102|      0|	  der[0] = ((unsigned char) k & 0x7F) + 128;
  103|      0|	  while (k--)
  ------------------
  |  Branch (103:11): [True: 0, False: 0]
  ------------------
  104|      0|	    der[*der_len - 1 - k] = temp[k];
  105|      0|	}
  106|      0|    }
  107|    599|}
asn1_octet_der:
  175|    599|{
  176|    599|  int len_len;
  177|       |
  178|    599|  if (der == NULL || str_len < 0)
  ------------------
  |  Branch (178:7): [True: 0, False: 599]
  |  Branch (178:22): [True: 0, False: 599]
  ------------------
  179|      0|    return;
  180|       |
  181|    599|  asn1_length_der (str_len, der, &len_len);
  182|    599|  memcpy (der + len_len, str, str_len);
  183|    599|  *der_len = str_len + len_len;
  184|    599|}

_asn1_convert_integer:
   80|    599|{
   81|    599|  char negative;
   82|    599|  unsigned char val[SIZEOF_UNSIGNED_LONG_INT];
   83|    599|  long valtmp;
   84|    599|  int k, k2;
   85|       |
   86|    599|  valtmp = _asn1_strtol (value, NULL, 10);
  ------------------
  |  |  114|    599|# define _asn1_strtol(n,e,b) strtol((const char *) n, e, b)
  ------------------
   87|       |
   88|  5.39k|  for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT; k++)
  ------------------
  |  |  635|  5.39k|#define SIZEOF_UNSIGNED_LONG_INT 8
  ------------------
  |  Branch (88:15): [True: 4.79k, False: 599]
  ------------------
   89|  4.79k|    {
   90|  4.79k|      val[SIZEOF_UNSIGNED_LONG_INT - k - 1] = (valtmp >> (8 * k)) & 0xFF;
  ------------------
  |  |  635|  4.79k|#define SIZEOF_UNSIGNED_LONG_INT 8
  ------------------
   91|  4.79k|    }
   92|       |
   93|    599|  if (val[0] & 0x80)
  ------------------
  |  Branch (93:7): [True: 219, False: 380]
  ------------------
   94|    219|    negative = 1;
   95|    380|  else
   96|    380|    negative = 0;
   97|       |
   98|  3.43k|  for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT - 1; k++)
  ------------------
  |  |  635|  3.43k|#define SIZEOF_UNSIGNED_LONG_INT 8
  ------------------
  |  Branch (98:15): [True: 3.23k, False: 198]
  ------------------
   99|  3.23k|    {
  100|  3.23k|      if (negative && (val[k] != 0xFF))
  ------------------
  |  Branch (100:11): [True: 1.37k, False: 1.86k]
  |  Branch (100:23): [True: 162, False: 1.20k]
  ------------------
  101|    162|	break;
  102|  3.07k|      else if (!negative && val[k])
  ------------------
  |  Branch (102:16): [True: 1.86k, False: 1.20k]
  |  Branch (102:29): [True: 239, False: 1.62k]
  ------------------
  103|    239|	break;
  104|  3.23k|    }
  105|       |
  106|    599|  if ((negative && !(val[k] & 0x80)) || (!negative && (val[k] & 0x80)))
  ------------------
  |  Branch (106:8): [True: 219, False: 380]
  |  Branch (106:20): [True: 96, False: 123]
  |  Branch (106:42): [True: 380, False: 123]
  |  Branch (106:55): [True: 184, False: 196]
  ------------------
  107|    280|    k--;
  108|       |
  109|    599|  *len = SIZEOF_UNSIGNED_LONG_INT - k;
  ------------------
  |  |  635|    599|#define SIZEOF_UNSIGNED_LONG_INT 8
  ------------------
  110|       |
  111|    599|  if (SIZEOF_UNSIGNED_LONG_INT - k > value_out_size)
  ------------------
  |  |  635|    599|#define SIZEOF_UNSIGNED_LONG_INT 8
  ------------------
  |  Branch (111:7): [True: 0, False: 599]
  ------------------
  112|       |    /* VALUE_OUT is too short to contain the value conversion */
  113|      0|    return ASN1_MEM_ERROR;
  ------------------
  |  |  128|      0|# define ASN1_MEM_ERROR			12
  ------------------
  114|       |
  115|    599|  if (value_out != NULL)
  ------------------
  |  Branch (115:7): [True: 599, False: 0]
  ------------------
  116|    599|    {
  117|  2.83k|      for (k2 = k; k2 < SIZEOF_UNSIGNED_LONG_INT; k2++)
  ------------------
  |  |  635|  2.83k|#define SIZEOF_UNSIGNED_LONG_INT 8
  ------------------
  |  Branch (117:20): [True: 2.23k, False: 599]
  ------------------
  118|  2.23k|	value_out[k2 - k] = val[k2];
  119|    599|    }
  120|       |
  121|       |#if 0
  122|       |  printf ("_asn1_convert_integer: valueIn=%s, lenOut=%d", value, *len);
  123|       |  for (k = 0; k < SIZEOF_UNSIGNED_LONG_INT; k++)
  124|       |    printf (", vOut[%d]=%d", k, value_out[k]);
  125|       |  printf ("\n");
  126|       |#endif
  127|       |
  128|    599|  return ASN1_SUCCESS;
  ------------------
  |  |  116|    599|# define ASN1_SUCCESS			0
  ------------------
  129|    599|}

c_isdigit:
  234|  4.44k|{
  235|  4.44k|  switch (c)
  236|  4.44k|    {
  237|    236|    _C_CTYPE_DIGIT:
  ------------------
  |  |  135|    150|   case '0': case '1': case '2': case '3': \
  |  |  ------------------
  |  |  |  Branch (135:4): [True: 31, False: 4.41k]
  |  |  |  Branch (135:14): [True: 25, False: 4.42k]
  |  |  |  Branch (135:24): [True: 61, False: 4.38k]
  |  |  |  Branch (135:34): [True: 33, False: 4.41k]
  |  |  ------------------
  |  |  136|    214|   case '4': case '5': case '6': case '7': \
  |  |  ------------------
  |  |  |  Branch (136:4): [True: 29, False: 4.42k]
  |  |  |  Branch (136:14): [True: 15, False: 4.43k]
  |  |  |  Branch (136:24): [True: 4, False: 4.44k]
  |  |  |  Branch (136:34): [True: 16, False: 4.43k]
  |  |  ------------------
  |  |  137|    236|   case '8': case '9'
  |  |  ------------------
  |  |  |  Branch (137:4): [True: 11, False: 4.43k]
  |  |  ------------------
  ------------------
  238|    236|      return true;
  239|  4.21k|    default:
  ------------------
  |  Branch (239:5): [True: 4.21k, False: 236]
  ------------------
  240|  4.21k|      return false;
  241|  4.44k|    }
  242|  4.44k|}

_asn1_str_cat:
   33|  13.0k|{
   34|  13.0k|  size_t str_size = strlen (src);
   35|  13.0k|  size_t dest_size = strlen (dest);
   36|       |
   37|  13.0k|  if (dest_tot_size - dest_size > str_size)
  ------------------
  |  Branch (37:7): [True: 12.4k, False: 581]
  ------------------
   38|  12.4k|    {
   39|  12.4k|      strcat (dest, src);
   40|  12.4k|    }
   41|    581|  else
   42|    581|    {
   43|    581|      if (dest_tot_size > dest_size)
  ------------------
  |  Branch (43:11): [True: 581, False: 0]
  ------------------
   44|    581|	{
   45|    581|	  strncat (dest, src, (dest_tot_size - dest_size) - 1);
   46|    581|	  dest[dest_tot_size - 1] = 0;
   47|    581|	}
   48|    581|    }
   49|  13.0k|}
_asn1_str_cpy:
   54|  46.5k|{
   55|  46.5k|  size_t str_size = strlen (src);
   56|       |
   57|  46.5k|  if (dest_tot_size > str_size)
  ------------------
  |  Branch (57:7): [True: 46.5k, False: 0]
  ------------------
   58|  46.5k|    {
   59|  46.5k|      strcpy (dest, src);
   60|  46.5k|      return str_size;
   61|  46.5k|    }
   62|      0|  else
   63|      0|    {
   64|      0|      if (dest_tot_size > 0)
  ------------------
  |  Branch (64:11): [True: 0, False: 0]
  ------------------
   65|      0|	{
   66|      0|	  str_size = dest_tot_size - 1;
   67|      0|	  memcpy (dest, src, str_size);
   68|      0|	  dest[str_size] = 0;
   69|      0|	  return str_size;
   70|      0|	}
   71|      0|      else
   72|      0|	return 0;
   73|      0|    }
   74|  46.5k|}

structure.c:convert_old_type:
  186|  8.38k|{
  187|  8.38k|  unsigned int type = ntype & 0xff;
  188|  8.38k|  if (type == ASN1_ETYPE_TIME)
  ------------------
  |  |  172|  8.38k|# define ASN1_ETYPE_TIME 17
  ------------------
  |  Branch (188:7): [True: 189, False: 8.19k]
  ------------------
  189|    189|    {
  190|    189|      if (ntype & CONST_UTC)
  ------------------
  |  |  160|    189|# define CONST_UTC         (1U<<24)
  ------------------
  |  Branch (190:11): [True: 105, False: 84]
  ------------------
  191|    105|	type = ASN1_ETYPE_UTC_TIME;
  ------------------
  |  |  244|    105|# define ASN1_ETYPE_UTC_TIME       36
  ------------------
  192|     84|      else
  193|     84|	type = ASN1_ETYPE_GENERALIZED_TIME;
  ------------------
  |  |  245|     84|# define ASN1_ETYPE_GENERALIZED_TIME 37
  ------------------
  194|       |
  195|    189|      ntype &= ~(CONST_UTC | CONST_GENERALIZED);
  ------------------
  |  |  160|    189|# define CONST_UTC         (1U<<24)
  ------------------
                    ntype &= ~(CONST_UTC | CONST_GENERALIZED);
  ------------------
  |  |  159|    189|# define CONST_GENERALIZED (1U<<23)
  ------------------
  196|    189|      ntype &= 0xffffff00;
  197|    189|      ntype |= type;
  198|       |
  199|    189|      return ntype;
  200|    189|    }
  201|  8.19k|  else
  202|  8.19k|    return ntype;
  203|  8.38k|}
parser_aux.c:type_field:
  179|  82.0k|{
  180|  82.0k|  return (ntype & 0xff);
  181|  82.0k|}

_asn1_add_static_node:
   66|  8.38k|{
   67|  8.38k|  list_type *p;
   68|  8.38k|  asn1_node punt;
   69|       |
   70|  8.38k|  punt = calloc (1, sizeof (struct asn1_node_st));
   71|  8.38k|  if (punt == NULL)
  ------------------
  |  Branch (71:7): [True: 0, False: 8.38k]
  ------------------
   72|      0|    return NULL;
   73|       |
   74|  8.38k|  p = malloc (sizeof (list_type));
   75|  8.38k|  if (p == NULL)
  ------------------
  |  Branch (75:7): [True: 0, False: 8.38k]
  ------------------
   76|      0|    {
   77|      0|      free (punt);
   78|      0|      return NULL;
   79|      0|    }
   80|       |
   81|  8.38k|  p->node = punt;
   82|  8.38k|  p->next = *e_list;
   83|  8.38k|  *e_list = p;
   84|       |
   85|  8.38k|  punt->type = type;
   86|       |
   87|  8.38k|  return punt;
   88|  8.38k|}
asn1_find_node:
  122|  5.96k|{
  123|  5.96k|  asn1_node_const p;
  124|  5.96k|  char *n_end, n[ASN1_MAX_NAME_SIZE + 1];
  125|  5.96k|  const char *n_start;
  126|  5.96k|  unsigned int nsize;
  127|  5.96k|  unsigned int nhash;
  128|       |
  129|  5.96k|  if (pointer == NULL)
  ------------------
  |  Branch (129:7): [True: 0, False: 5.96k]
  ------------------
  130|      0|    return NULL;
  131|       |
  132|  5.96k|  if (name == NULL)
  ------------------
  |  Branch (132:7): [True: 0, False: 5.96k]
  ------------------
  133|      0|    return NULL;
  134|       |
  135|  5.96k|  p = pointer;
  136|  5.96k|  n_start = name;
  137|       |
  138|  5.96k|  if (name[0] == '?' && name[1] == 'C' && p->name[0] == '?')
  ------------------
  |  Branch (138:7): [True: 1.79k, False: 4.17k]
  |  Branch (138:25): [True: 981, False: 810]
  |  Branch (138:43): [True: 981, False: 0]
  ------------------
  139|    981|    {				/* ?CURRENT */
  140|    981|      n_start = strchr (n_start, '.');
  141|    981|      if (n_start)
  ------------------
  |  Branch (141:11): [True: 913, False: 68]
  ------------------
  142|    913|	n_start++;
  143|    981|    }
  144|  4.98k|  else if (p->name[0] != 0)
  ------------------
  |  Branch (144:12): [True: 4.03k, False: 944]
  ------------------
  145|  4.03k|    {				/* has *pointer got a name ? */
  146|  4.03k|      n_end = strchr (n_start, '.');	/* search the first dot */
  147|  4.03k|      if (n_end)
  ------------------
  |  Branch (147:11): [True: 3.89k, False: 140]
  ------------------
  148|  3.89k|	{
  149|  3.89k|	  nsize = n_end - n_start;
  150|  3.89k|	  if (nsize >= sizeof (n))
  ------------------
  |  Branch (150:8): [True: 0, False: 3.89k]
  ------------------
  151|      0|	    return NULL;
  152|       |
  153|  3.89k|	  memcpy (n, n_start, nsize);
  154|  3.89k|	  n[nsize] = 0;
  155|  3.89k|	  n_start = n_end;
  156|  3.89k|	  n_start++;
  157|       |
  158|  3.89k|	  nhash = _asn1_hash_name (n);
  159|  3.89k|	}
  160|    140|      else
  161|    140|	{
  162|    140|	  _asn1_str_cpy (n, sizeof (n), n_start);
  163|    140|	  nhash = _asn1_hash_name (n);
  164|       |
  165|    140|	  n_start = NULL;
  166|    140|	}
  167|       |
  168|  4.10k|      while (p)
  ------------------
  |  Branch (168:14): [True: 4.03k, False: 61]
  ------------------
  169|  4.03k|	{
  170|  4.03k|	  if (nhash == p->name_hash && (!strcmp (p->name, n)))
  ------------------
  |  Branch (170:8): [True: 3.99k, False: 46]
  |  Branch (170:33): [True: 3.97k, False: 15]
  ------------------
  171|  3.97k|	    break;
  172|     61|	  else
  173|     61|	    p = p->right;
  174|  4.03k|	}			/* while */
  175|       |
  176|  4.03k|      if (p == NULL)
  ------------------
  |  Branch (176:11): [True: 61, False: 3.97k]
  ------------------
  177|     61|	return NULL;
  178|  4.03k|    }
  179|    944|  else
  180|    944|    {				/* *pointer doesn't have a name */
  181|    944|      if (n_start[0] == 0)
  ------------------
  |  Branch (181:11): [True: 156, False: 788]
  ------------------
  182|    156|	return (asn1_node) p;
  183|    944|    }
  184|       |
  185|  13.3k|  while (n_start)
  ------------------
  |  Branch (185:10): [True: 7.94k, False: 5.45k]
  ------------------
  186|  7.94k|    {				/* Has the end of NAME been reached? */
  187|  7.94k|      n_end = strchr (n_start, '.');	/* search the next dot */
  188|  7.94k|      if (n_end)
  ------------------
  |  Branch (188:11): [True: 2.44k, False: 5.50k]
  ------------------
  189|  2.44k|	{
  190|  2.44k|	  nsize = n_end - n_start;
  191|  2.44k|	  if (nsize >= sizeof (n))
  ------------------
  |  Branch (191:8): [True: 0, False: 2.44k]
  ------------------
  192|      0|	    return NULL;
  193|       |
  194|  2.44k|	  memcpy (n, n_start, nsize);
  195|  2.44k|	  n[nsize] = 0;
  196|  2.44k|	  n_start = n_end;
  197|  2.44k|	  n_start++;
  198|       |
  199|  2.44k|	  nhash = _asn1_hash_name (n);
  200|  2.44k|	}
  201|  5.50k|      else
  202|  5.50k|	{
  203|  5.50k|	  _asn1_str_cpy (n, sizeof (n), n_start);
  204|  5.50k|	  nhash = _asn1_hash_name (n);
  205|  5.50k|	  n_start = NULL;
  206|  5.50k|	}
  207|       |
  208|  7.94k|      if (p->down == NULL)
  ------------------
  |  Branch (208:11): [True: 46, False: 7.89k]
  ------------------
  209|     46|	return NULL;
  210|       |
  211|  7.89k|      p = p->down;
  212|  7.89k|      if (p == NULL)
  ------------------
  |  Branch (212:11): [True: 0, False: 7.89k]
  ------------------
  213|      0|	return NULL;
  214|       |
  215|       |      /* The identifier "?LAST" indicates the last element
  216|       |         in the right chain. */
  217|  7.89k|      if (n[0] == '?' && n[1] == 'L')	/* ?LAST */
  ------------------
  |  Branch (217:11): [True: 2.15k, False: 5.73k]
  |  Branch (217:26): [True: 1.88k, False: 276]
  ------------------
  218|  1.88k|	{
  219|  8.33k|	  while (p->right)
  ------------------
  |  Branch (219:11): [True: 6.45k, False: 1.88k]
  ------------------
  220|  6.45k|	    p = p->right;
  221|  1.88k|	}
  222|  6.01k|      else
  223|  6.01k|	{			/* no "?LAST" */
  224|  17.8k|	  while (p)
  ------------------
  |  Branch (224:11): [True: 17.5k, False: 247]
  ------------------
  225|  17.5k|	    {
  226|  17.5k|	      if (p->name_hash == nhash && !strcmp (p->name, n))
  ------------------
  |  Branch (226:12): [True: 6.30k, False: 11.2k]
  |  Branch (226:37): [True: 5.76k, False: 537]
  ------------------
  227|  5.76k|		break;
  228|  11.7k|	      else
  229|  11.7k|		p = p->right;
  230|  17.5k|	    }
  231|  6.01k|	}
  232|  7.89k|      if (p == NULL)
  ------------------
  |  Branch (232:11): [True: 247, False: 7.64k]
  ------------------
  233|    247|	return NULL;
  234|  7.89k|    }				/* while */
  235|       |
  236|  5.45k|  return (asn1_node) p;
  237|  5.74k|}
_asn1_set_value:
  252|  31.7k|{
  253|  31.7k|  if (node == NULL)
  ------------------
  |  Branch (253:7): [True: 0, False: 31.7k]
  ------------------
  254|      0|    return node;
  255|  31.7k|  if (node->value)
  ------------------
  |  Branch (255:7): [True: 786, False: 30.9k]
  ------------------
  256|    786|    {
  257|    786|      if (node->value != node->small_value)
  ------------------
  |  Branch (257:11): [True: 471, False: 315]
  ------------------
  258|    471|	free (node->value);
  259|    786|      node->value = NULL;
  260|    786|      node->value_len = 0;
  261|    786|    }
  262|       |
  263|  31.7k|  if (!len)
  ------------------
  |  Branch (263:7): [True: 0, False: 31.7k]
  ------------------
  264|      0|    return node;
  265|       |
  266|  31.7k|  if (len < sizeof (node->small_value))
  ------------------
  |  Branch (266:7): [True: 21.1k, False: 10.6k]
  ------------------
  267|  21.1k|    {
  268|  21.1k|      node->value = node->small_value;
  269|  21.1k|    }
  270|  10.6k|  else
  271|  10.6k|    {
  272|  10.6k|      node->value = malloc (len);
  273|  10.6k|      if (node->value == NULL)
  ------------------
  |  Branch (273:11): [True: 0, False: 10.6k]
  ------------------
  274|      0|	return NULL;
  275|  10.6k|    }
  276|  31.7k|  node->value_len = len;
  277|       |
  278|  31.7k|  memcpy (node->value, value, len);
  279|  31.7k|  return node;
  280|  31.7k|}
_asn1_set_name:
  409|  32.9k|{
  410|  32.9k|  if (node == NULL)
  ------------------
  |  Branch (410:7): [True: 0, False: 32.9k]
  ------------------
  411|      0|    return node;
  412|       |
  413|  32.9k|  _asn1_str_cpy (node->name, sizeof (node->name), name ? name : "");
  ------------------
  |  Branch (413:51): [True: 32.9k, False: 0]
  ------------------
  414|  32.9k|  node->name_hash = _asn1_hash_name (node->name);
  415|       |
  416|  32.9k|  return node;
  417|  32.9k|}
_asn1_set_right:
  457|  49.9k|{
  458|  49.9k|  if (node == NULL)
  ------------------
  |  Branch (458:7): [True: 190, False: 49.7k]
  ------------------
  459|    190|    return node;
  460|  49.7k|  node->right = right;
  461|  49.7k|  if (right)
  ------------------
  |  Branch (461:7): [True: 48.2k, False: 1.53k]
  ------------------
  462|  48.2k|    right->left = node;
  463|  49.7k|  return node;
  464|  49.9k|}
_asn1_remove_node:
  497|  34.4k|{
  498|  34.4k|  if (node == NULL)
  ------------------
  |  Branch (498:7): [True: 1.37k, False: 33.0k]
  ------------------
  499|  1.37k|    return;
  500|       |
  501|  33.0k|  if (node->value != NULL)
  ------------------
  |  Branch (501:7): [True: 30.9k, False: 2.12k]
  ------------------
  502|  30.9k|    {
  503|  30.9k|      if (flags & ASN1_DELETE_FLAG_ZEROIZE)
  ------------------
  |  |  254|  30.9k|# define ASN1_DELETE_FLAG_ZEROIZE 1
  ------------------
  |  Branch (503:11): [True: 0, False: 30.9k]
  ------------------
  504|      0|	{
  505|      0|	  safe_memset (node->value, 0, node->value_len);
  506|      0|	}
  507|       |
  508|  30.9k|      if (node->value != node->small_value)
  ------------------
  |  Branch (508:11): [True: 10.1k, False: 20.7k]
  ------------------
  509|  10.1k|	free (node->value);
  510|  30.9k|    }
  511|  33.0k|  free (node);
  512|  33.0k|}
_asn1_find_up:
  523|  30.4k|{
  524|  30.4k|  asn1_node_const p;
  525|       |
  526|  30.4k|  if (node == NULL)
  ------------------
  |  Branch (526:7): [True: 0, False: 30.4k]
  ------------------
  527|      0|    return NULL;
  528|       |
  529|  30.4k|  p = node;
  530|       |
  531|  59.0k|  while ((p->left != NULL) && (p->left->right == p))
  ------------------
  |  Branch (531:10): [True: 54.0k, False: 5.01k]
  |  Branch (531:31): [True: 28.5k, False: 25.4k]
  ------------------
  532|  28.5k|    p = p->left;
  533|       |
  534|  30.4k|  return p->left;
  535|  30.4k|}
_asn1_delete_node_from_list:
  563|  4.27k|{
  564|  4.27k|  list_type *p = list;
  565|       |
  566|   295k|  while (p)
  ------------------
  |  Branch (566:10): [True: 291k, False: 4.27k]
  ------------------
  567|   291k|    {
  568|   291k|      if (p->node == node)
  ------------------
  |  Branch (568:11): [True: 4.27k, False: 287k]
  ------------------
  569|  4.27k|	p->node = NULL;
  570|   291k|      p = p->next;
  571|   291k|    }
  572|  4.27k|}
_asn1_delete_list:
  581|    500|{
  582|    500|  list_type *p;
  583|       |
  584|  9.66k|  while (e_list)
  ------------------
  |  Branch (584:10): [True: 9.16k, False: 500]
  ------------------
  585|  9.16k|    {
  586|  9.16k|      p = e_list;
  587|  9.16k|      e_list = e_list->next;
  588|  9.16k|      free (p);
  589|  9.16k|    }
  590|    500|}
_asn1_delete_list_and_nodes:
  599|    564|{
  600|    564|  list_type *p;
  601|       |
  602|  24.4k|  while (e_list)
  ------------------
  |  Branch (602:10): [True: 23.9k, False: 564]
  ------------------
  603|  23.9k|    {
  604|  23.9k|      p = e_list;
  605|  23.9k|      e_list = e_list->next;
  606|  23.9k|      _asn1_remove_node (p->node, 0);
  607|  23.9k|      free (p);
  608|  23.9k|    }
  609|    564|}
_asn1_change_integer_value:
  662|    643|{
  663|    643|  asn1_node p;
  664|    643|  unsigned char val[SIZEOF_UNSIGNED_LONG_INT];
  665|    643|  unsigned char val2[SIZEOF_UNSIGNED_LONG_INT + 1];
  666|    643|  int len;
  667|       |
  668|    643|  if (node == NULL)
  ------------------
  |  Branch (668:7): [True: 0, False: 643]
  ------------------
  669|      0|    return ASN1_ELEMENT_NOT_FOUND;
  ------------------
  |  |  118|      0|# define ASN1_ELEMENT_NOT_FOUND		2
  ------------------
  670|       |
  671|    643|  p = node;
  672|  6.08k|  while (p)
  ------------------
  |  Branch (672:10): [True: 5.44k, False: 643]
  ------------------
  673|  5.44k|    {
  674|  5.44k|      if ((type_field (p->type) == ASN1_ETYPE_INTEGER)
  ------------------
  |  |  217|  5.44k|# define ASN1_ETYPE_INTEGER        3
  ------------------
  |  Branch (674:11): [True: 740, False: 4.70k]
  ------------------
  675|  5.44k|	  && (p->type & CONST_ASSIGN))
  ------------------
  |  |  166|    740|# define CONST_ASSIGN      (1U<<28)
  ------------------
  |  Branch (675:7): [True: 669, False: 71]
  ------------------
  676|    669|	{
  677|    669|	  if (p->value)
  ------------------
  |  Branch (677:8): [True: 599, False: 70]
  ------------------
  678|    599|	    {
  679|    599|	      _asn1_convert_integer (p->value, val, sizeof (val), &len);
  680|    599|	      asn1_octet_der (val, len, val2, &len);
  681|    599|	      _asn1_set_value (p, val2, len);
  682|    599|	    }
  683|    669|	}
  684|       |
  685|  5.44k|      if (p->down)
  ------------------
  |  Branch (685:11): [True: 2.69k, False: 2.74k]
  ------------------
  686|  2.69k|	{
  687|  2.69k|	  p = p->down;
  688|  2.69k|	}
  689|  2.74k|      else
  690|  2.74k|	{
  691|  2.74k|	  if (p == node)
  ------------------
  |  Branch (691:8): [True: 130, False: 2.61k]
  ------------------
  692|    130|	    p = NULL;
  693|  2.61k|	  else if (p->right)
  ------------------
  |  Branch (693:13): [True: 1.41k, False: 1.19k]
  ------------------
  694|  1.41k|	    p = p->right;
  695|  1.19k|	  else
  696|  1.19k|	    {
  697|  2.69k|	      while (1)
  ------------------
  |  Branch (697:15): [Folded - Ignored]
  ------------------
  698|  2.69k|		{
  699|  2.69k|		  p = _asn1_find_up (p);
  700|  2.69k|		  if (p == node)
  ------------------
  |  Branch (700:9): [True: 513, False: 2.18k]
  ------------------
  701|    513|		    {
  702|    513|		      p = NULL;
  703|    513|		      break;
  704|    513|		    }
  705|  2.18k|		  if (p && p->right)
  ------------------
  |  Branch (705:9): [True: 2.18k, False: 0]
  |  Branch (705:14): [True: 685, False: 1.49k]
  ------------------
  706|    685|		    {
  707|    685|		      p = p->right;
  708|    685|		      break;
  709|    685|		    }
  710|  2.18k|		}
  711|  1.19k|	    }
  712|  2.74k|	}
  713|  5.44k|    }
  714|       |
  715|    643|  return ASN1_SUCCESS;
  ------------------
  |  |  116|    643|# define ASN1_SUCCESS			0
  ------------------
  716|    643|}
_asn1_expand_object_id:
  731|    643|{
  732|    643|  asn1_node p, p2, p3, p4, p5;
  733|    643|  char name_root[ASN1_MAX_NAME_SIZE], name2[2 * ASN1_MAX_NAME_SIZE + 1];
  734|    643|  int move, tlen, tries;
  735|    643|  unsigned max_constants;
  736|       |
  737|    643|  if (node == NULL)
  ------------------
  |  Branch (737:7): [True: 0, False: 643]
  ------------------
  738|      0|    return ASN1_ELEMENT_NOT_FOUND;
  ------------------
  |  |  118|      0|# define ASN1_ELEMENT_NOT_FOUND		2
  ------------------
  739|       |
  740|    643|  _asn1_str_cpy (name_root, sizeof (name_root), node->name);
  741|       |
  742|    643|  p = node;
  743|    643|  move = DOWN;
  ------------------
  |  |  131|    643|# define DOWN   3
  ------------------
  744|    643|  tries = 0;
  745|       |
  746|  12.7k|  while (!((p == node) && (move == UP)))
  ------------------
  |  |  129|  1.88k|# define UP     1
  ------------------
  |  Branch (746:12): [True: 1.88k, False: 10.8k]
  |  Branch (746:27): [True: 533, False: 1.34k]
  ------------------
  747|  12.1k|    {
  748|  12.1k|      if (move != UP)
  ------------------
  |  |  129|  12.1k|# define UP     1
  ------------------
  |  Branch (748:11): [True: 10.3k, False: 1.83k]
  ------------------
  749|  10.3k|	{
  750|  10.3k|	  if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID)
  ------------------
  |  |  226|  10.3k|# define ASN1_ETYPE_OBJECT_ID     12
  ------------------
  |  Branch (750:8): [True: 5.67k, False: 4.69k]
  ------------------
  751|  10.3k|	      && (p->type & CONST_ASSIGN))
  ------------------
  |  |  166|  5.67k|# define CONST_ASSIGN      (1U<<28)
  ------------------
  |  Branch (751:11): [True: 5.51k, False: 165]
  ------------------
  752|  5.51k|	    {
  753|  5.51k|	      p2 = p->down;
  754|  5.51k|	      if (p2 && (type_field (p2->type) == ASN1_ETYPE_CONSTANT))
  ------------------
  |  |  215|  5.24k|# define ASN1_ETYPE_CONSTANT       1
  ------------------
  |  Branch (754:12): [True: 5.24k, False: 261]
  |  Branch (754:18): [True: 4.14k, False: 1.10k]
  ------------------
  755|  4.14k|		{
  756|  4.14k|		  if (p2->value && !c_isdigit (p2->value[0]))
  ------------------
  |  Branch (756:9): [True: 3.95k, False: 184]
  |  Branch (756:22): [True: 3.81k, False: 145]
  ------------------
  757|  3.81k|		    {
  758|  3.81k|		      _asn1_str_cpy (name2, sizeof (name2), name_root);
  759|  3.81k|		      _asn1_str_cat (name2, sizeof (name2), ".");
  760|  3.81k|		      _asn1_str_cat (name2, sizeof (name2),
  761|  3.81k|				     (char *) p2->value);
  762|  3.81k|		      p3 = asn1_find_node (node, name2);
  763|  3.81k|		      if (!p3 || _asn1_is_up (p2, p3) ||
  ------------------
  |  Branch (763:13): [True: 34, False: 3.77k]
  |  Branch (763:20): [True: 1, False: 3.77k]
  ------------------
  764|  3.81k|			  (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID) ||
  ------------------
  |  |  226|  3.77k|# define ASN1_ETYPE_OBJECT_ID     12
  ------------------
  |  Branch (764:6): [True: 13, False: 3.76k]
  ------------------
  765|  3.81k|			  !(p3->type & CONST_ASSIGN))
  ------------------
  |  |  166|  3.76k|# define CONST_ASSIGN      (1U<<28)
  ------------------
  |  Branch (765:6): [True: 1, False: 3.76k]
  ------------------
  766|     49|			return ASN1_ELEMENT_NOT_FOUND;
  ------------------
  |  |  118|     49|# define ASN1_ELEMENT_NOT_FOUND		2
  ------------------
  767|       |
  768|  3.76k|		      _asn1_set_down (p, p2->right);
  769|  3.76k|		      if (p2->down)
  ------------------
  |  Branch (769:13): [True: 80, False: 3.68k]
  ------------------
  770|     80|			_asn1_delete_structure (*list, &p2->down, 0);
  771|  3.76k|		      _asn1_delete_node_from_list (*list, p2);
  772|  3.76k|		      _asn1_remove_node (p2, 0);
  773|  3.76k|		      p2 = p;
  774|  3.76k|		      p4 = p3->down;
  775|  3.76k|		      max_constants = 0;
  776|  32.1k|		      while (p4)
  ------------------
  |  Branch (776:16): [True: 28.3k, False: 3.75k]
  ------------------
  777|  28.3k|			{
  778|  28.3k|			  if (type_field (p4->type) == ASN1_ETYPE_CONSTANT)
  ------------------
  |  |  215|  28.3k|# define ASN1_ETYPE_CONSTANT       1
  ------------------
  |  Branch (778:10): [True: 24.6k, False: 3.65k]
  ------------------
  779|  24.6k|			    {
  780|  24.6k|			      max_constants++;
  781|  24.6k|			      if (max_constants == MAX_CONSTANTS)
  ------------------
  |  |  718|  24.6k|#define MAX_CONSTANTS 1024
  ------------------
  |  Branch (781:14): [True: 8, False: 24.6k]
  ------------------
  782|      8|				return ASN1_RECURSION;
  ------------------
  |  |  135|      8|# define ASN1_RECURSION			19
  ------------------
  783|       |
  784|  24.6k|			      p5 =
  785|  24.6k|				_asn1_add_single_node (ASN1_ETYPE_CONSTANT);
  ------------------
  |  |  215|  24.6k|# define ASN1_ETYPE_CONSTANT       1
  ------------------
  786|  24.6k|			      _asn1_set_name (p5, p4->name);
  787|  24.6k|			      if (p4->value)
  ------------------
  |  Branch (787:14): [True: 23.7k, False: 952]
  ------------------
  788|  23.7k|				{
  789|  23.7k|				  tlen = _asn1_strlen (p4->value);
  ------------------
  |  |  113|  23.7k|# define _asn1_strlen(s) strlen((const char *) s)
  ------------------
  790|  23.7k|				  if (tlen > 0)
  ------------------
  |  Branch (790:11): [True: 23.3k, False: 351]
  ------------------
  791|  23.3k|				    _asn1_set_value (p5, p4->value, tlen + 1);
  792|  23.7k|				}
  793|  24.6k|			      _asn1_add_static_node2 (list, p5);
  794|       |
  795|  24.6k|			      if (p2 == p)
  ------------------
  |  Branch (795:14): [True: 2.38k, False: 22.2k]
  ------------------
  796|  2.38k|				{
  797|  2.38k|				  _asn1_set_right (p5, p->down);
  798|  2.38k|				  _asn1_set_down (p, p5);
  799|  2.38k|				}
  800|  22.2k|			      else
  801|  22.2k|				{
  802|  22.2k|				  _asn1_set_right (p5, p2->right);
  803|  22.2k|				  _asn1_set_right (p2, p5);
  804|  22.2k|				}
  805|  24.6k|			      p2 = p5;
  806|  24.6k|			    }
  807|  28.3k|			  p4 = p4->right;
  808|  28.3k|			}
  809|  3.75k|		      move = DOWN;
  ------------------
  |  |  131|  3.75k|# define DOWN   3
  ------------------
  810|       |
  811|  3.75k|		      tries++;
  812|  3.75k|		      if (tries >= EXPAND_OBJECT_ID_MAX_RECURSION)
  ------------------
  |  |   76|  3.75k|# define EXPAND_OBJECT_ID_MAX_RECURSION 16
  ------------------
  |  Branch (812:13): [True: 53, False: 3.70k]
  ------------------
  813|     53|			return ASN1_RECURSION;
  ------------------
  |  |  135|     53|# define ASN1_RECURSION			19
  ------------------
  814|       |
  815|  3.70k|		      continue;
  816|  3.75k|		    }
  817|  4.14k|		}
  818|  5.51k|	    }
  819|  6.55k|	  move = DOWN;
  ------------------
  |  |  131|  6.55k|# define DOWN   3
  ------------------
  820|  6.55k|	}
  821|  1.83k|      else
  822|  1.83k|	move = RIGHT;
  ------------------
  |  |  130|  1.83k|# define RIGHT  2
  ------------------
  823|       |
  824|  8.38k|      tries = 0;
  825|  8.38k|      if (move == DOWN)
  ------------------
  |  |  131|  8.38k|# define DOWN   3
  ------------------
  |  Branch (825:11): [True: 6.55k, False: 1.83k]
  ------------------
  826|  6.55k|	{
  827|  6.55k|	  if (p->down)
  ------------------
  |  Branch (827:8): [True: 2.29k, False: 4.25k]
  ------------------
  828|  2.29k|	    p = p->down;
  829|  4.25k|	  else
  830|  4.25k|	    move = RIGHT;
  ------------------
  |  |  130|  4.25k|# define RIGHT  2
  ------------------
  831|  6.55k|	}
  832|       |
  833|  8.38k|      if (p == node)
  ------------------
  |  Branch (833:11): [True: 130, False: 8.25k]
  ------------------
  834|    130|	{
  835|    130|	  move = UP;
  ------------------
  |  |  129|    130|# define UP     1
  ------------------
  836|    130|	  continue;
  837|    130|	}
  838|       |
  839|  8.25k|      if (move == RIGHT)
  ------------------
  |  |  130|  8.25k|# define RIGHT  2
  ------------------
  |  Branch (839:11): [True: 5.95k, False: 2.29k]
  ------------------
  840|  5.95k|	{
  841|  5.95k|	  if (p && p->right)
  ------------------
  |  Branch (841:8): [True: 5.95k, False: 0]
  |  Branch (841:13): [True: 3.72k, False: 2.23k]
  ------------------
  842|  3.72k|	    p = p->right;
  843|  2.23k|	  else
  844|  2.23k|	    move = UP;
  ------------------
  |  |  129|  2.23k|# define UP     1
  ------------------
  845|  5.95k|	}
  846|  8.25k|      if (move == UP)
  ------------------
  |  |  129|  8.25k|# define UP     1
  ------------------
  |  Branch (846:11): [True: 2.23k, False: 6.02k]
  ------------------
  847|  2.23k|	p = _asn1_find_up (p);
  848|  8.25k|    }
  849|       |
  850|       |  /*******************************/
  851|       |  /*       expand DEFAULT        */
  852|       |  /*******************************/
  853|    533|  p = node;
  854|    533|  move = DOWN;
  ------------------
  |  |  131|    533|# define DOWN   3
  ------------------
  855|       |
  856|  8.48k|  while (!((p == node) && (move == UP)))
  ------------------
  |  |  129|  1.03k|# define UP     1
  ------------------
  |  Branch (856:12): [True: 1.03k, False: 7.45k]
  |  Branch (856:27): [True: 500, False: 533]
  ------------------
  857|  7.98k|    {
  858|  7.98k|      if (move != UP)
  ------------------
  |  |  129|  7.98k|# define UP     1
  ------------------
  |  Branch (858:11): [True: 6.27k, False: 1.71k]
  ------------------
  859|  6.27k|	{
  860|  6.27k|	  if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) &&
  ------------------
  |  |  226|  6.27k|# define ASN1_ETYPE_OBJECT_ID     12
  ------------------
  |  Branch (860:8): [True: 1.79k, False: 4.47k]
  ------------------
  861|  6.27k|	      (p->type & CONST_DEFAULT))
  ------------------
  |  |  145|  1.79k|# define CONST_DEFAULT     (1U<<15)
  ------------------
  |  Branch (861:8): [True: 1.00k, False: 787]
  ------------------
  862|  1.00k|	    {
  863|  1.00k|	      p2 = p->down;
  864|  1.00k|	      if (p2 && (type_field (p2->type) == ASN1_ETYPE_DEFAULT))
  ------------------
  |  |  223|    892|# define ASN1_ETYPE_DEFAULT        9
  ------------------
  |  Branch (864:12): [True: 892, False: 115]
  |  Branch (864:18): [True: 644, False: 248]
  ------------------
  865|    644|		{
  866|    644|		  _asn1_str_cpy (name2, sizeof (name2), name_root);
  867|    644|		  _asn1_str_cat (name2, sizeof (name2), ".");
  868|    644|		  if (p2->value)
  ------------------
  |  Branch (868:9): [True: 301, False: 343]
  ------------------
  869|    301|		    _asn1_str_cat (name2, sizeof (name2), (char *) p2->value);
  870|    644|		  p3 = asn1_find_node (node, name2);
  871|    644|		  if (!p3 || (type_field (p3->type) != ASN1_ETYPE_OBJECT_ID)
  ------------------
  |  |  226|    632|# define ASN1_ETYPE_OBJECT_ID     12
  ------------------
  |  Branch (871:9): [True: 12, False: 632]
  |  Branch (871:16): [True: 18, False: 614]
  ------------------
  872|    644|		      || !(p3->type & CONST_ASSIGN))
  ------------------
  |  |  166|    614|# define CONST_ASSIGN      (1U<<28)
  ------------------
  |  Branch (872:12): [True: 2, False: 612]
  ------------------
  873|     32|		    return ASN1_ELEMENT_NOT_FOUND;
  ------------------
  |  |  118|     32|# define ASN1_ELEMENT_NOT_FOUND		2
  ------------------
  874|    612|		  p4 = p3->down;
  875|    612|		  name2[0] = 0;
  876|  3.93k|		  while (p4)
  ------------------
  |  Branch (876:12): [True: 3.32k, False: 611]
  ------------------
  877|  3.32k|		    {
  878|  3.32k|		      if (type_field (p4->type) == ASN1_ETYPE_CONSTANT)
  ------------------
  |  |  215|  3.32k|# define ASN1_ETYPE_CONSTANT       1
  ------------------
  |  Branch (878:13): [True: 974, False: 2.34k]
  ------------------
  879|    974|			{
  880|    974|			  if (p4->value == NULL)
  ------------------
  |  Branch (880:10): [True: 1, False: 973]
  ------------------
  881|      1|			    return ASN1_VALUE_NOT_FOUND;
  ------------------
  |  |  121|      1|# define ASN1_VALUE_NOT_FOUND		5
  ------------------
  882|       |
  883|    973|			  if (name2[0])
  ------------------
  |  Branch (883:10): [True: 530, False: 443]
  ------------------
  884|    530|			    _asn1_str_cat (name2, sizeof (name2), ".");
  885|    973|			  _asn1_str_cat (name2, sizeof (name2),
  886|    973|					 (char *) p4->value);
  887|    973|			}
  888|  3.32k|		      p4 = p4->right;
  889|  3.32k|		    }
  890|    611|		  tlen = strlen (name2);
  891|    611|		  if (tlen > 0)
  ------------------
  |  Branch (891:9): [True: 268, False: 343]
  ------------------
  892|    268|		    _asn1_set_value (p2, name2, tlen + 1);
  893|    611|		}
  894|  1.00k|	    }
  895|  6.24k|	  move = DOWN;
  ------------------
  |  |  131|  6.24k|# define DOWN   3
  ------------------
  896|  6.24k|	}
  897|  1.71k|      else
  898|  1.71k|	move = RIGHT;
  ------------------
  |  |  130|  1.71k|# define RIGHT  2
  ------------------
  899|       |
  900|  7.95k|      if (move == DOWN)
  ------------------
  |  |  131|  7.95k|# define DOWN   3
  ------------------
  |  Branch (900:11): [True: 6.24k, False: 1.71k]
  ------------------
  901|  6.24k|	{
  902|  6.24k|	  if (p->down)
  ------------------
  |  Branch (902:8): [True: 2.08k, False: 4.15k]
  ------------------
  903|  2.08k|	    p = p->down;
  904|  4.15k|	  else
  905|  4.15k|	    move = RIGHT;
  ------------------
  |  |  130|  4.15k|# define RIGHT  2
  ------------------
  906|  6.24k|	}
  907|       |
  908|  7.95k|      if (p == node)
  ------------------
  |  Branch (908:11): [True: 130, False: 7.82k]
  ------------------
  909|    130|	{
  910|    130|	  move = UP;
  ------------------
  |  |  129|    130|# define UP     1
  ------------------
  911|    130|	  continue;
  912|    130|	}
  913|       |
  914|  7.82k|      if (move == RIGHT)
  ------------------
  |  |  130|  7.82k|# define RIGHT  2
  ------------------
  |  Branch (914:11): [True: 5.74k, False: 2.08k]
  ------------------
  915|  5.74k|	{
  916|  5.74k|	  if (p && p->right)
  ------------------
  |  Branch (916:8): [True: 5.74k, False: 0]
  |  Branch (916:13): [True: 3.65k, False: 2.08k]
  ------------------
  917|  3.65k|	    p = p->right;
  918|  2.08k|	  else
  919|  2.08k|	    move = UP;
  ------------------
  |  |  129|  2.08k|# define UP     1
  ------------------
  920|  5.74k|	}
  921|  7.82k|      if (move == UP)
  ------------------
  |  |  129|  7.82k|# define UP     1
  ------------------
  |  Branch (921:11): [True: 2.08k, False: 5.74k]
  ------------------
  922|  2.08k|	p = _asn1_find_up (p);
  923|  7.82k|    }
  924|       |
  925|    500|  return ASN1_SUCCESS;
  ------------------
  |  |  116|    500|# define ASN1_SUCCESS			0
  ------------------
  926|    533|}
_asn1_check_identifier:
 1014|    977|{
 1015|    977|  asn1_node_const p, p2;
 1016|    977|  char name2[ASN1_MAX_NAME_SIZE * 2 + 2];
 1017|       |
 1018|    977|  if (node == NULL)
  ------------------
  |  Branch (1018:7): [True: 6, False: 971]
  ------------------
 1019|      6|    return ASN1_ELEMENT_NOT_FOUND;
  ------------------
  |  |  118|      6|# define ASN1_ELEMENT_NOT_FOUND		2
  ------------------
 1020|       |
 1021|    971|  p = node;
 1022|  6.50k|  while (p)
  ------------------
  |  Branch (1022:10): [True: 5.86k, False: 643]
  ------------------
 1023|  5.86k|    {
 1024|  5.86k|      if (p->value && type_field (p->type) == ASN1_ETYPE_IDENTIFIER)
  ------------------
  |  |  216|  5.15k|# define ASN1_ETYPE_IDENTIFIER     2
  ------------------
  |  Branch (1024:11): [True: 5.15k, False: 706]
  |  Branch (1024:23): [True: 430, False: 4.72k]
  ------------------
 1025|    430|	{
 1026|    430|	  _asn1_str_cpy (name2, sizeof (name2), node->name);
 1027|    430|	  _asn1_str_cat (name2, sizeof (name2), ".");
 1028|    430|	  _asn1_str_cat (name2, sizeof (name2), (char *) p->value);
 1029|    430|	  p2 = asn1_find_node (node, name2);
 1030|    430|	  if (p2 == NULL)
  ------------------
  |  Branch (1030:8): [True: 284, False: 146]
  ------------------
 1031|    284|	    {
 1032|    284|	      if (p->value)
  ------------------
  |  Branch (1032:12): [True: 284, False: 0]
  ------------------
 1033|    284|		_asn1_str_cpy (_asn1_identifierMissing,
 1034|    284|			       sizeof (_asn1_identifierMissing),
 1035|    284|			       (char *) p->value);
 1036|      0|	      else
 1037|      0|		_asn1_strcpy (_asn1_identifierMissing, "(null)");
  ------------------
  |  |  117|      0|# define _asn1_strcpy(a,b) strcpy((char *)a, (const char *)b)
  ------------------
 1038|    284|	      return ASN1_IDENTIFIER_NOT_FOUND;
  ------------------
  |  |  119|    284|# define ASN1_IDENTIFIER_NOT_FOUND	3
  ------------------
 1039|    284|	    }
 1040|    430|	}
 1041|  5.43k|      else if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) &&
  ------------------
  |  |  226|  5.43k|# define ASN1_ETYPE_OBJECT_ID     12
  ------------------
  |  Branch (1041:16): [True: 2.11k, False: 3.31k]
  ------------------
 1042|  5.43k|	       (p->type & CONST_DEFAULT))
  ------------------
  |  |  145|  2.11k|# define CONST_DEFAULT     (1U<<15)
  ------------------
  |  Branch (1042:9): [True: 1.16k, False: 952]
  ------------------
 1043|  1.16k|	{
 1044|  1.16k|	  p2 = p->down;
 1045|  1.16k|	  if (p2 && (type_field (p2->type) == ASN1_ETYPE_DEFAULT))
  ------------------
  |  |  223|  1.06k|# define ASN1_ETYPE_DEFAULT        9
  ------------------
  |  Branch (1045:8): [True: 1.06k, False: 94]
  |  Branch (1045:14): [True: 677, False: 389]
  ------------------
 1046|    677|	    {
 1047|    677|	      _asn1_str_cpy (name2, sizeof (name2), node->name);
 1048|    677|	      if (p2->value)
  ------------------
  |  Branch (1048:12): [True: 313, False: 364]
  ------------------
 1049|    313|		{
 1050|    313|		  _asn1_str_cat (name2, sizeof (name2), ".");
 1051|    313|		  _asn1_str_cat (name2, sizeof (name2), (char *) p2->value);
 1052|    313|		  _asn1_str_cpy (_asn1_identifierMissing,
 1053|    313|				 sizeof (_asn1_identifierMissing),
 1054|    313|				 (char *) p2->value);
 1055|    313|		}
 1056|    364|	      else
 1057|    364|		_asn1_strcpy (_asn1_identifierMissing, "(null)");
  ------------------
  |  |  117|    364|# define _asn1_strcpy(a,b) strcpy((char *)a, (const char *)b)
  ------------------
 1058|       |
 1059|    677|	      p2 = asn1_find_node (node, name2);
 1060|    677|	      if (!p2 || (type_field (p2->type) != ASN1_ETYPE_OBJECT_ID) ||
  ------------------
  |  |  226|    671|# define ASN1_ETYPE_OBJECT_ID     12
  ------------------
  |  Branch (1060:12): [True: 6, False: 671]
  |  Branch (1060:19): [True: 9, False: 662]
  ------------------
 1061|    677|		  !(p2->type & CONST_ASSIGN))
  ------------------
  |  |  166|    662|# define CONST_ASSIGN      (1U<<28)
  ------------------
  |  Branch (1061:5): [True: 1, False: 661]
  ------------------
 1062|     16|		return ASN1_IDENTIFIER_NOT_FOUND;
  ------------------
  |  |  119|     16|# define ASN1_IDENTIFIER_NOT_FOUND	3
  ------------------
 1063|    661|	      else
 1064|    661|		_asn1_identifierMissing[0] = 0;
 1065|    677|	    }
 1066|  1.16k|	}
 1067|  4.27k|      else if ((type_field (p->type) == ASN1_ETYPE_OBJECT_ID) &&
  ------------------
  |  |  226|  4.27k|# define ASN1_ETYPE_OBJECT_ID     12
  ------------------
  |  Branch (1067:16): [True: 952, False: 3.31k]
  ------------------
 1068|  4.27k|	       (p->type & CONST_ASSIGN))
  ------------------
  |  |  166|    952|# define CONST_ASSIGN      (1U<<28)
  ------------------
  |  Branch (1068:9): [True: 860, False: 92]
  ------------------
 1069|    860|	{
 1070|    860|	  p2 = p->down;
 1071|    860|	  if (p2 && (type_field (p2->type) == ASN1_ETYPE_CONSTANT))
  ------------------
  |  |  215|    761|# define ASN1_ETYPE_CONSTANT       1
  ------------------
  |  Branch (1071:8): [True: 761, False: 99]
  |  Branch (1071:14): [True: 562, False: 199]
  ------------------
 1072|    562|	    {
 1073|    562|	      if (p2->value && !c_isdigit (p2->value[0]))
  ------------------
  |  Branch (1073:12): [True: 492, False: 70]
  |  Branch (1073:25): [True: 401, False: 91]
  ------------------
 1074|    401|		{
 1075|    401|		  _asn1_str_cpy (name2, sizeof (name2), node->name);
 1076|    401|		  _asn1_str_cat (name2, sizeof (name2), ".");
 1077|    401|		  _asn1_str_cat (name2, sizeof (name2), (char *) p2->value);
 1078|    401|		  _asn1_str_cpy (_asn1_identifierMissing,
 1079|    401|				 sizeof (_asn1_identifierMissing),
 1080|    401|				 (char *) p2->value);
 1081|       |
 1082|    401|		  p2 = asn1_find_node (node, name2);
 1083|    401|		  if (!p2 || (type_field (p2->type) != ASN1_ETYPE_OBJECT_ID)
  ------------------
  |  |  226|    383|# define ASN1_ETYPE_OBJECT_ID     12
  ------------------
  |  Branch (1083:9): [True: 18, False: 383]
  |  Branch (1083:16): [True: 9, False: 374]
  ------------------
 1084|    401|		      || !(p2->type & CONST_ASSIGN))
  ------------------
  |  |  166|    374|# define CONST_ASSIGN      (1U<<28)
  ------------------
  |  Branch (1084:12): [True: 1, False: 373]
  ------------------
 1085|     28|		    return ASN1_IDENTIFIER_NOT_FOUND;
  ------------------
  |  |  119|     28|# define ASN1_IDENTIFIER_NOT_FOUND	3
  ------------------
 1086|    373|		  else
 1087|    373|		    _asn1_identifierMissing[0] = 0;
 1088|    401|		}
 1089|    562|	    }
 1090|    860|	}
 1091|       |
 1092|  5.53k|      if (p->down)
  ------------------
  |  Branch (1092:11): [True: 2.75k, False: 2.77k]
  ------------------
 1093|  2.75k|	{
 1094|  2.75k|	  p = p->down;
 1095|  2.75k|	}
 1096|  2.77k|      else if (p->right)
  ------------------
  |  Branch (1096:16): [True: 1.44k, False: 1.33k]
  ------------------
 1097|  1.44k|	p = p->right;
 1098|  1.33k|      else
 1099|  1.33k|	{
 1100|  2.96k|	  while (p)
  ------------------
  |  Branch (1100:11): [True: 2.83k, False: 130]
  ------------------
 1101|  2.83k|	    {
 1102|  2.83k|	      p = _asn1_find_up (p);
 1103|  2.83k|	      if (p == node)
  ------------------
  |  Branch (1103:12): [True: 513, False: 2.32k]
  ------------------
 1104|    513|		{
 1105|    513|		  p = NULL;
 1106|    513|		  break;
 1107|    513|		}
 1108|  2.32k|	      if (p && p->right)
  ------------------
  |  Branch (1108:12): [True: 2.19k, False: 130]
  |  Branch (1108:17): [True: 689, False: 1.50k]
  ------------------
 1109|    689|		{
 1110|    689|		  p = p->right;
 1111|    689|		  break;
 1112|    689|		}
 1113|  2.32k|	    }
 1114|  1.33k|	}
 1115|  5.53k|    }
 1116|       |
 1117|    643|  return ASN1_SUCCESS;
  ------------------
  |  |  116|    643|# define ASN1_SUCCESS			0
  ------------------
 1118|    971|}
parser_aux.c:_asn1_hash_name:
   44|  44.9k|{
   45|  44.9k|  const unsigned char *s = (unsigned char *) x;
   46|  44.9k|  unsigned h = 0;
   47|       |
   48|   249k|  while (*s)
  ------------------
  |  Branch (48:10): [True: 204k, False: 44.9k]
  ------------------
   49|   204k|    h = (*s++) + ((h << 9) | (h >> (WORD_BIT - 9)));
   50|       |
   51|  44.9k|  return h;
   52|  44.9k|}
parser_aux.c:_asn1_is_up:
  539|  3.77k|{
  540|  3.77k|  asn1_node_const d, u;
  541|       |
  542|  3.77k|  if (up_cand == NULL || down == NULL)
  ------------------
  |  Branch (542:7): [True: 0, False: 3.77k]
  |  Branch (542:26): [True: 0, False: 3.77k]
  ------------------
  543|      0|    return 0;
  544|       |
  545|  3.77k|  d = down;
  546|       |
  547|  9.44k|  while ((u = _asn1_find_up (d)) != NULL && u != d)
  ------------------
  |  Branch (547:10): [True: 5.67k, False: 3.77k]
  |  Branch (547:45): [True: 5.67k, False: 0]
  ------------------
  548|  5.67k|    {
  549|  5.67k|      if (u == up_cand)
  ------------------
  |  Branch (549:11): [True: 1, False: 5.67k]
  ------------------
  550|      1|	return 1;
  551|  5.67k|      d = u;
  552|  5.67k|    }
  553|       |
  554|  3.77k|  return 0;
  555|  3.77k|}
parser_aux.c:_asn1_add_static_node2:
   92|  24.6k|{
   93|  24.6k|  list_type *p;
   94|       |
   95|  24.6k|  p = malloc (sizeof (list_type));
   96|  24.6k|  if (p == NULL)
  ------------------
  |  Branch (96:7): [True: 0, False: 24.6k]
  ------------------
   97|      0|    {
   98|      0|      return -1;
   99|      0|    }
  100|       |
  101|  24.6k|  p->node = node;
  102|  24.6k|  p->next = *e_list;
  103|  24.6k|  *e_list = p;
  104|       |
  105|  24.6k|  return 0;
  106|  24.6k|}

structure.c:_asn1_set_down:
  112|  10.3k|{
  113|  10.3k|  if (node == NULL)
  ------------------
  |  Branch (113:7): [True: 155, False: 10.2k]
  ------------------
  114|    155|    return node;
  115|  10.2k|  node->down = down;
  116|  10.2k|  if (down)
  ------------------
  |  Branch (116:7): [True: 7.71k, False: 2.48k]
  ------------------
  117|  7.71k|    down->left = node;
  118|  10.2k|  return node;
  119|  10.3k|}
parser_aux.c:_asn1_set_down:
  112|  6.15k|{
  113|  6.15k|  if (node == NULL)
  ------------------
  |  Branch (113:7): [True: 0, False: 6.15k]
  ------------------
  114|      0|    return node;
  115|  6.15k|  node->down = down;
  116|  6.15k|  if (down)
  ------------------
  |  Branch (116:7): [True: 5.42k, False: 730]
  ------------------
  117|  5.42k|    down->left = node;
  118|  6.15k|  return node;
  119|  6.15k|}

_asn1_add_single_node:
   49|  24.6k|{
   50|  24.6k|  asn1_node punt;
   51|       |
   52|  24.6k|  punt = calloc (1, sizeof (struct asn1_node_st));
   53|  24.6k|  if (punt == NULL)
  ------------------
  |  Branch (53:7): [True: 0, False: 24.6k]
  ------------------
   54|      0|    return NULL;
   55|       |
   56|  24.6k|  punt->type = type;
   57|       |
   58|  24.6k|  return punt;
   59|  24.6k|}
_asn1_find_left:
   72|    838|{
   73|    838|  if ((node == NULL) || (node->left == NULL) || (node->left->down == node))
  ------------------
  |  Branch (73:7): [True: 0, False: 838]
  |  Branch (73:25): [True: 500, False: 338]
  |  Branch (73:49): [True: 338, False: 0]
  ------------------
   74|    838|    return NULL;
   75|       |
   76|      0|  return node->left;
   77|    838|}
asn1_array2tree:
  179|  1.06k|{
  180|  1.06k|  asn1_node p, p_last = NULL;
  181|  1.06k|  unsigned long k;
  182|  1.06k|  int move;
  183|  1.06k|  int result;
  184|  1.06k|  unsigned int type;
  185|  1.06k|  list_type *e_list = NULL;
  186|       |
  187|  1.06k|  if (errorDescription)
  ------------------
  |  Branch (187:7): [True: 1.06k, False: 0]
  ------------------
  188|  1.06k|    errorDescription[0] = 0;
  189|       |
  190|  1.06k|  if (*definitions != NULL)
  ------------------
  |  Branch (190:7): [True: 0, False: 1.06k]
  ------------------
  191|      0|    return ASN1_ELEMENT_NOT_EMPTY;
  ------------------
  |  |  133|      0|# define ASN1_ELEMENT_NOT_EMPTY		17
  ------------------
  192|       |
  193|  1.06k|  move = UP;
  ------------------
  |  |  129|  1.06k|# define UP     1
  ------------------
  194|       |
  195|  9.44k|  for (k = 0; array[k].value || array[k].type || array[k].name; k++)
  ------------------
  |  Branch (195:15): [True: 7.48k, False: 1.96k]
  |  Branch (195:33): [True: 823, False: 1.14k]
  |  Branch (195:50): [True: 78, False: 1.06k]
  ------------------
  196|  8.38k|    {
  197|  8.38k|      type = convert_old_type (array[k].type);
  198|       |
  199|  8.38k|      p = _asn1_add_static_node (&e_list, type & (~CONST_DOWN));
  ------------------
  |  |  168|  8.38k|# define CONST_DOWN        (1U<<29)
  ------------------
  200|  8.38k|      if (array[k].name)
  ------------------
  |  Branch (200:11): [True: 8.24k, False: 138]
  ------------------
  201|  8.24k|	_asn1_set_name (p, array[k].name);
  202|  8.38k|      if (array[k].value)
  ------------------
  |  Branch (202:11): [True: 7.48k, False: 901]
  ------------------
  203|  7.48k|	_asn1_set_value (p, array[k].value, strlen (array[k].value) + 1);
  204|       |
  205|  8.38k|      if (*definitions == NULL)
  ------------------
  |  Branch (205:11): [True: 1.05k, False: 7.32k]
  ------------------
  206|  1.05k|	*definitions = p;
  207|       |
  208|  8.38k|      if (move == DOWN)
  ------------------
  |  |  131|  8.38k|# define DOWN   3
  ------------------
  |  Branch (208:11): [True: 4.10k, False: 4.27k]
  ------------------
  209|  4.10k|	{
  210|  4.10k|	  if (p_last && p_last->down)
  ------------------
  |  Branch (210:8): [True: 3.95k, False: 155]
  |  Branch (210:18): [True: 258, False: 3.69k]
  ------------------
  211|    258|	    _asn1_delete_structure (e_list, &p_last->down, 0);
  212|  4.10k|	  _asn1_set_down (p_last, p);
  213|  4.10k|	}
  214|  4.27k|      else if (move == RIGHT)
  ------------------
  |  |  130|  4.27k|# define RIGHT  2
  ------------------
  |  Branch (214:16): [True: 2.98k, False: 1.29k]
  ------------------
  215|  2.98k|	{
  216|  2.98k|	  if (p_last && p_last->right)
  ------------------
  |  Branch (216:8): [True: 2.79k, False: 190]
  |  Branch (216:18): [True: 0, False: 2.79k]
  ------------------
  217|      0|	    _asn1_delete_structure (e_list, &p_last->right, 0);
  218|  2.98k|	  _asn1_set_right (p_last, p);
  219|  2.98k|	}
  220|       |
  221|  8.38k|      p_last = p;
  222|       |
  223|  8.38k|      if (type & CONST_DOWN)
  ------------------
  |  |  168|  8.38k|# define CONST_DOWN        (1U<<29)
  ------------------
  |  Branch (223:11): [True: 3.87k, False: 4.50k]
  ------------------
  224|  3.87k|	move = DOWN;
  ------------------
  |  |  131|  3.87k|# define DOWN   3
  ------------------
  225|  4.50k|      else if (type & CONST_RIGHT)
  ------------------
  |  |  169|  4.50k|# define CONST_RIGHT       (1U<<30)
  ------------------
  |  Branch (225:16): [True: 1.92k, False: 2.58k]
  ------------------
  226|  1.92k|	move = RIGHT;
  ------------------
  |  |  130|  1.92k|# define RIGHT  2
  ------------------
  227|  2.58k|      else
  228|  2.58k|	{
  229|  5.27k|	  while (p_last != *definitions)
  ------------------
  |  Branch (229:11): [True: 4.37k, False: 899]
  ------------------
  230|  4.37k|	    {
  231|  4.37k|	      p_last = _asn1_find_up (p_last);
  232|       |
  233|  4.37k|	      if (p_last == NULL)
  ------------------
  |  Branch (233:12): [True: 603, False: 3.77k]
  ------------------
  234|    603|		break;
  235|       |
  236|  3.77k|	      if (p_last->type & CONST_RIGHT)
  ------------------
  |  |  169|  3.77k|# define CONST_RIGHT       (1U<<30)
  ------------------
  |  Branch (236:12): [True: 1.07k, False: 2.69k]
  ------------------
  237|  1.07k|		{
  238|  1.07k|		  p_last->type &= ~CONST_RIGHT;
  ------------------
  |  |  169|  1.07k|# define CONST_RIGHT       (1U<<30)
  ------------------
  239|  1.07k|		  move = RIGHT;
  ------------------
  |  |  130|  1.07k|# define RIGHT  2
  ------------------
  240|  1.07k|		  break;
  241|  1.07k|		}
  242|  3.77k|	    }			/* while */
  243|  2.58k|	}
  244|  8.38k|    }				/* while */
  245|       |
  246|  1.06k|  if (p_last == *definitions)
  ------------------
  |  Branch (246:7): [True: 977, False: 87]
  ------------------
  247|    977|    {
  248|    977|      result = _asn1_check_identifier (*definitions);
  249|    977|      if (result == ASN1_SUCCESS)
  ------------------
  |  |  116|    977|# define ASN1_SUCCESS			0
  ------------------
  |  Branch (249:11): [True: 643, False: 334]
  ------------------
  250|    643|	{
  251|    643|	  _asn1_change_integer_value (*definitions);
  252|    643|	  result = _asn1_expand_object_id (&e_list, *definitions);
  253|    643|	}
  254|    977|    }
  255|     87|  else
  256|     87|    {
  257|     87|      result = ASN1_ARRAY_ERROR;
  ------------------
  |  |  132|     87|# define ASN1_ARRAY_ERROR		16
  ------------------
  258|     87|    }
  259|       |
  260|  1.06k|  if (errorDescription != NULL)
  ------------------
  |  Branch (260:7): [True: 1.06k, False: 0]
  ------------------
  261|  1.06k|    {
  262|  1.06k|      if (result == ASN1_IDENTIFIER_NOT_FOUND)
  ------------------
  |  |  119|  1.06k|# define ASN1_IDENTIFIER_NOT_FOUND	3
  ------------------
  |  Branch (262:11): [True: 328, False: 736]
  ------------------
  263|    328|	{
  264|    328|	  Estrcpy (errorDescription, ":: identifier '");
  ------------------
  |  |   29|    328|# define Estrcpy(x,y) _asn1_str_cpy(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y)
  |  |  ------------------
  |  |  |  |  315|    328|# define ASN1_MAX_ERROR_DESCRIPTION_SIZE 128
  |  |  ------------------
  ------------------
  265|    328|	  Estrcat (errorDescription, _asn1_identifierMissing);
  ------------------
  |  |   30|    328|# define Estrcat(x,y) _asn1_str_cat(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y)
  |  |  ------------------
  |  |  |  |  315|    328|# define ASN1_MAX_ERROR_DESCRIPTION_SIZE 128
  |  |  ------------------
  ------------------
  266|    328|	  Estrcat (errorDescription, "' not found");
  ------------------
  |  |   30|    328|# define Estrcat(x,y) _asn1_str_cat(x,ASN1_MAX_ERROR_DESCRIPTION_SIZE,y)
  |  |  ------------------
  |  |  |  |  315|    328|# define ASN1_MAX_ERROR_DESCRIPTION_SIZE 128
  |  |  ------------------
  ------------------
  267|    328|	}
  268|    736|      else
  269|    736|	errorDescription[0] = 0;
  270|  1.06k|    }
  271|       |
  272|  1.06k|  if (result != ASN1_SUCCESS)
  ------------------
  |  |  116|  1.06k|# define ASN1_SUCCESS			0
  ------------------
  |  Branch (272:7): [True: 564, False: 500]
  ------------------
  273|    564|    {
  274|    564|      _asn1_delete_list_and_nodes (e_list);
  275|    564|      *definitions = NULL;
  276|    564|    }
  277|    500|  else
  278|    500|    _asn1_delete_list (e_list);
  279|       |
  280|  1.06k|  return result;
  281|  1.06k|}
asn1_delete_structure:
  295|    500|{
  296|    500|  return _asn1_delete_structure (NULL, structure, 0);
  297|    500|}
_asn1_delete_structure:
  319|    838|{
  320|    838|  asn1_node p, p2, p3;
  321|       |
  322|    838|  if (*structure == NULL)
  ------------------
  |  Branch (322:7): [True: 0, False: 838]
  ------------------
  323|      0|    return ASN1_ELEMENT_NOT_FOUND;
  ------------------
  |  |  118|      0|# define ASN1_ELEMENT_NOT_FOUND		2
  ------------------
  324|       |
  325|    838|  p = *structure;
  326|  13.4k|  while (p)
  ------------------
  |  Branch (326:10): [True: 12.6k, False: 838]
  ------------------
  327|  12.6k|    {
  328|  12.6k|      if (p->down)
  ------------------
  |  Branch (328:11): [True: 5.91k, False: 6.74k]
  ------------------
  329|  5.91k|	{
  330|  5.91k|	  p = p->down;
  331|  5.91k|	}
  332|  6.74k|      else
  333|  6.74k|	{			/* no down */
  334|  6.74k|	  p2 = p->right;
  335|  6.74k|	  if (p != *structure)
  ------------------
  |  Branch (335:8): [True: 5.91k, False: 838]
  ------------------
  336|  5.91k|	    {
  337|  5.91k|	      p3 = _asn1_find_up (p);
  338|  5.91k|	      _asn1_set_down (p3, p2);
  339|  5.91k|	      if (e_list)
  ------------------
  |  Branch (339:12): [True: 171, False: 5.74k]
  ------------------
  340|    171|		_asn1_delete_node_from_list (e_list, p);
  341|  5.91k|	      _asn1_remove_node (p, flags);
  342|  5.91k|	      p = p3;
  343|  5.91k|	    }
  344|    838|	  else
  345|    838|	    {			/* p==root */
  346|    838|	      p3 = _asn1_find_left (p);
  347|    838|	      if (!p3)
  ------------------
  |  Branch (347:12): [True: 838, False: 0]
  ------------------
  348|    838|		{
  349|    838|		  p3 = _asn1_find_up (p);
  350|    838|		  if (p3)
  ------------------
  |  Branch (350:9): [True: 338, False: 500]
  ------------------
  351|    338|		    _asn1_set_down (p3, p2);
  352|    500|		  else
  353|    500|		    {
  354|    500|		      if (p->right)
  ------------------
  |  Branch (354:13): [True: 0, False: 500]
  ------------------
  355|      0|			p->right->left = NULL;
  356|    500|		    }
  357|    838|		}
  358|      0|	      else
  359|      0|		_asn1_set_right (p3, p2);
  360|    838|	      if (e_list)
  ------------------
  |  Branch (360:12): [True: 338, False: 500]
  ------------------
  361|    338|		_asn1_delete_node_from_list (e_list, p);
  362|    838|	      _asn1_remove_node (p, flags);
  363|    838|	      p = NULL;
  364|    838|	    }
  365|  6.74k|	}
  366|  12.6k|    }
  367|       |
  368|    838|  *structure = NULL;
  369|    838|  return ASN1_SUCCESS;
  ------------------
  |  |  116|    838|# define ASN1_SUCCESS			0
  ------------------
  370|    838|}