#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */
typedef struct TYPE_12__ TYPE_3__;
typedef struct TYPE_11__ TYPE_2__;
typedef struct TYPE_10__ TYPE_1__;

/* Type definitions */
struct TYPE_12__ {
  scalar_t__ type;
  int length;
  unsigned char const *data;
};
struct TYPE_11__ {
  scalar_t__ type;
  int length;
  unsigned char const *data;
};
struct TYPE_10__ {
  int length;
  unsigned char *data;
};
typedef int /*<<< orphan*/ BIO;
typedef TYPE_1__ ASN1_OCTET_STRING;
typedef int /*<<< orphan*/ ASN1_OBJECT;
typedef TYPE_2__ ASN1_INTEGER;
typedef TYPE_3__ ASN1_ENUMERATED;

/* Variables and functions */
int /*<<< orphan*/ ASN1_ENUMERATED_free(TYPE_3__ *);
int /*<<< orphan*/ ASN1_INTEGER_free(TYPE_2__ *);
int /*<<< orphan*/ ASN1_OBJECT_free(int /*<<< orphan*/ *);
int /*<<< orphan*/ ASN1_OCTET_STRING_free(TYPE_1__ *);
int ASN1_get_object(unsigned char const **, long *, int *, int *, long);
scalar_t__ BIO_dump_indent(int /*<<< orphan*/ *, char const *, long, int);
scalar_t__ BIO_printf(int /*<<< orphan*/ *, char *, unsigned char const, ...);
scalar_t__ BIO_puts(int /*<<< orphan*/ *, char *);
scalar_t__ BIO_write(int /*<<< orphan*/ *, char const *, int);
int V_ASN1_BMPSTRING;
int V_ASN1_BOOLEAN;
int V_ASN1_CONSTRUCTED;
int V_ASN1_ENUMERATED;
int V_ASN1_EOC;
int V_ASN1_GENERALIZEDTIME;
int V_ASN1_IA5STRING;
int V_ASN1_INTEGER;
scalar_t__ V_ASN1_NEG_ENUMERATED;
scalar_t__ V_ASN1_NEG_INTEGER;
int V_ASN1_NUMERICSTRING;
int V_ASN1_OBJECT;
int V_ASN1_OCTET_STRING;
int V_ASN1_PRINTABLESTRING;
int V_ASN1_T61STRING;
int V_ASN1_UTCTIME;
int V_ASN1_UTF8STRING;
int V_ASN1_VISIBLESTRING;
int /*<<< orphan*/ asn1_print_info(int /*<<< orphan*/ *, int, int, int, int);
TYPE_3__ *d2i_ASN1_ENUMERATED(int /*<<< orphan*/ *, unsigned char const **,
                              long);
TYPE_2__ *d2i_ASN1_INTEGER(int /*<<< orphan*/ *, unsigned char const **, long);
int /*<<< orphan*/ *d2i_ASN1_OBJECT(int /*<<< orphan*/ **,
                                    unsigned char const **, long);
TYPE_1__ *d2i_ASN1_OCTET_STRING(int /*<<< orphan*/ *, unsigned char const **,
                                long);
int /*<<< orphan*/ i2a_ASN1_OBJECT(int /*<<< orphan*/ *, int /*<<< orphan*/ *);
int asn1_parse2(BIO *bp, const unsigned char **pp, long length, int offset,
                int depth, int indent, int dump) {
  const unsigned char *p, *ep, *tot, *op, *opp;
  long len;
  int tag, xclass, ret = 0;
  int nl, hl, j, r;
  ASN1_OBJECT *o = NULL;
  ASN1_OCTET_STRING *os = NULL;
  int dump_indent, dump_cont = 0;
  if (depth > 128) {
    BIO_puts(bp, "BAD RECURSION DEPTH\n");
    return 0;
  }
  dump_indent = 6;
  p = *pp;
  tot = p + length;
  while (length > 0) {
    op = p;
    j = ASN1_get_object(&p, &len, &tag, &xclass, length);
    if (j & 0x80) {
      if (BIO_write(bp, "Error in encoding\n", 18) <= 0)
        goto end;
      ret = 0;
      goto end;
    }
    hl = (p - op);
    length -= hl;
    if (BIO_printf(bp, "%5ld:", (long)offset + (long)(op - *pp)) <= 0)
      goto end;
    if (j != (V_ASN1_CONSTRUCTED | 1)) {
      if (BIO_printf(bp, "d=%-2d hl=%ld l=%4ld ", depth, (long)hl, len) <= 0)
        goto end;
    } else {
      if (BIO_printf(bp, "d=%-2d hl=%ld l=inf  ", depth, (long)hl) <= 0)
        goto end;
    }
    if (!asn1_print_info(bp, tag, xclass, j, (indent) ? depth : 0))
      goto end;
    if (j & V_ASN1_CONSTRUCTED) {
      const unsigned char *sp = p;
      ep = p + len;
      if (BIO_write(bp, "\n", 1) <= 0)
        goto end;
      if (len > length) {
        BIO_printf(bp, "length is greater than %ld\n", length);
        ret = 0;
        goto end;
      }
      if ((j == 0x21) && (len == 0)) {
        for (;;) {
          r = asn1_parse2(bp, &p, (long)(tot - p), offset + (p - *pp),
                          depth + 1, indent, dump);
          if (r == 0) {
            ret = 0;
            goto end;
          }
          if ((r == 2) || (p >= tot)) {
            len = p - sp;
            break;
          }
        }
      } else {
        long tmp = len;
        while (p < ep) {
          sp = p;
          r = asn1_parse2(bp, &p, tmp, offset + (p - *pp), depth + 1, indent,
                          dump);
          if (r == 0) {
            ret = 0;
            goto end;
          }
          tmp -= p - sp;
        }
      }
    } else if (xclass != 0) {
      p += len;
      if (BIO_write(bp, "\n", 1) <= 0)
        goto end;
    } else {
      nl = 0;
      if ((tag == V_ASN1_PRINTABLESTRING) || (tag == V_ASN1_T61STRING) ||
          (tag == V_ASN1_IA5STRING) || (tag == V_ASN1_VISIBLESTRING) ||
          (tag == V_ASN1_NUMERICSTRING) || (tag == V_ASN1_UTF8STRING) ||
          (tag == V_ASN1_UTCTIME) || (tag == V_ASN1_GENERALIZEDTIME)) {
        if (BIO_write(bp, ":", 1) <= 0)
          goto end;
        if ((len > 0) && BIO_write(bp, (const char *)p, (int)len) != (int)len)
          goto end;
      } else if (tag == V_ASN1_OBJECT) {
        opp = op;
        if (d2i_ASN1_OBJECT(&o, &opp, len + hl) != NULL) {
          if (BIO_write(bp, ":", 1) <= 0)
            goto end;
          i2a_ASN1_OBJECT(bp, o);
        } else {
          if (BIO_puts(bp, ":BAD OBJECT") <= 0)
            goto end;
          dump_cont = 1;
        }
      } else if (tag == V_ASN1_BOOLEAN) {
        if (len != 1) {
          if (BIO_puts(bp, ":BAD BOOLEAN") <= 0)
            goto end;
          dump_cont = 1;
        }
        if (len > 0)
          BIO_printf(bp, ":%u", p[0]);
      } else if (tag == V_ASN1_BMPSTRING) {
      } else if (tag == V_ASN1_OCTET_STRING) {
        int i, printable = 1;
        opp = op;
        os = d2i_ASN1_OCTET_STRING(NULL, &opp, len + hl);
        if (os != NULL && os->length > 0) {
          opp = os->data;
          for (i = 0; i < os->length; i++) {
            if (((opp[i] < ' ') && (opp[i] != '\n') && (opp[i] != '\r') &&
                 (opp[i] != '\t')) ||
                (opp[i] > '~')) {
              printable = 0;
              break;
            }
          }
          if (printable) {
            if (BIO_write(bp, ":", 1) <= 0)
              goto end;
            if (BIO_write(bp, (const char *)opp, os->length) <= 0)
              goto end;
          } else if (!dump) {
            if (BIO_write(bp, "[HEX DUMP]:", 11) <= 0)
              goto end;
            for (i = 0; i < os->length; i++) {
              if (BIO_printf(bp, "%02X", opp[i]) <= 0)
                goto end;
            }
          } else {
            if (!nl) {
              if (BIO_write(bp, "\n", 1) <= 0)
                goto end;
            }
            if (BIO_dump_indent(
                    bp, (const char *)opp,
                    ((dump == -1 || dump > os->length) ? os->length : dump),
                    dump_indent) <= 0)
              goto end;
            nl = 1;
          }
        }
        ASN1_OCTET_STRING_free(os);
        os = NULL;
      } else if (tag == V_ASN1_INTEGER) {
        ASN1_INTEGER *bs;
        int i;
        opp = op;
        bs = d2i_ASN1_INTEGER(NULL, &opp, len + hl);
        if (bs != NULL) {
          if (BIO_write(bp, ":", 1) <= 0)
            goto end;
          if (bs->type == V_ASN1_NEG_INTEGER)
            if (BIO_write(bp, "-", 1) <= 0)
              goto end;
          for (i = 0; i < bs->length; i++) {
            if (BIO_printf(bp, "%02X", bs->data[i]) <= 0)
              goto end;
          }
          if (bs->length == 0) {
            if (BIO_write(bp, "00", 2) <= 0)
              goto end;
          }
        } else {
          if (BIO_puts(bp, ":BAD INTEGER") <= 0)
            goto end;
          dump_cont = 1;
        }
        ASN1_INTEGER_free(bs);
      } else if (tag == V_ASN1_ENUMERATED) {
        ASN1_ENUMERATED *bs;
        int i;
        opp = op;
        bs = d2i_ASN1_ENUMERATED(NULL, &opp, len + hl);
        if (bs != NULL) {
          if (BIO_write(bp, ":", 1) <= 0)
            goto end;
          if (bs->type == V_ASN1_NEG_ENUMERATED)
            if (BIO_write(bp, "-", 1) <= 0)
              goto end;
          for (i = 0; i < bs->length; i++) {
            if (BIO_printf(bp, "%02X", bs->data[i]) <= 0)
              goto end;
          }
          if (bs->length == 0) {
            if (BIO_write(bp, "00", 2) <= 0)
              goto end;
          }
        } else {
          if (BIO_puts(bp, ":BAD ENUMERATED") <= 0)
            goto end;
          dump_cont = 1;
        }
        ASN1_ENUMERATED_free(bs);
      } else if (len > 0 && dump) {
        if (!nl) {
          if (BIO_write(bp, "\n", 1) <= 0)
            goto end;
        }
        if (BIO_dump_indent(bp, (const char *)p,
                            ((dump == -1 || dump > len) ? len : dump),
                            dump_indent) <= 0)
          goto end;
        nl = 1;
      }
      if (dump_cont) {
        int i;
        const unsigned char *tmp = op + hl;
        if (BIO_puts(bp, ":[") <= 0)
          goto end;
        for (i = 0; i < len; i++) {
          if (BIO_printf(bp, "%02X", tmp[i]) <= 0)
            goto end;
        }
        if (BIO_puts(bp, "]") <= 0)
          goto end;
      }
      if (!nl) {
        if (BIO_write(bp, "\n", 1) <= 0)
          goto end;
      }
      p += len;
      if ((tag == V_ASN1_EOC) && (xclass == 0)) {
        ret = 2;
        goto end;
      }
    }
    length -= len;
  }
  ret = 1;
end:
  ASN1_OBJECT_free(o);
  ASN1_OCTET_STRING_free(os);
  *pp = p;
  return (ret);
}


x86 assembly (clang, -O0):
<asn1_parse2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x6c(%rbp)
movq   $0x0,-0x88(%rbp)
movq   $0x0,-0x90(%rbp)
movl   $0x0,-0x98(%rbp)
cmpl   $0x80,-0x28(%rbp)
jle    1275 <asn1_parse2+0x75>
mov    -0x10(%rbp),%rdi
lea    0x1d9c(%rip),%rsi
call   1100 <BIO_puts@plt>
movl   $0x0,-0x4(%rbp)
jmp    2126 <asn1_parse2+0xf26>
movl   $0x6,-0x94(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x20(%rbp)
jle    20f6 <asn1_parse2+0xef6>
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%r8
lea    -0x38(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x64(%rbp),%rdx
lea    -0x68(%rbp),%rcx
call   10c0 <ASN1_get_object@plt>
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     1306 <asn1_parse2+0x106>
mov    -0x10(%rbp),%rdi
lea    0x1d34(%rip),%rsi
mov    $0x12,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     12fa <asn1_parse2+0xfa>
jmp    20fd <asn1_parse2+0xefd>
movl   $0x0,-0x6c(%rbp)
jmp    20fd <asn1_parse2+0xefd>
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x74(%rbp)
movslq -0x74(%rbp),%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
movslq -0x24(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x18(%rbp),%rdx
mov    (%rdx),%rdx
sub    %rdx,%rcx
add    %rcx,%rax
lea    0x1ce5(%rip),%rsi
movzbl %al,%edx
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     135c <asn1_parse2+0x15c>
jmp    20fd <asn1_parse2+0xefd>
mov    -0x78(%rbp),%eax
mov    0x3c0a(%rip),%rcx
mov    (%rcx),%ecx
or     $0x1,%ecx
cmp    %ecx,%eax
je     13a7 <asn1_parse2+0x1a7>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%eax
movslq -0x74(%rbp),%rcx
mov    -0x60(%rbp),%r8
lea    0x1ca5(%rip),%rsi
movzbl %al,%edx
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     13a2 <asn1_parse2+0x1a2>
jmp    20fd <asn1_parse2+0xefd>
jmp    13d7 <asn1_parse2+0x1d7>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%eax
movslq -0x74(%rbp),%rcx
lea    0x1c8b(%rip),%rsi
movzbl %al,%edx
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     13d2 <asn1_parse2+0x1d2>
jmp    20fd <asn1_parse2+0xefd>
jmp    13d7 <asn1_parse2+0x1d7>
mov    -0x10(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0xe4(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0xe0(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0xdc(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1415 <asn1_parse2+0x215>
mov    -0x28(%rbp),%eax
mov    %eax,-0xf4(%rbp)
jmp    1422 <asn1_parse2+0x222>
xor    %eax,%eax
mov    %eax,-0xf4(%rbp)
jmp    1422 <asn1_parse2+0x222>
mov    -0xdc(%rbp),%ecx
mov    -0xe0(%rbp),%edx
mov    -0xe4(%rbp),%esi
mov    -0xf0(%rbp),%rdi
mov    -0xf4(%rbp),%r8d
call   10f0 <asn1_print_info@plt>
cmp    $0x0,%eax
jne    1455 <asn1_parse2+0x255>
jmp    20fd <asn1_parse2+0xefd>
mov    -0x78(%rbp),%eax
mov    0x3b11(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     162d <asn1_parse2+0x42d>
mov    -0x38(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x38(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rdi
lea    0x1b87(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     14a5 <asn1_parse2+0x2a5>
jmp    20fd <asn1_parse2+0xefd>
mov    -0x60(%rbp),%rax
cmp    -0x20(%rbp),%rax
jle    14d8 <asn1_parse2+0x2d8>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rax
lea    0x1b98(%rip),%rsi
movzbl %al,%edx
mov    $0x0,%al
call   1060 <BIO_printf@plt>
movl   $0x0,-0x6c(%rbp)
jmp    20fd <asn1_parse2+0xefd>
cmpl   $0x21,-0x78(%rbp)
jne    1585 <asn1_parse2+0x385>
cmpq   $0x0,-0x60(%rbp)
jne    1585 <asn1_parse2+0x385>
jmp    14f2 <asn1_parse2+0x2f2>
mov    -0x10(%rbp),%rdi
mov    -0x48(%rbp),%rdx
mov    -0x38(%rbp),%rax
sub    %rax,%rdx
movslq -0x24(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rsi
mov    (%rsi),%rsi
sub    %rsi,%rcx
add    %rcx,%rax
mov    %eax,%ecx
mov    -0x28(%rbp),%r8d
add    $0x1,%r8d
mov    -0x2c(%rbp),%r9d
mov    0x10(%rbp),%eax
lea    -0x38(%rbp),%rsi
mov    %eax,(%rsp)
call   1070 <asn1_parse2@plt>
mov    %eax,-0x7c(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jne    154c <asn1_parse2+0x34c>
movl   $0x0,-0x6c(%rbp)
jmp    20fd <asn1_parse2+0xefd>
cmpl   $0x2,-0x7c(%rbp)
je     1564 <asn1_parse2+0x364>
mov    -0x38(%rbp),%rax
cmp    -0x48(%rbp),%rax
jb     157b <asn1_parse2+0x37b>
mov    -0x38(%rbp),%rax
mov    -0xa0(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x60(%rbp)
jmp    1580 <asn1_parse2+0x380>
jmp    14f2 <asn1_parse2+0x2f2>
jmp    1628 <asn1_parse2+0x428>
mov    -0x60(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    1623 <asn1_parse2+0x423>
mov    -0x38(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0xa8(%rbp),%rdx
movslq -0x24(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rsi
mov    (%rsi),%rsi
sub    %rsi,%rcx
add    %rcx,%rax
mov    %eax,%ecx
mov    -0x28(%rbp),%r8d
add    $0x1,%r8d
mov    -0x2c(%rbp),%r9d
mov    0x10(%rbp),%eax
lea    -0x38(%rbp),%rsi
mov    %eax,(%rsp)
call   1070 <asn1_parse2@plt>
mov    %eax,-0x7c(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jne    15ff <asn1_parse2+0x3ff>
movl   $0x0,-0x6c(%rbp)
jmp    20fd <asn1_parse2+0xefd>
mov    -0x38(%rbp),%rcx
mov    -0xa0(%rbp),%rax
sub    %rax,%rcx
mov    -0xa8(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0xa8(%rbp)
jmp    1590 <asn1_parse2+0x390>
jmp    1628 <asn1_parse2+0x428>
jmp    20e2 <asn1_parse2+0xee2>
cmpl   $0x0,-0x68(%rbp)
je     166c <asn1_parse2+0x46c>
mov    -0x60(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rdi
lea    0x19c5(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1667 <asn1_parse2+0x467>
jmp    20fd <asn1_parse2+0xefd>
jmp    20dd <asn1_parse2+0xedd>
movl   $0x0,-0x70(%rbp)
mov    -0x64(%rbp),%eax
mov    0x3903(%rip),%rcx
cmp    (%rcx),%eax
je     1703 <asn1_parse2+0x503>
mov    -0x64(%rbp),%eax
mov    0x3909(%rip),%rcx
cmp    (%rcx),%eax
je     1703 <asn1_parse2+0x503>
mov    -0x64(%rbp),%eax
mov    0x38e7(%rip),%rcx
cmp    (%rcx),%eax
je     1703 <asn1_parse2+0x503>
mov    -0x64(%rbp),%eax
mov    0x391d(%rip),%rcx
cmp    (%rcx),%eax
je     1703 <asn1_parse2+0x503>
mov    -0x64(%rbp),%eax
mov    0x3923(%rip),%rcx
cmp    (%rcx),%eax
je     1703 <asn1_parse2+0x503>
mov    -0x64(%rbp),%eax
mov    0x38e9(%rip),%rcx
cmp    (%rcx),%eax
je     1703 <asn1_parse2+0x503>
mov    -0x64(%rbp),%eax
mov    0x3877(%rip),%rcx
cmp    (%rcx),%eax
je     1703 <asn1_parse2+0x503>
mov    -0x64(%rbp),%eax
mov    0x38bd(%rip),%rcx
cmp    (%rcx),%eax
jne    175f <asn1_parse2+0x55f>
mov    -0x10(%rbp),%rdi
lea    0x198f(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1727 <asn1_parse2+0x527>
jmp    20fd <asn1_parse2+0xefd>
cmpq   $0x0,-0x60(%rbp)
jle    175a <asn1_parse2+0x55a>
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x60(%rbp),%rax
mov    %eax,%edx
call   1120 <BIO_write@plt>
mov    -0x60(%rbp),%rcx
movslq %ecx,%rcx
cmp    %rcx,%rax
je     175a <asn1_parse2+0x55a>
jmp    20fd <asn1_parse2+0xefd>
jmp    1fa8 <asn1_parse2+0xda8>
mov    -0x64(%rbp),%eax
mov    0x385f(%rip),%rcx
cmp    (%rcx),%eax
jne    1805 <asn1_parse2+0x605>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rdx
movslq -0x74(%rbp),%rax
add    %rax,%rdx
lea    -0x88(%rbp),%rdi
lea    -0x58(%rbp),%rsi
call   1080 <d2i_ASN1_OBJECT@plt>
cmp    $0x0,%rax
je     17d7 <asn1_parse2+0x5d7>
mov    -0x10(%rbp),%rdi
lea    0x18f4(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     17c2 <asn1_parse2+0x5c2>
jmp    20fd <asn1_parse2+0xefd>
mov    -0x10(%rbp),%rdi
mov    -0x88(%rbp),%rsi
call   1030 <i2a_ASN1_OBJECT@plt>
jmp    1800 <asn1_parse2+0x600>
mov    -0x10(%rbp),%rdi
lea    0x1894(%rip),%rsi
call   1100 <BIO_puts@plt>
cmp    $0x0,%rax
jg     17f6 <asn1_parse2+0x5f6>
jmp    20fd <asn1_parse2+0xefd>
movl   $0x1,-0x98(%rbp)
jmp    1fa3 <asn1_parse2+0xda3>
mov    -0x64(%rbp),%eax
mov    0x3781(%rip),%rcx
cmp    (%rcx),%eax
jne    1874 <asn1_parse2+0x674>
cmpq   $0x1,-0x60(%rbp)
je     184b <asn1_parse2+0x64b>
mov    -0x10(%rbp),%rdi
lea    0x1855(%rip),%rsi
call   1100 <BIO_puts@plt>
cmp    $0x0,%rax
jg     1841 <asn1_parse2+0x641>
jmp    20fd <asn1_parse2+0xefd>
movl   $0x1,-0x98(%rbp)
cmpq   $0x0,-0x60(%rbp)
jle    186f <asn1_parse2+0x66f>
mov    -0x10(%rbp),%rdi
mov    -0x38(%rbp),%rax
lea    0x182a(%rip),%rsi
movzbl (%rax),%edx
mov    $0x0,%al
call   1060 <BIO_printf@plt>
jmp    1f9e <asn1_parse2+0xd9e>
mov    -0x64(%rbp),%eax
mov    0x36da(%rip),%rcx
cmp    (%rcx),%eax
jne    188b <asn1_parse2+0x68b>
jmp    1f99 <asn1_parse2+0xd99>
mov    -0x64(%rbp),%eax
mov    0x36d3(%rip),%rcx
cmp    (%rcx),%eax
jne    1b90 <asn1_parse2+0x990>
movl   $0x1,-0xb0(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rdx
movslq -0x74(%rbp),%rax
add    %rax,%rdx
xor    %eax,%eax
mov    %eax,%edi
lea    -0x58(%rbp),%rsi
call   1040 <d2i_ASN1_OCTET_STRING@plt>
mov    %rax,-0x90(%rbp)
cmpq   $0x0,-0x90(%rbp)
je     1b74 <asn1_parse2+0x974>
mov    -0x90(%rbp),%rax
cmpl   $0x0,(%rax)
jle    1b74 <asn1_parse2+0x974>
mov    -0x90(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x58(%rbp)
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x90(%rbp),%rcx
cmp    (%rcx),%eax
jge    19ba <asn1_parse2+0x7ba>
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jge    197a <asn1_parse2+0x77a>
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
je     197a <asn1_parse2+0x77a>
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0xd,%eax
je     197a <asn1_parse2+0x77a>
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x9,%eax
jne    1992 <asn1_parse2+0x792>
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x7e,%eax
jle    19a1 <asn1_parse2+0x7a1>
movl   $0x0,-0xb0(%rbp)
jmp    19ba <asn1_parse2+0x7ba>
jmp    19a6 <asn1_parse2+0x7a6>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1905 <asn1_parse2+0x705>
cmpl   $0x0,-0xb0(%rbp)
je     1a15 <asn1_parse2+0x815>
mov    -0x10(%rbp),%rdi
lea    0x16cb(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     19eb <asn1_parse2+0x7eb>
jmp    20fd <asn1_parse2+0xefd>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x90(%rbp),%rax
mov    (%rax),%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1a10 <asn1_parse2+0x810>
jmp    20fd <asn1_parse2+0xefd>
jmp    1b6f <asn1_parse2+0x96f>
cmpl   $0x0,0x10(%rbp)
jne    1ab0 <asn1_parse2+0x8b0>
mov    -0x10(%rbp),%rdi
lea    0x1669(%rip),%rsi
mov    $0xb,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1a43 <asn1_parse2+0x843>
jmp    20fd <asn1_parse2+0xefd>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    -0x90(%rbp),%rcx
cmp    (%rcx),%eax
jge    1aab <asn1_parse2+0x8ab>
mov    -0x10(%rbp),%rdi
mov    -0x58(%rbp),%rax
movslq -0xac(%rbp),%rcx
lea    0x1627(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     1a92 <asn1_parse2+0x892>
jmp    20fd <asn1_parse2+0xefd>
jmp    1a97 <asn1_parse2+0x897>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1a4d <asn1_parse2+0x84d>
jmp    1b6a <asn1_parse2+0x96a>
cmpl   $0x0,-0x70(%rbp)
jne    1ae3 <asn1_parse2+0x8e3>
mov    -0x10(%rbp),%rdi
lea    0x154e(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1ade <asn1_parse2+0x8de>
jmp    20fd <asn1_parse2+0xefd>
jmp    1ae3 <asn1_parse2+0x8e3>
mov    -0x10(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x100(%rbp)
cmpl   $0xffffffff,0x10(%rbp)
je     1b15 <asn1_parse2+0x915>
mov    0x10(%rbp),%eax
mov    -0x90(%rbp),%rcx
cmp    (%rcx),%eax
jle    1b29 <asn1_parse2+0x929>
mov    -0x90(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x10c(%rbp)
jmp    1b32 <asn1_parse2+0x932>
mov    0x10(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x100(%rbp),%rsi
mov    -0x108(%rbp),%rdi
mov    -0x10c(%rbp),%eax
movslq %eax,%rdx
mov    -0x94(%rbp),%ecx
call   10d0 <BIO_dump_indent@plt>
cmp    $0x0,%rax
jg     1b63 <asn1_parse2+0x963>
jmp    20fd <asn1_parse2+0xefd>
movl   $0x1,-0x70(%rbp)
jmp    1b6f <asn1_parse2+0x96f>
jmp    1b74 <asn1_parse2+0x974>
mov    -0x90(%rbp),%rdi
call   1050 <ASN1_OCTET_STRING_free@plt>
movq   $0x0,-0x90(%rbp)
jmp    1f94 <asn1_parse2+0xd94>
mov    -0x64(%rbp),%eax
mov    0x3416(%rip),%rcx
cmp    (%rcx),%eax
jne    1d27 <asn1_parse2+0xb27>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rdx
movslq -0x74(%rbp),%rax
add    %rax,%rdx
xor    %eax,%eax
mov    %eax,%edi
lea    -0x58(%rbp),%rsi
call   10b0 <d2i_ASN1_INTEGER@plt>
mov    %rax,-0xb8(%rbp)
cmpq   $0x0,-0xb8(%rbp)
je     1ced <asn1_parse2+0xaed>
mov    -0x10(%rbp),%rdi
lea    0x14bb(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1bfb <asn1_parse2+0x9fb>
jmp    20fd <asn1_parse2+0xefd>
mov    -0xb8(%rbp),%rax
mov    (%rax),%rax
mov    0x336c(%rip),%rcx
cmp    (%rcx),%rax
jne    1c3e <asn1_parse2+0xa3e>
mov    -0x10(%rbp),%rdi
lea    0x1484(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1c39 <asn1_parse2+0xa39>
jmp    20fd <asn1_parse2+0xefd>
jmp    1c3e <asn1_parse2+0xa3e>
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0xb8(%rbp),%rcx
cmp    0x8(%rcx),%eax
jge    1cae <asn1_parse2+0xaae>
mov    -0x10(%rbp),%rdi
mov    -0xb8(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0xbc(%rbp),%rcx
lea    0x1424(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     1c95 <asn1_parse2+0xa95>
jmp    20fd <asn1_parse2+0xefd>
jmp    1c9a <asn1_parse2+0xa9a>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1c48 <asn1_parse2+0xa48>
mov    -0xb8(%rbp),%rax
cmpl   $0x0,0x8(%rax)
jne    1ce8 <asn1_parse2+0xae8>
mov    -0x10(%rbp),%rdi
lea    0x13dc(%rip),%rsi
mov    $0x2,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1ce3 <asn1_parse2+0xae3>
jmp    20fd <asn1_parse2+0xefd>
jmp    1ce8 <asn1_parse2+0xae8>
jmp    1d16 <asn1_parse2+0xb16>
mov    -0x10(%rbp),%rdi
lea    0x13b1(%rip),%rsi
call   1100 <BIO_puts@plt>
cmp    $0x0,%rax
jg     1d0c <asn1_parse2+0xb0c>
jmp    20fd <asn1_parse2+0xefd>
movl   $0x1,-0x98(%rbp)
mov    -0xb8(%rbp),%rdi
call   1110 <ASN1_INTEGER_free@plt>
jmp    1f8f <asn1_parse2+0xd8f>
mov    -0x64(%rbp),%eax
mov    0x326f(%rip),%rcx
cmp    (%rcx),%eax
jne    1ebe <asn1_parse2+0xcbe>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rdx
movslq -0x74(%rbp),%rax
add    %rax,%rdx
xor    %eax,%eax
mov    %eax,%edi
lea    -0x58(%rbp),%rsi
call   1090 <d2i_ASN1_ENUMERATED@plt>
mov    %rax,-0xc8(%rbp)
cmpq   $0x0,-0xc8(%rbp)
je     1e84 <asn1_parse2+0xc84>
mov    -0x10(%rbp),%rdi
lea    0x1324(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1d92 <asn1_parse2+0xb92>
jmp    20fd <asn1_parse2+0xefd>
mov    -0xc8(%rbp),%rax
mov    (%rax),%rax
mov    0x3235(%rip),%rcx
cmp    (%rcx),%rax
jne    1dd5 <asn1_parse2+0xbd5>
mov    -0x10(%rbp),%rdi
lea    0x12ed(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1dd0 <asn1_parse2+0xbd0>
jmp    20fd <asn1_parse2+0xefd>
jmp    1dd5 <asn1_parse2+0xbd5>
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
mov    -0xc8(%rbp),%rcx
cmp    0x8(%rcx),%eax
jge    1e45 <asn1_parse2+0xc45>
mov    -0x10(%rbp),%rdi
mov    -0xc8(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0xcc(%rbp),%rcx
lea    0x128d(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     1e2c <asn1_parse2+0xc2c>
jmp    20fd <asn1_parse2+0xefd>
jmp    1e31 <asn1_parse2+0xc31>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1ddf <asn1_parse2+0xbdf>
mov    -0xc8(%rbp),%rax
cmpl   $0x0,0x8(%rax)
jne    1e7f <asn1_parse2+0xc7f>
mov    -0x10(%rbp),%rdi
lea    0x1245(%rip),%rsi
mov    $0x2,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1e7a <asn1_parse2+0xc7a>
jmp    20fd <asn1_parse2+0xefd>
jmp    1e7f <asn1_parse2+0xc7f>
jmp    1ead <asn1_parse2+0xcad>
mov    -0x10(%rbp),%rdi
lea    0x1227(%rip),%rsi
call   1100 <BIO_puts@plt>
cmp    $0x0,%rax
jg     1ea3 <asn1_parse2+0xca3>
jmp    20fd <asn1_parse2+0xefd>
movl   $0x1,-0x98(%rbp)
mov    -0xc8(%rbp),%rdi
call   10a0 <ASN1_ENUMERATED_free@plt>
jmp    1f8a <asn1_parse2+0xd8a>
cmpq   $0x0,-0x60(%rbp)
jle    1f85 <asn1_parse2+0xd85>
cmpl   $0x0,0x10(%rbp)
je     1f85 <asn1_parse2+0xd85>
cmpl   $0x0,-0x70(%rbp)
jne    1f06 <asn1_parse2+0xd06>
mov    -0x10(%rbp),%rdi
lea    0x112b(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1f01 <asn1_parse2+0xd01>
jmp    20fd <asn1_parse2+0xefd>
jmp    1f06 <asn1_parse2+0xd06>
mov    -0x10(%rbp),%rax
mov    %rax,-0x120(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x118(%rbp)
cmpl   $0xffffffff,0x10(%rbp)
je     1f34 <asn1_parse2+0xd34>
movslq 0x10(%rbp),%rax
cmp    -0x60(%rbp),%rax
jle    1f44 <asn1_parse2+0xd44>
mov    -0x60(%rbp),%rax
mov    %rax,-0x128(%rbp)
jmp    1f4f <asn1_parse2+0xd4f>
movslq 0x10(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x118(%rbp),%rsi
mov    -0x120(%rbp),%rdi
mov    -0x128(%rbp),%rdx
mov    -0x94(%rbp),%ecx
call   10d0 <BIO_dump_indent@plt>
cmp    $0x0,%rax
jg     1f7e <asn1_parse2+0xd7e>
jmp    20fd <asn1_parse2+0xefd>
movl   $0x1,-0x70(%rbp)
jmp    1f8a <asn1_parse2+0xd8a>
jmp    1f8f <asn1_parse2+0xd8f>
jmp    1f94 <asn1_parse2+0xd94>
jmp    1f99 <asn1_parse2+0xd99>
jmp    1f9e <asn1_parse2+0xd9e>
jmp    1fa3 <asn1_parse2+0xda3>
jmp    1fa8 <asn1_parse2+0xda8>
cmpl   $0x0,-0x98(%rbp)
je     2071 <asn1_parse2+0xe71>
mov    -0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0xd8(%rbp)
mov    -0x10(%rbp),%rdi
lea    0x10f4(%rip),%rsi
call   1100 <BIO_puts@plt>
cmp    $0x0,%rax
jg     1fe6 <asn1_parse2+0xde6>
jmp    20fd <asn1_parse2+0xefd>
movl   $0x0,-0xd0(%rbp)
movslq -0xd0(%rbp),%rax
cmp    -0x60(%rbp),%rax
jge    204d <asn1_parse2+0xe4d>
mov    -0x10(%rbp),%rdi
mov    -0xd8(%rbp),%rax
movslq -0xd0(%rbp),%rcx
lea    0x1085(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     2034 <asn1_parse2+0xe34>
jmp    20fd <asn1_parse2+0xefd>
jmp    2039 <asn1_parse2+0xe39>
mov    -0xd0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd0(%rbp)
jmp    1ff0 <asn1_parse2+0xdf0>
mov    -0x10(%rbp),%rdi
lea    0x1071(%rip),%rsi
call   1100 <BIO_puts@plt>
cmp    $0x0,%rax
jg     206c <asn1_parse2+0xe6c>
jmp    20fd <asn1_parse2+0xefd>
jmp    2071 <asn1_parse2+0xe71>
cmpl   $0x0,-0x70(%rbp)
jne    20a4 <asn1_parse2+0xea4>
mov    -0x10(%rbp),%rdi
lea    0xf8d(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     209f <asn1_parse2+0xe9f>
jmp    20fd <asn1_parse2+0xefd>
jmp    20a4 <asn1_parse2+0xea4>
mov    -0x60(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x64(%rbp),%eax
mov    0x2f3e(%rip),%rcx
cmp    (%rcx),%eax
jne    20d8 <asn1_parse2+0xed8>
cmpl   $0x0,-0x68(%rbp)
jne    20d8 <asn1_parse2+0xed8>
movl   $0x2,-0x6c(%rbp)
jmp    20fd <asn1_parse2+0xefd>
jmp    20dd <asn1_parse2+0xedd>
jmp    20e2 <asn1_parse2+0xee2>
mov    -0x60(%rbp),%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
jmp    1296 <asn1_parse2+0x96>
movl   $0x1,-0x6c(%rbp)
mov    -0x88(%rbp),%rdi
call   10e0 <ASN1_OBJECT_free@plt>
mov    -0x90(%rbp),%rdi
call   1050 <ASN1_OCTET_STRING_free@plt>
mov    -0x38(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<asn1_parse2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rdi,%r15
movq   $0x0,0x58(%rsp)
cmp    $0x81,%r8d
jl     123c <asn1_parse2+0x3c>
lea    0xdd3(%rip),%rsi
mov    %r15,%rdi
call   1100 <BIO_puts@plt>
xor    %ebx,%ebx
jmp    1c6f <asn1_parse2+0xa6f>
mov    %rdx,%r13
mov    %rsi,%r14
mov    %ecx,0x3c(%rsp)
mov    (%rsi),%rbx
mov    %rbx,0x18(%rsp)
test   %rdx,%rdx
jle    1c2d <asn1_parse2+0xa2d>
mov    %r9d,%r12d
mov    %r8d,%ebp
mov    %r14,0x8(%rsp)
test   %r9d,%r9d
mov    %r8d,%eax
cmove  %r9d,%eax
mov    %eax,0x64(%rsp)
lea    0x18(%rsp),%rdi
lea    0x10(%rsp),%rsi
lea    0x38(%rsp),%rdx
lea    0x34(%rsp),%rcx
mov    %r13,%r8
call   10c0 <ASN1_get_object@plt>
mov    %eax,%r14d
test   $0x80,%r14b
jne    1c37 <asn1_parse2+0xa37>
lea    (%rbx,%r13,1),%rax
mov    %rax,0x78(%rsp)
mov    0x3c(%rsp),%eax
mov    %ebp,%ecx
add    $0x1,%ecx
mov    %ecx,0x54(%rsp)
movslq 0xc0(%rsp),%rcx
mov    %rcx,0x70(%rsp)
lea    0xd65(%rip),%rsi
movl   $0x0,0x24(%rsp)
mov    %r12d,0x50(%rsp)
mov    %ebp,0x60(%rsp)
mov    %rax,0x80(%rsp)
mov    0x18(%rsp),%ebp
add    %ebx,%eax
mov    0x8(%rsp),%rcx
sub    (%rcx),%eax
movzbl %al,%edx
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1c91 <asn1_parse2+0xa91>
mov    %rbx,0x40(%rsp)
sub    %ebx,%ebp
movslq %ebp,%rcx
mov    0x2c60(%rip),%rax
mov    (%rax),%eax
or     $0x1,%eax
mov    0x60(%rsp),%ebp
movzbl %bpl,%edx
cmp    %eax,%r14d
jne    1340 <asn1_parse2+0x140>
xor    %r12d,%r12d
mov    %r15,%rdi
lea    0xd15(%rip),%rsi
mov    %rcx,%rbx
xor    %eax,%eax
call   1060 <BIO_printf@plt>
jmp    135c <asn1_parse2+0x15c>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%r8
xor    %r12d,%r12d
mov    %r15,%rdi
lea    0xcdc(%rip),%rsi
mov    %rcx,%rbx
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1c4e <asn1_parse2+0xa4e>
mov    0x38(%rsp),%esi
mov    0x34(%rsp),%edx
mov    %r15,%rdi
mov    %r14d,%ecx
mov    0x64(%rsp),%r8d
call   10f0 <asn1_print_info@plt>
test   %eax,%eax
je     1c4b <asn1_parse2+0xa4b>
sub    %rbx,%r13
mov    0x2be1(%rip),%rax
test   %r14d,(%rax)
je     144e <asn1_parse2+0x24e>
mov    %r15,%rdi
mov    0x18(%rsp),%rbp
mov    0x10(%rsp),%r12
add    %rbp,%r12
lea    0xc64(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c4b <asn1_parse2+0xa4b>
mov    0x10(%rsp),%rbx
cmp    %r13,%rbx
jg     1c9d <asn1_parse2+0xa9d>
mov    %rbp,0x40(%rsp)
mov    0x18(%rsp),%rbp
cmp    $0x21,%r14d
jne    148a <asn1_parse2+0x28a>
test   %rbx,%rbx
jne    148a <asn1_parse2+0x28a>
mov    0x8(%rsp),%r14
mov    0x50(%rsp),%r12d
mov    0x3c(%rsp),%ebx
mov    0x78(%rsp),%rdx
sub    %rbp,%rdx
sub    (%r14),%ebp
add    %ebx,%ebp
mov    0xc0(%rsp),%eax
mov    %eax,(%rsp)
mov    %r15,%rdi
lea    0x18(%rsp),%rsi
mov    %ebp,%ecx
mov    0x54(%rsp),%r8d
mov    %r12d,%r9d
call   1070 <asn1_parse2@plt>
test   %eax,%eax
je     1c83 <asn1_parse2+0xa83>
cmp    $0x2,%eax
je     15e7 <asn1_parse2+0x3e7>
mov    0x18(%rsp),%rbp
mov    0x78(%rsp),%rdx
cmp    %rdx,%rbp
jb     1400 <asn1_parse2+0x200>
jmp    15ec <asn1_parse2+0x3ec>
cmpl   $0x0,0x34(%rsp)
je     14ef <asn1_parse2+0x2ef>
mov    0x10(%rsp),%rax
add    %rax,0x18(%rsp)
mov    %r15,%rdi
lea    0xba6(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
mov    0x8(%rsp),%r14
jg     1b70 <asn1_parse2+0x970>
jmp    1c8a <asn1_parse2+0xa8a>
cmp    %r12,%rbp
mov    0x8(%rsp),%r14
jae    1b70 <asn1_parse2+0x970>
nopl   0x0(%rax,%rax,1)
mov    (%r14),%eax
mov    %ebp,%ecx
sub    %eax,%ecx
add    0x3c(%rsp),%ecx
mov    0xc0(%rsp),%eax
mov    %eax,(%rsp)
mov    %r15,%rdi
lea    0x18(%rsp),%rsi
mov    %rbx,%rdx
mov    0x54(%rsp),%r8d
mov    0x50(%rsp),%r9d
call   1070 <asn1_parse2@plt>
test   %eax,%eax
je     1c8a <asn1_parse2+0xa8a>
add    %rbp,%rbx
mov    0x18(%rsp),%rax
sub    %rax,%rbx
mov    %rax,%rbp
cmp    %r12,%rax
jb     14a0 <asn1_parse2+0x2a0>
jmp    1b70 <asn1_parse2+0x970>
mov    %rbx,0x48(%rsp)
mov    0x38(%rsp),%eax
mov    0x2a81(%rip),%rcx
cmp    (%rcx),%eax
mov    0x8(%rsp),%r14
mov    %r13,0x68(%rsp)
je     15fb <asn1_parse2+0x3fb>
mov    0x2a80(%rip),%rcx
cmp    (%rcx),%eax
je     15fb <asn1_parse2+0x3fb>
mov    0x2a61(%rip),%rcx
cmp    (%rcx),%eax
je     15fb <asn1_parse2+0x3fb>
mov    0x2a9a(%rip),%rcx
cmp    (%rcx),%eax
je     15fb <asn1_parse2+0x3fb>
mov    0x2aa3(%rip),%rcx
cmp    (%rcx),%eax
je     15fb <asn1_parse2+0x3fb>
mov    0x2a6c(%rip),%rcx
cmp    (%rcx),%eax
je     15fb <asn1_parse2+0x3fb>
mov    0x29fd(%rip),%rcx
cmp    (%rcx),%eax
je     15fb <asn1_parse2+0x3fb>
mov    0x2a46(%rip),%rcx
cmp    (%rcx),%eax
je     15fb <asn1_parse2+0x3fb>
mov    0x2a47(%rip),%rcx
cmp    (%rcx),%eax
mov    0x40(%rsp),%rbx
jne    164e <asn1_parse2+0x44e>
mov    %rbx,0x28(%rsp)
mov    0x10(%rsp),%rdx
add    0x48(%rsp),%rdx
lea    0x58(%rsp),%rdi
lea    0x28(%rsp),%rsi
call   1080 <d2i_ASN1_OBJECT@plt>
mov    %r15,%rdi
test   %rax,%rax
je     17ab <asn1_parse2+0x5ab>
lea    0xade(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c8a <asn1_parse2+0xa8a>
mov    0x58(%rsp),%rsi
mov    %r15,%rdi
call   1030 <i2a_ASN1_OBJECT@plt>
xor    %r13d,%r13d
jmp    1a9f <asn1_parse2+0x89f>
mov    0x18(%rsp),%rbp
sub    0x40(%rsp),%rbp
mov    %rbp,0x10(%rsp)
jmp    1b70 <asn1_parse2+0x970>
mov    %r15,%rdi
lea    0xa98(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
mov    0x40(%rsp),%rbx
jle    1c8a <asn1_parse2+0xa8a>
mov    0x10(%rsp),%rdx
test   %rdx,%rdx
jle    16ae <asn1_parse2+0x4ae>
mov    0x18(%rsp),%rsi
mov    %r15,%rdi
call   1120 <BIO_write@plt>
movslq 0x10(%rsp),%rcx
xor    %r13d,%r13d
cmp    %rcx,%rax
je     1a9f <asn1_parse2+0x89f>
jmp    1c8a <asn1_parse2+0xa8a>
mov    0x293b(%rip),%rcx
cmp    (%rcx),%eax
jne    16b6 <asn1_parse2+0x4b6>
cmpq   $0x1,0x10(%rsp)
je     168d <asn1_parse2+0x48d>
mov    %r15,%rdi
lea    0xa17(%rip),%rsi
call   1100 <BIO_puts@plt>
test   %rax,%rax
jle    1c8a <asn1_parse2+0xa8a>
movl   $0x1,0x24(%rsp)
cmpq   $0x0,0x10(%rsp)
jle    18ac <asn1_parse2+0x6ac>
mov    0x18(%rsp),%rax
movzbl (%rax),%edx
xor    %r13d,%r13d
mov    %r15,%rdi
lea    0x9ed(%rip),%rsi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
jmp    1a9f <asn1_parse2+0x89f>
xor    %r13d,%r13d
jmp    1a9f <asn1_parse2+0x89f>
xor    %r13d,%r13d
mov    0x2898(%rip),%rcx
cmp    (%rcx),%eax
je     1a9f <asn1_parse2+0x89f>
mov    0x2899(%rip),%rcx
cmp    (%rcx),%eax
jne    17d0 <asn1_parse2+0x5d0>
mov    %rbx,0x28(%rsp)
mov    0x10(%rsp),%rdx
add    0x48(%rsp),%rdx
xor    %r13d,%r13d
xor    %edi,%edi
lea    0x28(%rsp),%rsi
call   1040 <d2i_ASN1_OCTET_STRING@plt>
mov    %rax,%r12
test   %rax,%rax
je     1a44 <asn1_parse2+0x844>
mov    (%r12),%esi
test   %esi,%esi
jle    1a44 <asn1_parse2+0x844>
mov    0x8(%r12),%rcx
mov    %rcx,0x28(%rsp)
xor    %edx,%edx
mov    $0x2600,%edi
jmp    1731 <asn1_parse2+0x531>
cmp    $0x7e,%al
ja     1746 <asn1_parse2+0x546>
add    $0x1,%rdx
cmp    %rdx,%rsi
je     1a0a <asn1_parse2+0x80a>
movzbl (%rcx,%rdx,1),%eax
cmp    $0x1f,%al
ja     1720 <asn1_parse2+0x520>
cmp    $0xd,%al
ja     1746 <asn1_parse2+0x546>
movzbl %al,%eax
bt     %rax,%rdi
jb     1724 <asn1_parse2+0x524>
cmpl   $0x0,0xc0(%rsp)
je     1bba <asn1_parse2+0x9ba>
mov    %r15,%rdi
lea    0x8b5(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c4e <asn1_parse2+0xa4e>
movslq (%r12),%rax
mov    0xc0(%rsp),%ecx
cmp    %ecx,%eax
mov    0x70(%rsp),%rdx
cmovl  %rax,%rdx
cmp    $0xffffffff,%ecx
mov    0x28(%rsp),%rsi
cmove  %rax,%rdx
mov    %r15,%rdi
mov    $0x6,%ecx
call   10d0 <BIO_dump_indent@plt>
mov    $0x1,%r13d
jmp    1a3b <asn1_parse2+0x83b>
lea    0x8c4(%rip),%rsi
call   1100 <BIO_puts@plt>
movl   $0x1,0x24(%rsp)
xor    %r13d,%r13d
test   %rax,%rax
jg     1aa6 <asn1_parse2+0x8a6>
jmp    1c8a <asn1_parse2+0xa8a>
mov    0x27d9(%rip),%rcx
cmp    (%rcx),%eax
jne    18b4 <asn1_parse2+0x6b4>
mov    %rbx,0x28(%rsp)
mov    0x10(%rsp),%rdx
add    0x48(%rsp),%rdx
xor    %edi,%edi
lea    0x28(%rsp),%rsi
call   10b0 <d2i_ASN1_INTEGER@plt>
mov    %rax,%r14
mov    %r15,%rdi
test   %rax,%rax
je     1a4e <asn1_parse2+0x84e>
lea    0x88d(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c4b <asn1_parse2+0xa4b>
mov    (%r14),%rax
mov    0x274b(%rip),%rcx
cmp    (%rcx),%rax
jne    184f <asn1_parse2+0x64f>
mov    %r15,%rdi
lea    0x868(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c4b <asn1_parse2+0xa4b>
mov    0x8(%r14),%eax
test   %eax,%eax
jle    188b <asn1_parse2+0x68b>
xor    %ebp,%ebp
mov    0x10(%r14),%rax
movzbl (%rax,%rbp,1),%edx
xor    %r12d,%r12d
mov    %r15,%rdi
lea    0x831(%rip),%rsi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1c4e <asn1_parse2+0xa4e>
add    $0x1,%rbp
movslq 0x8(%r14),%rax
cmp    %rax,%rbp
jl     1859 <asn1_parse2+0x659>
test   %eax,%eax
jne    1a6b <asn1_parse2+0x86b>
mov    %r15,%rdi
lea    0x809(%rip),%rsi
mov    $0x2,%edx
call   1120 <BIO_write@plt>
jmp    1a62 <asn1_parse2+0x862>
xor    %r13d,%r13d
jmp    1aa6 <asn1_parse2+0x8a6>
mov    0x26e5(%rip),%rcx
cmp    (%rcx),%eax
jne    1990 <asn1_parse2+0x790>
mov    %rbx,0x28(%rsp)
mov    0x10(%rsp),%rdx
add    0x48(%rsp),%rdx
xor    %edi,%edi
lea    0x28(%rsp),%rsi
call   1090 <d2i_ASN1_ENUMERATED@plt>
mov    %rax,%r14
mov    %r15,%rdi
test   %rax,%rax
je     1a75 <asn1_parse2+0x875>
lea    0x7a9(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c4b <asn1_parse2+0xa4b>
mov    (%r14),%rax
mov    0x26c7(%rip),%rcx
cmp    (%rcx),%rax
jne    1933 <asn1_parse2+0x733>
mov    %r15,%rdi
lea    0x784(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c4b <asn1_parse2+0xa4b>
mov    0x8(%r14),%eax
test   %eax,%eax
jle    196f <asn1_parse2+0x76f>
xor    %ebp,%ebp
mov    0x10(%r14),%rax
movzbl (%rax,%rbp,1),%edx
xor    %r12d,%r12d
mov    %r15,%rdi
lea    0x74d(%rip),%rsi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1c4e <asn1_parse2+0xa4e>
add    $0x1,%rbp
movslq 0x8(%r14),%rax
cmp    %rax,%rbp
jl     193d <asn1_parse2+0x73d>
test   %eax,%eax
jne    1a92 <asn1_parse2+0x892>
mov    %r15,%rdi
lea    0x725(%rip),%rsi
mov    $0x2,%edx
call   1120 <BIO_write@plt>
jmp    1a89 <asn1_parse2+0x889>
cmpl   $0x0,0xc0(%rsp)
je     1a9f <asn1_parse2+0x89f>
cmpq   $0x0,0x10(%rsp)
jle    1a9f <asn1_parse2+0x89f>
mov    %r15,%rdi
lea    0x65f(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c8a <asn1_parse2+0xa8a>
mov    0x10(%rsp),%rax
mov    0x70(%rsp),%rdx
cmp    %rdx,%rax
cmovl  %rax,%rdx
cmpl   $0xffffffff,0xc0(%rsp)
ff
mov    0x18(%rsp),%rsi
cmove  %rax,%rdx
mov    %r15,%rdi
mov    $0x6,%ecx
call   10d0 <BIO_dump_indent@plt>
mov    $0x1,%r13d
test   %rax,%rax
jg     1a9f <asn1_parse2+0x89f>
jmp    1c8a <asn1_parse2+0xa8a>
mov    %r15,%rdi
lea    0x689(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c4e <asn1_parse2+0xa4e>
mov    0x28(%rsp),%rsi
mov    (%r12),%edx
mov    %r15,%rdi
call   1120 <BIO_write@plt>
xor    %r13d,%r13d
test   %rax,%rax
jle    1c4e <asn1_parse2+0xa4e>
mov    %r12,%rdi
call   1050 <ASN1_OCTET_STRING_free@plt>
jmp    1a9a <asn1_parse2+0x89a>
lea    0x654(%rip),%rsi
call   1100 <BIO_puts@plt>
movl   $0x1,0x24(%rsp)
test   %rax,%rax
jle    1c4b <asn1_parse2+0xa4b>
mov    %r14,%rdi
call   1110 <ASN1_INTEGER_free@plt>
jmp    1a9a <asn1_parse2+0x89a>
lea    0x63a(%rip),%rsi
call   1100 <BIO_puts@plt>
movl   $0x1,0x24(%rsp)
test   %rax,%rax
jle    1c4b <asn1_parse2+0xa4b>
mov    %r14,%rdi
call   10a0 <ASN1_ENUMERATED_free@plt>
mov    0x8(%rsp),%r14
cmpl   $0x0,0x24(%rsp)
je     1b15 <asn1_parse2+0x915>
mov    %r15,%rdi
lea    0x616(%rip),%rsi
call   1100 <BIO_puts@plt>
test   %rax,%rax
jle    1c8a <asn1_parse2+0xa8a>
cmpq   $0x0,0x10(%rsp)
jle    1afc <asn1_parse2+0x8fc>
add    0x48(%rsp),%rbx
xor    %ebp,%ebp
nopl   (%rax)
movzbl (%rbx,%rbp,1),%edx
xor    %r12d,%r12d
mov    %r15,%rdi
lea    0x5be(%rip),%rsi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1c99 <asn1_parse2+0xa99>
add    $0x1,%rbp
cmp    %rbp,0x10(%rsp)
jg     1ad0 <asn1_parse2+0x8d0>
mov    %r15,%rdi
lea    0x5c3(%rip),%rsi
call   1100 <BIO_puts@plt>
test   %rax,%rax
jg     1b1d <asn1_parse2+0x91d>
jmp    1c8a <asn1_parse2+0xa8a>
movl   $0x0,0x24(%rsp)
test   %r13d,%r13d
jne    1b3f <asn1_parse2+0x93f>
mov    %r15,%rdi
lea    0x4e7(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c8a <asn1_parse2+0xa8a>
mov    0x10(%rsp),%rax
add    %rax,0x18(%rsp)
mov    0x38(%rsp),%eax
mov    0x24a4(%rip),%rcx
cmp    (%rcx),%eax
jne    1b69 <asn1_parse2+0x969>
cmpl   $0x0,0x34(%rsp)
mov    0x68(%rsp),%r13
jne    1b70 <asn1_parse2+0x970>
jmp    1cb7 <asn1_parse2+0xab7>
mov    0x68(%rsp),%r13
xchg   %ax,%ax
sub    0x10(%rsp),%r13
jle    1c2d <asn1_parse2+0xa2d>
mov    0x18(%rsp),%rbx
lea    0x18(%rsp),%rdi
lea    0x10(%rsp),%rsi
lea    0x38(%rsp),%rdx
lea    0x34(%rsp),%rcx
mov    %r13,%r8
call   10c0 <ASN1_get_object@plt>
mov    %eax,%r14d
test   $0x80,%r14b
mov    0x80(%rsp),%rax
lea    0x476(%rip),%rsi
je     12dc <asn1_parse2+0xdc>
jmp    1c37 <asn1_parse2+0xa37>
mov    %r15,%rbp
mov    %r15,%rdi
lea    0x4cc(%rip),%rsi
mov    $0xb,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c4e <asn1_parse2+0xa4e>
cmpl   $0x0,(%r12)
jle    1c1d <asn1_parse2+0xa1d>
xor    %r14d,%r14d
mov    %rbp,%r15
mov    0x40(%rsp),%rbx
mov    0x28(%rsp),%rax
movzbl (%rax,%r14,1),%edx
mov    %r15,%rdi
lea    0x4a3(%rip),%rsi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1c4e <asn1_parse2+0xa4e>
add    $0x1,%r14
movslq (%r12),%rax
xor    %r13d,%r13d
cmp    %rax,%r14
jl     1be8 <asn1_parse2+0x9e8>
jmp    1a44 <asn1_parse2+0x844>
xor    %r13d,%r13d
mov    %rbp,%r15
mov    0x40(%rsp),%rbx
jmp    1a44 <asn1_parse2+0x844>
mov    $0x1,%ebx
xor    %r12d,%r12d
jmp    1c55 <asn1_parse2+0xa55>
lea    0x3d7(%rip),%rsi
mov    %r15,%rdi
mov    $0x12,%edx
call   1120 <BIO_write@plt>
xor    %r12d,%r12d
xor    %ebx,%ebx
mov    0x8(%rsp),%r14
mov    0x58(%rsp),%rdi
call   10e0 <ASN1_OBJECT_free@plt>
mov    %r12,%rdi
call   1050 <ASN1_OCTET_STRING_free@plt>
mov    0x18(%rsp),%rax
mov    %rax,(%r14)
mov    %ebx,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %r12d,%r12d
mov    %eax,%ebx
jmp    1c55 <asn1_parse2+0xa55>
xor    %r12d,%r12d
xor    %ebx,%ebx
jmp    1c55 <asn1_parse2+0xa55>
xor    %r12d,%r12d
mov    0x8(%rsp),%r14
xor    %ebx,%ebx
jmp    1c55 <asn1_parse2+0xa55>
movzbl %r13b,%edx
lea    0x3b2(%rip),%rsi
xor    %r12d,%r12d
mov    %r15,%rdi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
jmp    1c4e <asn1_parse2+0xa4e>
mov    $0x2,%ebx
jmp    1c32 <asn1_parse2+0xa32>

LLVM IR (-O0):
%struct.TYPE_10__ = type { i32, i8* }
%struct.TYPE_11__ = type { i64, i32, i8* }
%struct.TYPE_12__ = type { i64, i32, i8* }
@.str = [21 x i8] c"BAD RECURSION DEPTH\0A\00"
@.str.1 = [19 x i8] c"Error in encoding\0A\00"
@.str.2 = [6 x i8] c"%5ld:\00"
@V_ASN1_CONSTRUCTED = global i32 0
@.str.3 = [22 x i8] c"d=%-2d hl=%ld l=%4ld \00"
@.str.4 = [22 x i8] c"d=%-2d hl=%ld l=inf \00"
@.str.5 = [2 x i8] c"\0A\00"
@.str.6 = [28 x i8] c"length is greater than %ld\0A\00"
@V_ASN1_PRINTABLESTRING = global i32 0
@V_ASN1_T61STRING = global i32 0
@V_ASN1_IA5STRING = global i32 0
@V_ASN1_VISIBLESTRING = global i32 0
@V_ASN1_NUMERICSTRING = global i32 0
@V_ASN1_UTF8STRING = global i32 0
@V_ASN1_UTCTIME = global i32 0
@V_ASN1_GENERALIZEDTIME = global i32 0
@.str.7 = [2 x i8] c":\00"
@V_ASN1_OBJECT = global i32 0
@.str.8 = [12 x i8] c":BAD OBJECT\00"
@V_ASN1_BOOLEAN = global i32 0
@.str.9 = [13 x i8] c":BAD BOOLEAN\00"
@.str.10 = [4 x i8] c":%u\00"
@V_ASN1_BMPSTRING = global i32 0
@V_ASN1_OCTET_STRING = global i32 0
@.str.11 = [12 x i8] c"[HEX DUMP]:\00"
@.str.12 = [5 x i8] c"%02X\00"
@V_ASN1_INTEGER = global i32 0
@V_ASN1_NEG_INTEGER = global i64 0
@.str.13 = [2 x i8] c"-\00"
@.str.14 = [3 x i8] c"00\00"
@.str.15 = [13 x i8] c":BAD INTEGER\00"
@V_ASN1_ENUMERATED = global i32 0
@V_ASN1_NEG_ENUMERATED = global i64 0
@.str.16 = [16 x i8] c":BAD ENUMERATED\00"
@.str.17 = [3 x i8] c":[\00"
@.str.18 = [2 x i8] c"]\00"
@V_ASN1_EOC = global i32 0
define i32 @asn1_parse2(i32* %0, i8** %1, i64 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i8**
%11 = alloca i64
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i8*
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8*
%20 = alloca i8*
%21 = alloca i64
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32*
%30 = alloca %struct.TYPE_10__*
%31 = alloca i32
%32 = alloca i32
%33 = alloca i8*
%34 = alloca i64
%35 = alloca i32
%36 = alloca i32
%37 = alloca %struct.TYPE_11__*
%38 = alloca i32
%39 = alloca %struct.TYPE_12__*
%40 = alloca i32
%41 = alloca i32
%42 = alloca i8*
store i32* %0, i32** %9
store i8** %1, i8*** %10
store i64 %2, i64* %11
store i32 %3, i32* %12
store i32 %4, i32* %13
store i32 %5, i32* %14
store i32 %6, i32* %15
store i32 0, i32* %24
store i32* null, i32** %29
store %struct.TYPE_10__* null, %struct.TYPE_10__** %30
store i32 0, i32* %32
%43 = load i32, i32* %13
%44 = icmp sgt i32 %43, 128
br i1 %44, label %45, label %48
45: ; preds = %7
%46 = load i32*, i32** %9
%47 = call i64 @BIO_puts(i32* %46, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %8
br label %789
48: ; preds = %7
store i32 6, i32* %31
%49 = load i8**, i8*** %10
%50 = load i8*, i8** %49
store i8* %50, i8** %16
%51 = load i8*, i8** %16
%52 = load i64, i64* %11
%53 = getelementptr inbounds i8, i8* %51, i64 %52
store i8* %53, i8** %18
br label %54
54: ; preds = %776, %48
%55 = load i64, i64* %11
%56 = icmp sgt i64 %55, 0
br i1 %56, label %57, label %780
57: ; preds = %54
%58 = load i8*, i8** %16
store i8* %58, i8** %19
%59 = load i64, i64* %11
%60 = call i32 @ASN1_get_object(i8** %16, i64* %21, i32* %22, i32* %23, i64 %59)
store i32 %60, i32* %27
%61 = load i32, i32* %27
%62 = and i32 %61, 128
%63 = icmp ne i32 %62, 0
br i1 %63, label %64, label %70
64: ; preds = %57
%65 = load i32*, i32** %9
%66 = call i64 @BIO_write(i32* %65, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0), i32 18)
%67 = icmp sle i64 %66, 0
br i1 %67, label %68, label %69
68: ; preds = %64
br label %781
69: ; preds = %64
store i32 0, i32* %24
br label %781
70: ; preds = %57
%71 = load i8*, i8** %16
%72 = load i8*, i8** %19
%73 = ptrtoint i8* %71 to i64
%74 = ptrtoint i8* %72 to i64
%75 = sub i64 %73, %74
%76 = trunc i64 %75 to i32
store i32 %76, i32* %26
%77 = load i32, i32* %26
%78 = sext i32 %77 to i64
%79 = load i64, i64* %11
%80 = sub nsw i64 %79, %78
store i64 %80, i64* %11
%81 = load i32*, i32** %9
%82 = load i32, i32* %12
%83 = sext i32 %82 to i64
%84 = load i8*, i8** %19
%85 = load i8**, i8*** %10
%86 = load i8*, i8** %85
%87 = ptrtoint i8* %84 to i64
%88 = ptrtoint i8* %86 to i64
%89 = sub i64 %87, %88
%90 = add nsw i64 %83, %89
%91 = trunc i64 %90 to i8
%92 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %81, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i8 zeroext %91)
%93 = icmp sle i64 %92, 0
br i1 %93, label %94, label %95
94: ; preds = %70
br label %781
95: ; preds = %70
%96 = load i32, i32* %27
%97 = load i32, i32* @V_ASN1_CONSTRUCTED
%98 = or i32 %97, 1
%99 = icmp ne i32 %96, %98
br i1 %99, label %100, label %111
100: ; preds = %95
%101 = load i32*, i32** %9
%102 = load i32, i32* %13
%103 = trunc i32 %102 to i8
%104 = load i32, i32* %26
%105 = sext i32 %104 to i64
%106 = load i64, i64* %21
%107 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %101, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.3, i64 0, i64 0), i8 zeroext %103, i64 %105, i64 %106)
%108 = icmp sle i64 %107, 0
br i1 %108, label %109, label %110
109: ; preds = %100
br label %781
110: ; preds = %100
br label %121
111: ; preds = %95
%112 = load i32*, i32** %9
%113 = load i32, i32* %13
%114 = trunc i32 %113 to i8
%115 = load i32, i32* %26
%116 = sext i32 %115 to i64
%117 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %112, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i8 zeroext %114, i64 %116)
%118 = icmp sle i64 %117, 0
br i1 %118, label %119, label %120
119: ; preds = %111
br label %781
120: ; preds = %111
br label %121
121: ; preds = %120, %110
%122 = load i32*, i32** %9
%123 = load i32, i32* %22
%124 = load i32, i32* %23
%125 = load i32, i32* %27
%126 = load i32, i32* %14
%127 = icmp ne i32 %126, 0
br i1 %127, label %128, label %130
128: ; preds = %121
%129 = load i32, i32* %13
br label %131
130: ; preds = %121
br label %131
131: ; preds = %130, %128
%132 = phi i32 [ %129, %128 ], [ 0, %130 ]
%133 = call i32 @asn1_print_info(i32* %122, i32 %123, i32 %124, i32 %125, i32 %132)
%134 = icmp ne i32 %133, 0
br i1 %134, label %136, label %135
135: ; preds = %131
br label %781
136: ; preds = %131
%137 = load i32, i32* %27
%138 = load i32, i32* @V_ASN1_CONSTRUCTED
%139 = and i32 %137, %138
%140 = icmp ne i32 %139, 0
br i1 %140, label %141, label %244
141: ; preds = %136
%142 = load i8*, i8** %16
store i8* %142, i8** %33
%143 = load i8*, i8** %16
%144 = load i64, i64* %21
%145 = getelementptr inbounds i8, i8* %143, i64 %144
store i8* %145, i8** %17
%146 = load i32*, i32** %9
%147 = call i64 @BIO_write(i32* %146, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%148 = icmp sle i64 %147, 0
br i1 %148, label %149, label %150
149: ; preds = %141
br label %781
150: ; preds = %141
%151 = load i64, i64* %21
%152 = load i64, i64* %11
%153 = icmp sgt i64 %151, %152
br i1 %153, label %154, label %159
154: ; preds = %150
%155 = load i32*, i32** %9
%156 = load i64, i64* %11
%157 = trunc i64 %156 to i8
%158 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %155, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.6, i64 0, i64 0), i8 zeroext %157)
store i32 0, i32* %24
br label %781
159: ; preds = %150
%160 = load i32, i32* %27
%161 = icmp eq i32 %160, 33
br i1 %161, label %162, label %206
162: ; preds = %159
%163 = load i64, i64* %21
%164 = icmp eq i64 %163, 0
br i1 %164, label %165, label %206
165: ; preds = %162
br label %166
166: ; preds = %204, %165
%167 = load i32*, i32** %9
%168 = load i8*, i8** %18
%169 = load i8*, i8** %16
%170 = ptrtoint i8* %168 to i64
%171 = ptrtoint i8* %169 to i64
%172 = sub i64 %170, %171
%173 = load i32, i32* %12
%174 = sext i32 %173 to i64
%175 = load i8*, i8** %16
%176 = load i8**, i8*** %10
%177 = load i8*, i8** %176
%178 = ptrtoint i8* %175 to i64
%179 = ptrtoint i8* %177 to i64
%180 = sub i64 %178, %179
%181 = add nsw i64 %174, %180
%182 = trunc i64 %181 to i32
%183 = load i32, i32* %13
%184 = add nsw i32 %183, 1
%185 = load i32, i32* %14
%186 = load i32, i32* %15
%187 = call i32 @asn1_parse2(i32* %167, i8** %16, i64 %172, i32 %182, i32 %184, i32 %185, i32 %186)
store i32 %187, i32* %28
%188 = load i32, i32* %28
%189 = icmp eq i32 %188, 0
br i1 %189, label %190, label %191
190: ; preds = %166
store i32 0, i32* %24
br label %781
191: ; preds = %166
%192 = load i32, i32* %28
%193 = icmp eq i32 %192, 2
br i1 %193, label %198, label %194
194: ; preds = %191
%195 = load i8*, i8** %16
%196 = load i8*, i8** %18
%197 = icmp uge i8* %195, %196
br i1 %197, label %198, label %204
198: ; preds = %194, %191
%199 = load i8*, i8** %16
%200 = load i8*, i8** %33
%201 = ptrtoint i8* %199 to i64
%202 = ptrtoint i8* %200 to i64
%203 = sub i64 %201, %202
store i64 %203, i64* %21
br label %205
204: ; preds = %194
br label %166
205: ; preds = %198
br label %243
206: ; preds = %162, %159
%207 = load i64, i64* %21
store i64 %207, i64* %34
br label %208
208: ; preds = %234, %206
%209 = load i8*, i8** %16
%210 = load i8*, i8** %17
%211 = icmp ult i8* %209, %210
br i1 %211, label %212, label %242
212: ; preds = %208
%213 = load i8*, i8** %16
store i8* %213, i8** %33
%214 = load i32*, i32** %9
%215 = load i64, i64* %34
%216 = load i32, i32* %12
%217 = sext i32 %216 to i64
%218 = load i8*, i8** %16
%219 = load i8**, i8*** %10
%220 = load i8*, i8** %219
%221 = ptrtoint i8* %218 to i64
%222 = ptrtoint i8* %220 to i64
%223 = sub i64 %221, %222
%224 = add nsw i64 %217, %223
%225 = trunc i64 %224 to i32
%226 = load i32, i32* %13
%227 = add nsw i32 %226, 1
%228 = load i32, i32* %14
%229 = load i32, i32* %15
%230 = call i32 @asn1_parse2(i32* %214, i8** %16, i64 %215, i32 %225, i32 %227, i32 %228, i32 %229)
store i32 %230, i32* %28
%231 = load i32, i32* %28
%232 = icmp eq i32 %231, 0
br i1 %232, label %233, label %234
233: ; preds = %212
store i32 0, i32* %24
br label %781
234: ; preds = %212
%235 = load i8*, i8** %16
%236 = load i8*, i8** %33
%237 = ptrtoint i8* %235 to i64
%238 = ptrtoint i8* %236 to i64
%239 = sub i64 %237, %238
%240 = load i64, i64* %34
%241 = sub nsw i64 %240, %239
store i64 %241, i64* %34
br label %208
242: ; preds = %208
br label %243
243: ; preds = %242, %205
br label %776
244: ; preds = %136
%245 = load i32, i32* %23
%246 = icmp ne i32 %245, 0
br i1 %246, label %247, label %256
247: ; preds = %244
%248 = load i64, i64* %21
%249 = load i8*, i8** %16
%250 = getelementptr inbounds i8, i8* %249, i64 %248
store i8* %250, i8** %16
%251 = load i32*, i32** %9
%252 = call i64 @BIO_write(i32* %251, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%253 = icmp sle i64 %252, 0
br i1 %253, label %254, label %255
254: ; preds = %247
br label %781
255: ; preds = %247
br label %775
256: ; preds = %244
store i32 0, i32* %25
%257 = load i32, i32* %22
%258 = load i32, i32* @V_ASN1_PRINTABLESTRING
%259 = icmp eq i32 %257, %258
br i1 %259, label %288, label %260
260: ; preds = %256
%261 = load i32, i32* %22
%262 = load i32, i32* @V_ASN1_T61STRING
%263 = icmp eq i32 %261, %262
br i1 %263, label %288, label %264
264: ; preds = %260
%265 = load i32, i32* %22
%266 = load i32, i32* @V_ASN1_IA5STRING
%267 = icmp eq i32 %265, %266
br i1 %267, label %288, label %268
268: ; preds = %264
%269 = load i32, i32* %22
%270 = load i32, i32* @V_ASN1_VISIBLESTRING
%271 = icmp eq i32 %269, %270
br i1 %271, label %288, label %272
272: ; preds = %268
%273 = load i32, i32* %22
%274 = load i32, i32* @V_ASN1_NUMERICSTRING
%275 = icmp eq i32 %273, %274
br i1 %275, label %288, label %276
276: ; preds = %272
%277 = load i32, i32* %22
%278 = load i32, i32* @V_ASN1_UTF8STRING
%279 = icmp eq i32 %277, %278
br i1 %279, label %288, label %280
280: ; preds = %276
%281 = load i32, i32* %22
%282 = load i32, i32* @V_ASN1_UTCTIME
%283 = icmp eq i32 %281, %282
br i1 %283, label %288, label %284
284: ; preds = %280
%285 = load i32, i32* %22
%286 = load i32, i32* @V_ASN1_GENERALIZEDTIME
%287 = icmp eq i32 %285, %286
br i1 %287, label %288, label %308
288: ; preds = %284, %280, %276, %272, %268, %264, %260, %256
%289 = load i32*, i32** %9
%290 = call i64 @BIO_write(i32* %289, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%291 = icmp sle i64 %290, 0
br i1 %291, label %292, label %293
292: ; preds = %288
br label %781
293: ; preds = %288
%294 = load i64, i64* %21
%295 = icmp sgt i64 %294, 0
br i1 %295, label %296, label %307
296: ; preds = %293
%297 = load i32*, i32** %9
%298 = load i8*, i8** %16
%299 = load i64, i64* %21
%300 = trunc i64 %299 to i32
%301 = call i64 @BIO_write(i32* %297, i8* %298, i32 %300)
%302 = load i64, i64* %21
%303 = trunc i64 %302 to i32
%304 = sext i32 %303 to i64
%305 = icmp ne i64 %301, %304
br i1 %305, label %306, label %307
306: ; preds = %296
br label %781
307: ; preds = %296, %293
br label %716
308: ; preds = %284
%309 = load i32, i32* %22
%310 = load i32, i32* @V_ASN1_OBJECT
%311 = icmp eq i32 %309, %310
br i1 %311, label %312, label %336
312: ; preds = %308
%313 = load i8*, i8** %19
store i8* %313, i8** %20
%314 = load i64, i64* %21
%315 = load i32, i32* %26
%316 = sext i32 %315 to i64
%317 = add nsw i64 %314, %316
%318 = call i32* @d2i_ASN1_OBJECT(i32** %29, i8** %20, i64 %317)
%319 = icmp ne i32* %318, null
br i1 %319, label %320, label %329
320: ; preds = %312
%321 = load i32*, i32** %9
%322 = call i64 @BIO_write(i32* %321, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%323 = icmp sle i64 %322, 0
br i1 %323, label %324, label %325
324: ; preds = %320
br label %781
325: ; preds = %320
%326 = load i32*, i32** %9
%327 = load i32*, i32** %29
%328 = call i32 @i2a_ASN1_OBJECT(i32* %326, i32* %327)
br label %335
329: ; preds = %312
%330 = load i32*, i32** %9
%331 = call i64 @BIO_puts(i32* %330, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.8, i64 0, i64 0))
%332 = icmp sle i64 %331, 0
br i1 %332, label %333, label %334
333: ; preds = %329
br label %781
334: ; preds = %329
store i32 1, i32* %32
br label %335
335: ; preds = %334, %325
br label %715
336: ; preds = %308
%337 = load i32, i32* %22
%338 = load i32, i32* @V_ASN1_BOOLEAN
%339 = icmp eq i32 %337, %338
br i1 %339, label %340, label %359
340: ; preds = %336
%341 = load i64, i64* %21
%342 = icmp ne i64 %341, 1
br i1 %342, label %343, label %349
343: ; preds = %340
%344 = load i32*, i32** %9
%345 = call i64 @BIO_puts(i32* %344, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.9, i64 0, i64 0))
%346 = icmp sle i64 %345, 0
br i1 %346, label %347, label %348
347: ; preds = %343
br label %781
348: ; preds = %343
store i32 1, i32* %32
br label %349
349: ; preds = %348, %340
%350 = load i64, i64* %21
%351 = icmp sgt i64 %350, 0
br i1 %351, label %352, label %358
352: ; preds = %349
%353 = load i32*, i32** %9
%354 = load i8*, i8** %16
%355 = getelementptr inbounds i8, i8* %354, i64 0
%356 = load i8, i8* %355
%357 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %353, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), i8 zeroext %356)
br label %358
358: ; preds = %352, %349
br label %714
359: ; preds = %336
%360 = load i32, i32* %22
%361 = load i32, i32* @V_ASN1_BMPSTRING
%362 = icmp eq i32 %360, %361
br i1 %362, label %363, label %364
363: ; preds = %359
br label %713
364: ; preds = %359
%365 = load i32, i32* %22
%366 = load i32, i32* @V_ASN1_OCTET_STRING
%367 = icmp eq i32 %365, %366
br i1 %367, label %368, label %524
368: ; preds = %364
store i32 1, i32* %36
%369 = load i8*, i8** %19
store i8* %369, i8** %20
%370 = load i64, i64* %21
%371 = load i32, i32* %26
%372 = sext i32 %371 to i64
%373 = add nsw i64 %370, %372
%374 = call %struct.TYPE_10__* @d2i_ASN1_OCTET_STRING(i32* null, i8** %20, i64 %373)
store %struct.TYPE_10__* %374, %struct.TYPE_10__** %30
%375 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%376 = icmp ne %struct.TYPE_10__* %375, null
br i1 %376, label %377, label %521
377: ; preds = %368
%378 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%379 = getelementptr inbounds %struct.TYPE_10__, %struct.TYPE_10__* %378, i32 0, i32 0
%380 = load i32, i32* %379
%381 = icmp sgt i32 %380, 0
br i1 %381, label %382, label %521
382: ; preds = %377
%383 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%384 = getelementptr inbounds %struct.TYPE_10__, %struct.TYPE_10__* %383, i32 0, i32 1
%385 = load i8*, i8** %384
store i8* %385, i8** %20
store i32 0, i32* %35
br label %386
386: ; preds = %434, %382
%387 = load i32, i32* %35
%388 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%389 = getelementptr inbounds %struct.TYPE_10__, %struct.TYPE_10__* %388, i32 0, i32 0
%390 = load i32, i32* %389
%391 = icmp slt i32 %387, %390
br i1 %391, label %392, label %437
392: ; preds = %386
%393 = load i8*, i8** %20
%394 = load i32, i32* %35
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i8, i8* %393, i64 %395
%397 = load i8, i8* %396
%398 = zext i8 %397 to i32
%399 = icmp slt i32 %398, 32
br i1 %399, label %400, label %424
400: ; preds = %392
%401 = load i8*, i8** %20
%402 = load i32, i32* %35
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds i8, i8* %401, i64 %403
%405 = load i8, i8* %404
%406 = zext i8 %405 to i32
%407 = icmp ne i32 %406, 10
br i1 %407, label %408, label %424
408: ; preds = %400
%409 = load i8*, i8** %20
%410 = load i32, i32* %35
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds i8, i8* %409, i64 %411
%413 = load i8, i8* %412
%414 = zext i8 %413 to i32
%415 = icmp ne i32 %414, 13
br i1 %415, label %416, label %424
416: ; preds = %408
%417 = load i8*, i8** %20
%418 = load i32, i32* %35
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds i8, i8* %417, i64 %419
%421 = load i8, i8* %420
%422 = zext i8 %421 to i32
%423 = icmp ne i32 %422, 9
br i1 %423, label %432, label %424
424: ; preds = %416, %408, %400, %392
%425 = load i8*, i8** %20
%426 = load i32, i32* %35
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds i8, i8* %425, i64 %427
%429 = load i8, i8* %428
%430 = zext i8 %429 to i32
%431 = icmp sgt i32 %430, 126
br i1 %431, label %432, label %433
432: ; preds = %424, %416
store i32 0, i32* %36
br label %437
433: ; preds = %424
br label %434
434: ; preds = %433
%435 = load i32, i32* %35
%436 = add nsw i32 %435, 1
store i32 %436, i32* %35
br label %386
437: ; preds = %432, %386
%438 = load i32, i32* %36
%439 = icmp ne i32 %438, 0
br i1 %439, label %440, label %455
440: ; preds = %437
%441 = load i32*, i32** %9
%442 = call i64 @BIO_write(i32* %441, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%443 = icmp sle i64 %442, 0
br i1 %443, label %444, label %445
444: ; preds = %440
br label %781
445: ; preds = %440
%446 = load i32*, i32** %9
%447 = load i8*, i8** %20
%448 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%449 = getelementptr inbounds %struct.TYPE_10__, %struct.TYPE_10__* %448, i32 0, i32 0
%450 = load i32, i32* %449
%451 = call i64 @BIO_write(i32* %446, i8* %447, i32 %450)
%452 = icmp sle i64 %451, 0
br i1 %452, label %453, label %454
453: ; preds = %445
br label %781
454: ; preds = %445
br label %520
455: ; preds = %437
%456 = load i32, i32* %15
%457 = icmp ne i32 %456, 0
br i1 %457, label %485, label %458
458: ; preds = %455
%459 = load i32*, i32** %9
%460 = call i64 @BIO_write(i32* %459, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.11, i64 0, i64 0), i32 11)
%461 = icmp sle i64 %460, 0
br i1 %461, label %462, label %463
462: ; preds = %458
br label %781
463: ; preds = %458
store i32 0, i32* %35
br label %464
464: ; preds = %481, %463
%465 = load i32, i32* %35
%466 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%467 = getelementptr inbounds %struct.TYPE_10__, %struct.TYPE_10__* %466, i32 0, i32 0
%468 = load i32, i32* %467
%469 = icmp slt i32 %465, %468
br i1 %469, label %470, label %484
470: ; preds = %464
%471 = load i32*, i32** %9
%472 = load i8*, i8** %20
%473 = load i32, i32* %35
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds i8, i8* %472, i64 %474
%476 = load i8, i8* %475
%477 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %471, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8 zeroext %476)
%478 = icmp sle i64 %477, 0
br i1 %478, label %479, label %480
479: ; preds = %470
br label %781
480: ; preds = %470
br label %481
481: ; preds = %480
%482 = load i32, i32* %35
%483 = add nsw i32 %482, 1
store i32 %483, i32* %35
br label %464
484: ; preds = %464
br label %519
485: ; preds = %455
%486 = load i32, i32* %25
%487 = icmp ne i32 %486, 0
br i1 %487, label %494, label %488
488: ; preds = %485
%489 = load i32*, i32** %9
%490 = call i64 @BIO_write(i32* %489, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%491 = icmp sle i64 %490, 0
br i1 %491, label %492, label %493
492: ; preds = %488
br label %781
493: ; preds = %488
br label %494
494: ; preds = %493, %485
%495 = load i32*, i32** %9
%496 = load i8*, i8** %20
%497 = load i32, i32* %15
%498 = icmp eq i32 %497, -1
br i1 %498, label %505, label %499
499: ; preds = %494
%500 = load i32, i32* %15
%501 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%502 = getelementptr inbounds %struct.TYPE_10__, %struct.TYPE_10__* %501, i32 0, i32 0
%503 = load i32, i32* %502
%504 = icmp sgt i32 %500, %503
br i1 %504, label %505, label %509
505: ; preds = %499, %494
%506 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%507 = getelementptr inbounds %struct.TYPE_10__, %struct.TYPE_10__* %506, i32 0, i32 0
%508 = load i32, i32* %507
br label %511
509: ; preds = %499
%510 = load i32, i32* %15
br label %511
511: ; preds = %509, %505
%512 = phi i32 [ %508, %505 ], [ %510, %509 ]
%513 = sext i32 %512 to i64
%514 = load i32, i32* %31
%515 = call i64 @BIO_dump_indent(i32* %495, i8* %496, i64 %513, i32 %514)
%516 = icmp sle i64 %515, 0
br i1 %516, label %517, label %518
517: ; preds = %511
br label %781
518: ; preds = %511
store i32 1, i32* %25
br label %519
519: ; preds = %518, %484
br label %520
520: ; preds = %519, %454
br label %521
521: ; preds = %520, %377, %368
%522 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%523 = call i32 @ASN1_OCTET_STRING_free(%struct.TYPE_10__* %522)
store %struct.TYPE_10__* null, %struct.TYPE_10__** %30
br label %712
524: ; preds = %364
%525 = load i32, i32* %22
%526 = load i32, i32* @V_ASN1_INTEGER
%527 = icmp eq i32 %525, %526
br i1 %527, label %528, label %598
528: ; preds = %524
%529 = load i8*, i8** %19
store i8* %529, i8** %20
%530 = load i64, i64* %21
%531 = load i32, i32* %26
%532 = sext i32 %531 to i64
%533 = add nsw i64 %530, %532
%534 = call %struct.TYPE_11__* @d2i_ASN1_INTEGER(i32* null, i8** %20, i64 %533)
store %struct.TYPE_11__* %534, %struct.TYPE_11__** %37
%535 = load %struct.TYPE_11__*, %struct.TYPE_11__** %37
%536 = icmp ne %struct.TYPE_11__* %535, null
br i1 %536, label %537, label %589
537: ; preds = %528
%538 = load i32*, i32** %9
%539 = call i64 @BIO_write(i32* %538, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%540 = icmp sle i64 %539, 0
br i1 %540, label %541, label %542
541: ; preds = %537
br label %781
542: ; preds = %537
%543 = load %struct.TYPE_11__*, %struct.TYPE_11__** %37
%544 = getelementptr inbounds %struct.TYPE_11__, %struct.TYPE_11__* %543, i32 0, i32 0
%545 = load i64, i64* %544
%546 = load i64, i64* @V_ASN1_NEG_INTEGER
%547 = icmp eq i64 %545, %546
br i1 %547, label %548, label %554
548: ; preds = %542
%549 = load i32*, i32** %9
%550 = call i64 @BIO_write(i32* %549, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0), i32 1)
%551 = icmp sle i64 %550, 0
br i1 %551, label %552, label %553
552: ; preds = %548
br label %781
553: ; preds = %548
br label %554
554: ; preds = %553, %542
store i32 0, i32* %38
br label %555
555: ; preds = %574, %554
%556 = load i32, i32* %38
%557 = load %struct.TYPE_11__*, %struct.TYPE_11__** %37
%558 = getelementptr inbounds %struct.TYPE_11__, %struct.TYPE_11__* %557, i32 0, i32 1
%559 = load i32, i32* %558
%560 = icmp slt i32 %556, %559
br i1 %560, label %561, label %577
561: ; preds = %555
%562 = load i32*, i32** %9
%563 = load %struct.TYPE_11__*, %struct.TYPE_11__** %37
%564 = getelementptr inbounds %struct.TYPE_11__, %struct.TYPE_11__* %563, i32 0, i32 2
%565 = load i8*, i8** %564
%566 = load i32, i32* %38
%567 = sext i32 %566 to i64
%568 = getelementptr inbounds i8, i8* %565, i64 %567
%569 = load i8, i8* %568
%570 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %562, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8 zeroext %569)
%571 = icmp sle i64 %570, 0
br i1 %571, label %572, label %573
572: ; preds = %561
br label %781
573: ; preds = %561
br label %574
574: ; preds = %573
%575 = load i32, i32* %38
%576 = add nsw i32 %575, 1
store i32 %576, i32* %38
br label %555
577: ; preds = %555
%578 = load %struct.TYPE_11__*, %struct.TYPE_11__** %37
%579 = getelementptr inbounds %struct.TYPE_11__, %struct.TYPE_11__* %578, i32 0, i32 1
%580 = load i32, i32* %579
%581 = icmp eq i32 %580, 0
br i1 %581, label %582, label %588
582: ; preds = %577
%583 = load i32*, i32** %9
%584 = call i64 @BIO_write(i32* %583, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32 2)
%585 = icmp sle i64 %584, 0
br i1 %585, label %586, label %587
586: ; preds = %582
br label %781
587: ; preds = %582
br label %588
588: ; preds = %587, %577
br label %595
589: ; preds = %528
%590 = load i32*, i32** %9
%591 = call i64 @BIO_puts(i32* %590, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.15, i64 0, i64 0))
%592 = icmp sle i64 %591, 0
br i1 %592, label %593, label %594
593: ; preds = %589
br label %781
594: ; preds = %589
store i32 1, i32* %32
br label %595
595: ; preds = %594, %588
%596 = load %struct.TYPE_11__*, %struct.TYPE_11__** %37
%597 = call i32 @ASN1_INTEGER_free(%struct.TYPE_11__* %596)
br label %711
598: ; preds = %524
%599 = load i32, i32* %22
%600 = load i32, i32* @V_ASN1_ENUMERATED
%601 = icmp eq i32 %599, %600
br i1 %601, label %602, label %672
602: ; preds = %598
%603 = load i8*, i8** %19
store i8* %603, i8** %20
%604 = load i64, i64* %21
%605 = load i32, i32* %26
%606 = sext i32 %605 to i64
%607 = add nsw i64 %604, %606
%608 = call %struct.TYPE_12__* @d2i_ASN1_ENUMERATED(i32* null, i8** %20, i64 %607)
store %struct.TYPE_12__* %608, %struct.TYPE_12__** %39
%609 = load %struct.TYPE_12__*, %struct.TYPE_12__** %39
%610 = icmp ne %struct.TYPE_12__* %609, null
br i1 %610, label %611, label %663
611: ; preds = %602
%612 = load i32*, i32** %9
%613 = call i64 @BIO_write(i32* %612, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%614 = icmp sle i64 %613, 0
br i1 %614, label %615, label %616
615: ; preds = %611
br label %781
616: ; preds = %611
%617 = load %struct.TYPE_12__*, %struct.TYPE_12__** %39
%618 = getelementptr inbounds %struct.TYPE_12__, %struct.TYPE_12__* %617, i32 0, i32 0
%619 = load i64, i64* %618
%620 = load i64, i64* @V_ASN1_NEG_ENUMERATED
%621 = icmp eq i64 %619, %620
br i1 %621, label %622, label %628
622: ; preds = %616
%623 = load i32*, i32** %9
%624 = call i64 @BIO_write(i32* %623, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0), i32 1)
%625 = icmp sle i64 %624, 0
br i1 %625, label %626, label %627
626: ; preds = %622
br label %781
627: ; preds = %622
br label %628
628: ; preds = %627, %616
store i32 0, i32* %40
br label %629
629: ; preds = %648, %628
%630 = load i32, i32* %40
%631 = load %struct.TYPE_12__*, %struct.TYPE_12__** %39
%632 = getelementptr inbounds %struct.TYPE_12__, %struct.TYPE_12__* %631, i32 0, i32 1
%633 = load i32, i32* %632
%634 = icmp slt i32 %630, %633
br i1 %634, label %635, label %651
635: ; preds = %629
%636 = load i32*, i32** %9
%637 = load %struct.TYPE_12__*, %struct.TYPE_12__** %39
%638 = getelementptr inbounds %struct.TYPE_12__, %struct.TYPE_12__* %637, i32 0, i32 2
%639 = load i8*, i8** %638
%640 = load i32, i32* %40
%641 = sext i32 %640 to i64
%642 = getelementptr inbounds i8, i8* %639, i64 %641
%643 = load i8, i8* %642
%644 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %636, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8 zeroext %643)
%645 = icmp sle i64 %644, 0
br i1 %645, label %646, label %647
646: ; preds = %635
br label %781
647: ; preds = %635
br label %648
648: ; preds = %647
%649 = load i32, i32* %40
%650 = add nsw i32 %649, 1
store i32 %650, i32* %40
br label %629
651: ; preds = %629
%652 = load %struct.TYPE_12__*, %struct.TYPE_12__** %39
%653 = getelementptr inbounds %struct.TYPE_12__, %struct.TYPE_12__* %652, i32 0, i32 1
%654 = load i32, i32* %653
%655 = icmp eq i32 %654, 0
br i1 %655, label %656, label %662
656: ; preds = %651
%657 = load i32*, i32** %9
%658 = call i64 @BIO_write(i32* %657, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32 2)
%659 = icmp sle i64 %658, 0
br i1 %659, label %660, label %661
660: ; preds = %656
br label %781
661: ; preds = %656
br label %662
662: ; preds = %661, %651
br label %669
663: ; preds = %602
%664 = load i32*, i32** %9
%665 = call i64 @BIO_puts(i32* %664, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.16, i64 0, i64 0))
%666 = icmp sle i64 %665, 0
br i1 %666, label %667, label %668
667: ; preds = %663
br label %781
668: ; preds = %663
store i32 1, i32* %32
br label %669
669: ; preds = %668, %662
%670 = load %struct.TYPE_12__*, %struct.TYPE_12__** %39
%671 = call i32 @ASN1_ENUMERATED_free(%struct.TYPE_12__* %670)
br label %710
672: ; preds = %598
%673 = load i64, i64* %21
%674 = icmp sgt i64 %673, 0
br i1 %674, label %675, label %709
675: ; preds = %672
%676 = load i32, i32* %15
%677 = icmp ne i32 %676, 0
br i1 %677, label %678, label %709
678: ; preds = %675
%679 = load i32, i32* %25
%680 = icmp ne i32 %679, 0
br i1 %680, label %687, label %681
681: ; preds = %678
%682 = load i32*, i32** %9
%683 = call i64 @BIO_write(i32* %682, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%684 = icmp sle i64 %683, 0
br i1 %684, label %685, label %686
685: ; preds = %681
br label %781
686: ; preds = %681
br label %687
687: ; preds = %686, %678
%688 = load i32*, i32** %9
%689 = load i8*, i8** %16
%690 = load i32, i32* %15
%691 = icmp eq i32 %690, -1
br i1 %691, label %697, label %692
692: ; preds = %687
%693 = load i32, i32* %15
%694 = sext i32 %693 to i64
%695 = load i64, i64* %21
%696 = icmp sgt i64 %694, %695
br i1 %696, label %697, label %699
697: ; preds = %692, %687
%698 = load i64, i64* %21
br label %702
699: ; preds = %692
%700 = load i32, i32* %15
%701 = sext i32 %700 to i64
br label %702
702: ; preds = %699, %697
%703 = phi i64 [ %698, %697 ], [ %701, %699 ]
%704 = load i32, i32* %31
%705 = call i64 @BIO_dump_indent(i32* %688, i8* %689, i64 %703, i32 %704)
%706 = icmp sle i64 %705, 0
br i1 %706, label %707, label %708
707: ; preds = %702
br label %781
708: ; preds = %702
store i32 1, i32* %25
br label %709
709: ; preds = %708, %675, %672
br label %710
710: ; preds = %709, %669
br label %711
711: ; preds = %710, %595
br label %712
712: ; preds = %711, %521
br label %713
713: ; preds = %712, %363
br label %714
714: ; preds = %713, %358
br label %715
715: ; preds = %714, %335
br label %716
716: ; preds = %715, %307
%717 = load i32, i32* %32
%718 = icmp ne i32 %717, 0
br i1 %718, label %719, label %754
719: ; preds = %716
%720 = load i8*, i8** %19
%721 = load i32, i32* %26
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds i8, i8* %720, i64 %722
store i8* %723, i8** %42
%724 = load i32*, i32** %9
%725 = call i64 @BIO_puts(i32* %724, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0))
%726 = icmp sle i64 %725, 0
br i1 %726, label %727, label %728
727: ; preds = %719
br label %781
728: ; preds = %719
store i32 0, i32* %41
br label %729
729: ; preds = %745, %728
%730 = load i32, i32* %41
%731 = sext i32 %730 to i64
%732 = load i64, i64* %21
%733 = icmp slt i64 %731, %732
br i1 %733, label %734, label %748
734: ; preds = %729
%735 = load i32*, i32** %9
%736 = load i8*, i8** %42
%737 = load i32, i32* %41
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds i8, i8* %736, i64 %738
%740 = load i8, i8* %739
%741 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %735, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8 zeroext %740)
%742 = icmp sle i64 %741, 0
br i1 %742, label %743, label %744
743: ; preds = %734
br label %781
744: ; preds = %734
br label %745
745: ; preds = %744
%746 = load i32, i32* %41
%747 = add nsw i32 %746, 1
store i32 %747, i32* %41
br label %729
748: ; preds = %729
%749 = load i32*, i32** %9
%750 = call i64 @BIO_puts(i32* %749, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0))
%751 = icmp sle i64 %750, 0
br i1 %751, label %752, label %753
752: ; preds = %748
br label %781
753: ; preds = %748
br label %754
754: ; preds = %753, %716
%755 = load i32, i32* %25
%756 = icmp ne i32 %755, 0
br i1 %756, label %763, label %757
757: ; preds = %754
%758 = load i32*, i32** %9
%759 = call i64 @BIO_write(i32* %758, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%760 = icmp sle i64 %759, 0
br i1 %760, label %761, label %762
761: ; preds = %757
br label %781
762: ; preds = %757
br label %763
763: ; preds = %762, %754
%764 = load i64, i64* %21
%765 = load i8*, i8** %16
%766 = getelementptr inbounds i8, i8* %765, i64 %764
store i8* %766, i8** %16
%767 = load i32, i32* %22
%768 = load i32, i32* @V_ASN1_EOC
%769 = icmp eq i32 %767, %768
br i1 %769, label %770, label %774
770: ; preds = %763
%771 = load i32, i32* %23
%772 = icmp eq i32 %771, 0
br i1 %772, label %773, label %774
773: ; preds = %770
store i32 2, i32* %24
br label %781
774: ; preds = %770, %763
br label %775
775: ; preds = %774, %255
br label %776
776: ; preds = %775, %243
%777 = load i64, i64* %21
%778 = load i64, i64* %11
%779 = sub nsw i64 %778, %777
store i64 %779, i64* %11
br label %54
780: ; preds = %54
store i32 1, i32* %24
br label %781
781: ; preds = %780, %773, %761, %752, %743, %727, %707, %685, %667, %660, %646, %626, %615, %593, %586, %572, %552, %541, %517, %492, %479, %462, %453, %444, %347, %333, %324, %306, %292, %254, %233, %190, %154, %149, %135, %119, %109, %94, %69, %68
%782 = load i32*, i32** %29
%783 = call i32 @ASN1_OBJECT_free(i32* %782)
%784 = load %struct.TYPE_10__*, %struct.TYPE_10__** %30
%785 = call i32 @ASN1_OCTET_STRING_free(%struct.TYPE_10__* %784)
%786 = load i8*, i8** %16
%787 = load i8**, i8*** %10
store i8* %786, i8** %787
%788 = load i32, i32* %24
store i32 %788, i32* %8
br label %789
789: ; preds = %781, %45
%790 = load i32, i32* %8
ret i32 %790
}

LLVM IR (-O2):
%struct.TYPE_10__ = type { i32, i8* }
%struct.TYPE_11__ = type { i64, i32, i8* }
%struct.TYPE_12__ = type { i64, i32, i8* }
@.str = [21 x i8] c"BAD RECURSION DEPTH\0A\00"
@.str.1 = [19 x i8] c"Error in encoding\0A\00"
@.str.2 = [6 x i8] c"%5ld:\00"
@V_ASN1_CONSTRUCTED = global i32 0
@.str.3 = [22 x i8] c"d=%-2d hl=%ld l=%4ld \00"
@.str.4 = [22 x i8] c"d=%-2d hl=%ld l=inf \00"
@.str.5 = [2 x i8] c"\0A\00"
@.str.6 = [28 x i8] c"length is greater than %ld\0A\00"
@V_ASN1_PRINTABLESTRING = global i32 0
@V_ASN1_T61STRING = global i32 0
@V_ASN1_IA5STRING = global i32 0
@V_ASN1_VISIBLESTRING = global i32 0
@V_ASN1_NUMERICSTRING = global i32 0
@V_ASN1_UTF8STRING = global i32 0
@V_ASN1_UTCTIME = global i32 0
@V_ASN1_GENERALIZEDTIME = global i32 0
@.str.7 = [2 x i8] c":\00"
@V_ASN1_OBJECT = global i32 0
@.str.8 = [12 x i8] c":BAD OBJECT\00"
@V_ASN1_BOOLEAN = global i32 0
@.str.9 = [13 x i8] c":BAD BOOLEAN\00"
@.str.10 = [4 x i8] c":%u\00"
@V_ASN1_BMPSTRING = global i32 0
@V_ASN1_OCTET_STRING = global i32 0
@.str.11 = [12 x i8] c"[HEX DUMP]:\00"
@.str.12 = [5 x i8] c"%02X\00"
@V_ASN1_INTEGER = global i32 0
@V_ASN1_NEG_INTEGER = global i64 0
@.str.13 = [2 x i8] c"-\00"
@.str.14 = [3 x i8] c"00\00"
@.str.15 = [13 x i8] c":BAD INTEGER\00"
@V_ASN1_ENUMERATED = global i32 0
@V_ASN1_NEG_ENUMERATED = global i64 0
@.str.16 = [16 x i8] c":BAD ENUMERATED\00"
@.str.17 = [3 x i8] c":[\00"
@.str.18 = [2 x i8] c"]\00"
@V_ASN1_EOC = global i32 0
define i32 @asn1_parse2(i32* %0, i8** nocapture %1, i64 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i64
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32*
%14 = bitcast i8** %8 to i8*
%15 = bitcast i8** %9 to i8*
%16 = bitcast i64* %10 to i8*
%17 = bitcast i32* %11 to i8*
%18 = bitcast i32* %12 to i8*
%19 = bitcast i32** %13 to i8*
store i32* null, i32** %13
%20 = icmp sgt i32 %4, 128
br i1 %20, label %21, label %23
21: ; preds = %7
%22 = tail call i64 @BIO_puts(i32* %0, i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0))
br label %466
23: ; preds = %7
%24 = load i8*, i8** %1
store i8* %24, i8** %8
%25 = getelementptr inbounds i8, i8* %24, i64 %2
%26 = icmp sgt i64 %2, 0
br i1 %26, label %27, label %459
27: ; preds = %23
%28 = zext i32 %3 to i64
%29 = trunc i32 %4 to i8
%30 = icmp eq i32 %5, 0
%31 = select i1 %30, i32 0, i32 %4
%32 = add nsw i32 %4, 1
%33 = ptrtoint i8* %25 to i64
%34 = icmp ne i32 %6, 0
%35 = icmp eq i32 %6, -1
%36 = sext i32 %6 to i64
%37 = icmp eq i32 %6, 0
%38 = call i32 @ASN1_get_object(i8** %8, i64* %10, i32* %11, i32* %12, i64 %2)
%39 = and i32 %38, 128
%40 = icmp eq i32 %39, 0
br i1 %40, label %43, label %41
41: ; preds = %454, %27
%42 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0), i32 18)
br label %459
43: ; preds = %27, %454
%44 = phi i32 [ %456, %454 ], [ %38, %27 ]
%45 = phi i32 [ %450, %454 ], [ 0, %27 ]
%46 = phi i64 [ %452, %454 ], [ %2, %27 ]
%47 = phi i8* [ %455, %454 ], [ %24, %27 ]
%48 = load i8*, i8** %8
%49 = ptrtoint i8* %48 to i64
%50 = ptrtoint i8* %47 to i64
%51 = sub i64 %49, %50
%52 = shl i64 %51, 32
%53 = ashr exact i64 %52, 32
%54 = sub nsw i64 %46, %53
%55 = load i8*, i8** %1
%56 = ptrtoint i8* %55 to i64
%57 = add i64 %50, %28
%58 = sub i64 %57, %56
%59 = trunc i64 %58 to i8
%60 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %0, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i8 zeroext %59)
%61 = icmp slt i64 %60, 1
br i1 %61, label %459, label %62
62: ; preds = %43
%63 = load i32, i32* @V_ASN1_CONSTRUCTED
%64 = or i32 %63, 1
%65 = icmp eq i32 %44, %64
br i1 %65, label %70, label %66
66: ; preds = %62
%67 = load i64, i64* %10
%68 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %0, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.3, i64 0, i64 0), i8 zeroext %29, i64 %53, i64 %67)
%69 = icmp slt i64 %68, 1
br i1 %69, label %459, label %73
70: ; preds = %62
%71 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %0, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i8 zeroext %29, i64 %53)
%72 = icmp slt i64 %71, 1
br i1 %72, label %459, label %73
73: ; preds = %70, %66
%74 = load i32, i32* %11
%75 = load i32, i32* %12
%76 = call i32 @asn1_print_info(i32* %0, i32 %74, i32 %75, i32 %44, i32 %31)
%77 = icmp eq i32 %76, 0
br i1 %77, label %459, label %78
78: ; preds = %73
%79 = load i32, i32* @V_ASN1_CONSTRUCTED
%80 = and i32 %79, %44
%81 = icmp eq i32 %80, 0
br i1 %81, label %138, label %82
82: ; preds = %78
%83 = load i8*, i8** %8
%84 = load i64, i64* %10
%85 = getelementptr inbounds i8, i8* %83, i64 %84
%86 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%87 = icmp slt i64 %86, 1
br i1 %87, label %459, label %88
88: ; preds = %82
%89 = load i64, i64* %10
%90 = icmp sgt i64 %89, %54
br i1 %90, label %91, label %94
91: ; preds = %88
%92 = trunc i64 %54 to i8
%93 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %0, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.6, i64 0, i64 0), i8 zeroext %92)
br label %459
94: ; preds = %88
%95 = icmp eq i32 %44, 33
%96 = icmp eq i64 %89, 0
%97 = select i1 %95, i1 %96, i1 false
%98 = load i8*, i8** %8
br i1 %97, label %101, label %99
99: ; preds = %94
%100 = icmp ult i8* %98, %85
br i1 %100, label %121, label %449
101: ; preds = %94, %113
%102 = phi i8* [ %114, %113 ], [ %98, %94 ]
%103 = ptrtoint i8* %102 to i64
%104 = sub i64 %33, %103
%105 = load i8*, i8** %1
%106 = ptrtoint i8* %105 to i64
%107 = sub i64 %103, %106
%108 = trunc i64 %107 to i32
%109 = add i32 %108, %3
%110 = call i32 @asn1_parse2(i32* %0, i8** %8, i64 %104, i32 %109, i32 %32, i32 %5, i32 %6)
switch i32 %110, label %113 [
i32 0, label %459
i32 2, label %111
]
111: ; preds = %101
%112 = load i8*, i8** %8
br label %116
113: ; preds = %101
%114 = load i8*, i8** %8
%115 = icmp ult i8* %114, %25
br i1 %115, label %101, label %116
116: ; preds = %113, %111
%117 = phi i8* [ %112, %111 ], [ %114, %113 ]
%118 = ptrtoint i8* %117 to i64
%119 = ptrtoint i8* %83 to i64
%120 = sub i64 %118, %119
store i64 %120, i64* %10
br label %449
121: ; preds = %99, %132
%122 = phi i8* [ %133, %132 ], [ %98, %99 ]
%123 = phi i64 [ %136, %132 ], [ %89, %99 ]
%124 = load i8*, i8** %1
%125 = ptrtoint i8* %122 to i64
%126 = ptrtoint i8* %124 to i64
%127 = sub i64 %125, %126
%128 = trunc i64 %127 to i32
%129 = add i32 %128, %3
%130 = call i32 @asn1_parse2(i32* %0, i8** %8, i64 %123, i32 %129, i32 %32, i32 %5, i32 %6)
%131 = icmp eq i32 %130, 0
br i1 %131, label %459, label %132
132: ; preds = %121
%133 = load i8*, i8** %8
%134 = ptrtoint i8* %133 to i64
%135 = add i64 %123, %125
%136 = sub i64 %135, %134
%137 = icmp ult i8* %133, %85
br i1 %137, label %121, label %449
138: ; preds = %78
%139 = load i32, i32* %12
%140 = icmp eq i32 %139, 0
br i1 %140, label %147, label %141
141: ; preds = %138
%142 = load i64, i64* %10
%143 = load i8*, i8** %8
%144 = getelementptr inbounds i8, i8* %143, i64 %142
store i8* %144, i8** %8
%145 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%146 = icmp slt i64 %145, 1
br i1 %146, label %459, label %449
147: ; preds = %138
%148 = load i32, i32* %11
%149 = load i32, i32* @V_ASN1_PRINTABLESTRING
%150 = icmp eq i32 %148, %149
%151 = load i32, i32* @V_ASN1_T61STRING
%152 = icmp eq i32 %148, %151
%153 = select i1 %150, i1 true, i1 %152
%154 = load i32, i32* @V_ASN1_IA5STRING
%155 = icmp eq i32 %148, %154
%156 = select i1 %153, i1 true, i1 %155
%157 = load i32, i32* @V_ASN1_VISIBLESTRING
%158 = icmp eq i32 %148, %157
%159 = select i1 %156, i1 true, i1 %158
%160 = load i32, i32* @V_ASN1_NUMERICSTRING
%161 = icmp eq i32 %148, %160
%162 = select i1 %159, i1 true, i1 %161
%163 = load i32, i32* @V_ASN1_UTF8STRING
%164 = icmp eq i32 %148, %163
%165 = select i1 %162, i1 true, i1 %164
%166 = load i32, i32* @V_ASN1_UTCTIME
%167 = icmp eq i32 %148, %166
%168 = select i1 %165, i1 true, i1 %167
%169 = load i32, i32* @V_ASN1_GENERALIZEDTIME
%170 = icmp eq i32 %148, %169
%171 = select i1 %168, i1 true, i1 %170
br i1 %171, label %172, label %186
172: ; preds = %147
%173 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%174 = icmp slt i64 %173, 1
br i1 %174, label %459, label %175
175: ; preds = %172
%176 = load i64, i64* %10
%177 = icmp sgt i64 %176, 0
br i1 %177, label %178, label %406
178: ; preds = %175
%179 = load i8*, i8** %8
%180 = trunc i64 %176 to i32
%181 = call i64 @BIO_write(i32* %0, i8* %179, i32 %180)
%182 = load i64, i64* %10
%183 = shl i64 %182, 32
%184 = ashr exact i64 %183, 32
%185 = icmp eq i64 %181, %184
br i1 %185, label %406, label %459
186: ; preds = %147
%187 = load i32, i32* @V_ASN1_OBJECT
%188 = icmp eq i32 %148, %187
br i1 %188, label %189, label %203
189: ; preds = %186
store i8* %47, i8** %9
%190 = load i64, i64* %10
%191 = add nsw i64 %190, %53
%192 = call i32* @d2i_ASN1_OBJECT(i32** %13, i8** %9, i64 %191)
%193 = icmp eq i32* %192, null
br i1 %193, label %200, label %194
194: ; preds = %189
%195 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%196 = icmp slt i64 %195, 1
br i1 %196, label %459, label %197
197: ; preds = %194
%198 = load i32*, i32** %13
%199 = call i32 @i2a_ASN1_OBJECT(i32* %0, i32* %198)
br label %406
200: ; preds = %189
%201 = call i64 @BIO_puts(i32* %0, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.8, i64 0, i64 0))
%202 = icmp slt i64 %201, 1
br i1 %202, label %459, label %410
203: ; preds = %186
%204 = load i32, i32* @V_ASN1_BOOLEAN
%205 = icmp eq i32 %148, %204
br i1 %205, label %206, label %220
206: ; preds = %203
%207 = load i64, i64* %10
%208 = icmp eq i64 %207, 1
br i1 %208, label %215, label %209
209: ; preds = %206
%210 = call i64 @BIO_puts(i32* %0, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.9, i64 0, i64 0))
%211 = icmp slt i64 %210, 1
br i1 %211, label %459, label %212
212: ; preds = %209
%213 = load i64, i64* %10
%214 = icmp sgt i64 %213, 0
br i1 %214, label %215, label %410
215: ; preds = %206, %212
%216 = phi i32 [ 1, %212 ], [ %45, %206 ]
%217 = load i8*, i8** %8
%218 = load i8, i8* %217
%219 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.10, i64 0, i64 0), i8 zeroext %218)
br label %406
220: ; preds = %203
%221 = load i32, i32* @V_ASN1_BMPSTRING
%222 = icmp eq i32 %148, %221
br i1 %222, label %406, label %223
223: ; preds = %220
%224 = load i32, i32* @V_ASN1_OCTET_STRING
%225 = icmp eq i32 %148, %224
br i1 %225, label %226, label %293
226: ; preds = %223
store i8* %47, i8** %9
%227 = load i64, i64* %10
%228 = add nsw i64 %227, %53
%229 = call %struct.TYPE_10__* @d2i_ASN1_OCTET_STRING(i32* null, i8** %9, i64 %228)
%230 = icmp eq %struct.TYPE_10__* %229, null
br i1 %230, label %290, label %231
231: ; preds = %226
%232 = getelementptr inbounds %struct.TYPE_10__, %struct.TYPE_10__* %229, i64 0, i32 0
%233 = load i32, i32* %232
%234 = icmp sgt i32 %233, 0
br i1 %234, label %235, label %290
235: ; preds = %231
%236 = getelementptr inbounds %struct.TYPE_10__, %struct.TYPE_10__* %229, i64 0, i32 1
%237 = load i8*, i8** %236
store i8* %237, i8** %9
%238 = zext i32 %233 to i64
br label %239
239: ; preds = %235, %248
%240 = phi i64 [ 0, %235 ], [ %249, %248 ]
%241 = getelementptr inbounds i8, i8* %237, i64 %240
%242 = load i8, i8* %241
%243 = freeze i8 %242
%244 = icmp ugt i8 %243, 31
br i1 %244, label %246, label %245
245: ; preds = %239
switch i8 %243, label %259 [
i8 13, label %248
i8 10, label %248
i8 9, label %248
]
246: ; preds = %239
%247 = icmp ugt i8 %243, 126
br i1 %247, label %259, label %248
248: ; preds = %245, %245, %245, %246
%249 = add nuw nsw i64 %240, 1
%250 = icmp eq i64 %249, %238
br i1 %250, label %251, label %239
251: ; preds = %248
%252 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%253 = icmp slt i64 %252, 1
br i1 %253, label %459, label %254
254: ; preds = %251
%255 = load i8*, i8** %9
%256 = load i32, i32* %232
%257 = call i64 @BIO_write(i32* %0, i8* %255, i32 %256)
%258 = icmp slt i64 %257, 1
br i1 %258, label %459, label %290
259: ; preds = %246, %245
br i1 %37, label %260, label %278
260: ; preds = %259
%261 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.11, i64 0, i64 0), i32 11)
%262 = icmp slt i64 %261, 1
br i1 %262, label %459, label %263
263: ; preds = %260
%264 = load i32, i32* %232
%265 = icmp sgt i32 %264, 0
br i1 %265, label %270, label %290
266: ; preds = %270
%267 = load i32, i32* %232
%268 = sext i32 %267 to i64
%269 = icmp slt i64 %277, %268
br i1 %269, label %270, label %290
270: ; preds = %263, %266
%271 = phi i64 [ %277, %266 ], [ 0, %263 ]
%272 = load i8*, i8** %9
%273 = getelementptr inbounds i8, i8* %272, i64 %271
%274 = load i8, i8* %273
%275 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8 zeroext %274)
%276 = icmp slt i64 %275, 1
%277 = add nuw nsw i64 %271, 1
br i1 %276, label %459, label %266
278: ; preds = %259
%279 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%280 = icmp slt i64 %279, 1
br i1 %280, label %459, label %281
281: ; preds = %278
%282 = load i8*, i8** %9
%283 = load i32, i32* %232
%284 = icmp slt i32 %283, %6
%285 = select i1 %35, i1 true, i1 %284
%286 = sext i32 %283 to i64
%287 = select i1 %285, i64 %286, i64 %36
%288 = call i64 @BIO_dump_indent(i32* %0, i8* %282, i64 %287, i32 6)
%289 = icmp slt i64 %288, 1
br i1 %289, label %459, label %290
290: ; preds = %266, %263, %226, %231, %254, %281
%291 = phi i32 [ 0, %254 ], [ 0, %231 ], [ 0, %226 ], [ 1, %281 ], [ 0, %263 ], [ 0, %266 ]
%292 = call i32 @ASN1_OCTET_STRING_free(%struct.TYPE_10__* %229)
br label %406
293: ; preds = %223
%294 = load i32, i32* @V_ASN1_INTEGER
%295 = icmp eq i32 %148, %294
br i1 %295, label %296, label %342
296: ; preds = %293
store i8* %47, i8** %9
%297 = load i64, i64* %10
%298 = add nsw i64 %297, %53
%299 = call %struct.TYPE_11__* @d2i_ASN1_INTEGER(i32* null, i8** %9, i64 %298)
%300 = icmp eq %struct.TYPE_11__* %299, null
br i1 %300, label %336, label %301
301: ; preds = %296
%302 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%303 = icmp slt i64 %302, 1
br i1 %303, label %459, label %304
304: ; preds = %301
%305 = getelementptr inbounds %struct.TYPE_11__, %struct.TYPE_11__* %299, i64 0, i32 0
%306 = load i64, i64* %305
%307 = load i64, i64* @V_ASN1_NEG_INTEGER
%308 = icmp eq i64 %306, %307
br i1 %308, label %309, label %312
309: ; preds = %304
%310 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0), i32 1)
%311 = icmp slt i64 %310, 1
br i1 %311, label %459, label %312
312: ; preds = %309, %304
%313 = getelementptr inbounds %struct.TYPE_11__, %struct.TYPE_11__* %299, i64 0, i32 1
%314 = load i32, i32* %313
%315 = icmp sgt i32 %314, 0
br i1 %315, label %316, label %330
316: ; preds = %312
%317 = getelementptr inbounds %struct.TYPE_11__, %struct.TYPE_11__* %299, i64 0, i32 2
br label %322
318: ; preds = %322
%319 = load i32, i32* %313
%320 = sext i32 %319 to i64
%321 = icmp slt i64 %329, %320
br i1 %321, label %322, label %330
322: ; preds = %316, %318
%323 = phi i64 [ 0, %316 ], [ %329, %318 ]
%324 = load i8*, i8** %317
%325 = getelementptr inbounds i8, i8* %324, i64 %323
%326 = load i8, i8* %325
%327 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8 zeroext %326)
%328 = icmp slt i64 %327, 1
%329 = add nuw nsw i64 %323, 1
br i1 %328, label %459, label %318
330: ; preds = %318, %312
%331 = phi i32 [ %314, %312 ], [ %319, %318 ]
%332 = icmp eq i32 %331, 0
br i1 %332, label %333, label %339
333: ; preds = %330
%334 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32 2)
%335 = icmp slt i64 %334, 1
br i1 %335, label %459, label %339
336: ; preds = %296
%337 = call i64 @BIO_puts(i32* %0, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.15, i64 0, i64 0))
%338 = icmp slt i64 %337, 1
br i1 %338, label %459, label %339
339: ; preds = %333, %330, %336
%340 = phi i32 [ %45, %333 ], [ %45, %330 ], [ 1, %336 ]
%341 = call i32 @ASN1_INTEGER_free(%struct.TYPE_11__* %299)
br label %406
342: ; preds = %293
%343 = load i32, i32* @V_ASN1_ENUMERATED
%344 = icmp eq i32 %148, %343
br i1 %344, label %345, label %391
345: ; preds = %342
store i8* %47, i8** %9
%346 = load i64, i64* %10
%347 = add nsw i64 %346, %53
%348 = call %struct.TYPE_12__* @d2i_ASN1_ENUMERATED(i32* null, i8** %9, i64 %347)
%349 = icmp eq %struct.TYPE_12__* %348, null
br i1 %349, label %385, label %350
350: ; preds = %345
%351 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i64 0, i64 0), i32 1)
%352 = icmp slt i64 %351, 1
br i1 %352, label %459, label %353
353: ; preds = %350
%354 = getelementptr inbounds %struct.TYPE_12__, %struct.TYPE_12__* %348, i64 0, i32 0
%355 = load i64, i64* %354
%356 = load i64, i64* @V_ASN1_NEG_ENUMERATED
%357 = icmp eq i64 %355, %356
br i1 %357, label %358, label %361
358: ; preds = %353
%359 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i64 0, i64 0), i32 1)
%360 = icmp slt i64 %359, 1
br i1 %360, label %459, label %361
361: ; preds = %358, %353
%362 = getelementptr inbounds %struct.TYPE_12__, %struct.TYPE_12__* %348, i64 0, i32 1
%363 = load i32, i32* %362
%364 = icmp sgt i32 %363, 0
br i1 %364, label %365, label %379
365: ; preds = %361
%366 = getelementptr inbounds %struct.TYPE_12__, %struct.TYPE_12__* %348, i64 0, i32 2
br label %371
367: ; preds = %371
%368 = load i32, i32* %362
%369 = sext i32 %368 to i64
%370 = icmp slt i64 %378, %369
br i1 %370, label %371, label %379
371: ; preds = %365, %367
%372 = phi i64 [ 0, %365 ], [ %378, %367 ]
%373 = load i8*, i8** %366
%374 = getelementptr inbounds i8, i8* %373, i64 %372
%375 = load i8, i8* %374
%376 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8 zeroext %375)
%377 = icmp slt i64 %376, 1
%378 = add nuw nsw i64 %372, 1
br i1 %377, label %459, label %367
379: ; preds = %367, %361
%380 = phi i32 [ %363, %361 ], [ %368, %367 ]
%381 = icmp eq i32 %380, 0
br i1 %381, label %382, label %388
382: ; preds = %379
%383 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i64 0, i64 0), i32 2)
%384 = icmp slt i64 %383, 1
br i1 %384, label %459, label %388
385: ; preds = %345
%386 = call i64 @BIO_puts(i32* %0, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.16, i64 0, i64 0))
%387 = icmp slt i64 %386, 1
br i1 %387, label %459, label %388
388: ; preds = %382, %379, %385
%389 = phi i32 [ %45, %382 ], [ %45, %379 ], [ 1, %385 ]
%390 = call i32 @ASN1_ENUMERATED_free(%struct.TYPE_12__* %348)
br label %406
391: ; preds = %342
%392 = load i64, i64* %10
%393 = icmp sgt i64 %392, 0
%394 = and i1 %34, %393
br i1 %394, label %395, label %406
395: ; preds = %391
%396 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%397 = icmp slt i64 %396, 1
br i1 %397, label %459, label %398
398: ; preds = %395
%399 = load i8*, i8** %8
%400 = load i64, i64* %10
%401 = icmp slt i64 %400, %36
%402 = select i1 %35, i1 true, i1 %401
%403 = select i1 %402, i64 %400, i64 %36
%404 = call i64 @BIO_dump_indent(i32* %0, i8* %399, i64 %403, i32 6)
%405 = icmp slt i64 %404, 1
br i1 %405, label %459, label %406
406: ; preds = %388, %339, %290, %398, %197, %220, %391, %215, %175, %178
%407 = phi i32 [ 0, %178 ], [ 0, %175 ], [ 0, %197 ], [ 0, %215 ], [ 0, %220 ], [ %291, %290 ], [ 0, %339 ], [ 0, %388 ], [ 0, %391 ], [ 1, %398 ]
%408 = phi i32 [ %45, %178 ], [ %45, %175 ], [ %45, %197 ], [ %216, %215 ], [ %45, %220 ], [ %45, %290 ], [ %340, %339 ], [ %389, %388 ], [ %45, %391 ], [ %45, %398 ]
%409 = icmp eq i32 %408, 0
br i1 %409, label %432, label %410
410: ; preds = %200, %212, %406
%411 = phi i32 [ %408, %406 ], [ 1, %212 ], [ 1, %200 ]
%412 = phi i32 [ %407, %406 ], [ 0, %212 ], [ 0, %200 ]
%413 = getelementptr inbounds i8, i8* %47, i64 %53
%414 = call i64 @BIO_puts(i32* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.17, i64 0, i64 0))
%415 = icmp slt i64 %414, 1
br i1 %415, label %459, label %416
416: ; preds = %410
%417 = load i64, i64* %10
%418 = icmp sgt i64 %417, 0
br i1 %418, label %422, label %429
419: ; preds = %422
%420 = load i64, i64* %10
%421 = icmp sgt i64 %420, %428
br i1 %421, label %422, label %429
422: ; preds = %416, %419
%423 = phi i64 [ %428, %419 ], [ 0, %416 ]
%424 = getelementptr inbounds i8, i8* %413, i64 %423
%425 = load i8, i8* %424
%426 = call i64 (i32*, i8*, i8, ...) @BIO_printf(i32* %0, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.12, i64 0, i64 0), i8 zeroext %425)
%427 = icmp slt i64 %426, 1
%428 = add nuw nsw i64 %423, 1
br i1 %427, label %459, label %419
429: ; preds = %419, %416
%430 = call i64 @BIO_puts(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0))
%431 = icmp slt i64 %430, 1
br i1 %431, label %459, label %432
432: ; preds = %429, %406
%433 = phi i32 [ 0, %406 ], [ %411, %429 ]
%434 = phi i32 [ %407, %406 ], [ %412, %429 ]
%435 = icmp eq i32 %434, 0
br i1 %435, label %436, label %439
436: ; preds = %432
%437 = call i64 @BIO_write(i32* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0), i32 1)
%438 = icmp slt i64 %437, 1
br i1 %438, label %459, label %439
439: ; preds = %436, %432
%440 = load i64, i64* %10
%441 = load i8*, i8** %8
%442 = getelementptr inbounds i8, i8* %441, i64 %440
store i8* %442, i8** %8
%443 = load i32, i32* %11
%444 = load i32, i32* @V_ASN1_EOC
%445 = icmp eq i32 %443, %444
%446 = load i32, i32* %12
%447 = icmp eq i32 %446, 0
%448 = select i1 %445, i1 %447, i1 false
br i1 %448, label %459, label %449
449: ; preds = %132, %99, %116, %141, %439
%450 = phi i32 [ %45, %141 ], [ %433, %439 ], [ %45, %116 ], [ %45, %99 ], [ %45, %132 ]
%451 = load i64, i64* %10
%452 = sub nsw i64 %54, %451
%453 = icmp sgt i64 %452, 0
br i1 %453, label %454, label %459
454: ; preds = %449
%455 = load i8*, i8** %8
%456 = call i32 @ASN1_get_object(i8** %8, i64* %10, i32* %11, i32* %12, i64 %452)
%457 = and i32 %456, 128
%458 = icmp eq i32 %457, 0
br i1 %458, label %43, label %41
459: ; preds = %43, %66, %70, %73, %141, %172, %178, %194, %200, %209, %395, %398, %436, %439, %449, %82, %251, %254, %260, %278, %281, %301, %309, %333, %336, %350, %358, %382, %385, %410, %429, %121, %101, %371, %322, %270, %422, %23, %91, %41
%460 = phi %struct.TYPE_10__* [ null, %41 ], [ null, %91 ], [ null, %23 ], [ null, %422 ], [ %229, %270 ], [ null, %322 ], [ null, %371 ], [ null, %101 ], [ null, %121 ], [ null, %43 ], [ null, %66 ], [ null, %70 ], [ null, %73 ], [ null, %141 ], [ null, %172 ], [ null, %178 ], [ null, %194 ], [ null, %200 ], [ null, %209 ], [ null, %395 ], [ null, %398 ], [ null, %436 ], [ null, %439 ], [ null, %449 ], [ null, %82 ], [ %229, %251 ], [ %229, %254 ], [ %229, %260 ], [ %229, %278 ], [ %229, %281 ], [ null, %301 ], [ null, %309 ], [ null, %333 ], [ null, %336 ], [ null, %350 ], [ null, %358 ], [ null, %382 ], [ null, %385 ], [ null, %410 ], [ null, %429 ]
%461 = phi i32 [ 0, %41 ], [ 0, %91 ], [ 1, %23 ], [ 0, %422 ], [ 0, %270 ], [ 0, %322 ], [ 0, %371 ], [ %110, %101 ], [ 0, %121 ], [ 0, %43 ], [ 0, %66 ], [ 0, %70 ], [ 0, %73 ], [ 0, %141 ], [ 0, %172 ], [ 0, %178 ], [ 0, %194 ], [ 0, %200 ], [ 0, %209 ], [ 0, %395 ], [ 0, %398 ], [ 0, %436 ], [ 2, %439 ], [ 1, %449 ], [ 0, %82 ], [ 0, %251 ], [ 0, %254 ], [ 0, %260 ], [ 0, %278 ], [ 0, %281 ], [ 0, %301 ], [ 0, %309 ], [ 0, %333 ], [ 0, %336 ], [ 0, %350 ], [ 0, %358 ], [ 0, %382 ], [ 0, %385 ], [ 0, %410 ], [ 0, %429 ]
%462 = load i32*, i32** %13
%463 = call i32 @ASN1_OBJECT_free(i32* %462)
%464 = call i32 @ASN1_OCTET_STRING_free(%struct.TYPE_10__* %460)
%465 = load i8*, i8** %8
store i8* %465, i8** %1
br label %466
466: ; preds = %459, %21
%467 = phi i32 [ 0, %21 ], [ %461, %459 ]
ret i32 %467
}