#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 *, ...);
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);
int d2i_ASN1_BOOLEAN(int /*<<< orphan*/ *, unsigned char const **, long);
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_indent = 6;
  p = *pp;
  tot = p + length;
  op = p - 1;
  if (depth > 128) {
    BIO_printf(bp, "Max depth exceeded\n");
    goto end;
  }
  while ((p < tot) && (op < p)) {
    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) {
      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 = (long)(p - ep);
            break;
          }
        }
      } else {
        while (p < ep) {
          r = asn1_parse2(bp, &p, (long)(ep - p), offset + (p - *pp), depth + 1,
                          indent, dump);
          if (r == 0) {
            ret = 0;
            goto end;
          }
        }
      }
    } 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_write(bp, ":BAD OBJECT", 11) <= 0)
            goto end;
        }
      } else if (tag == V_ASN1_BOOLEAN) {
        int ii;
        opp = op;
        ii = d2i_ASN1_BOOLEAN(NULL, &opp, len + hl);
        if (ii < 0) {
          if (BIO_write(bp, "Bad boolean\n", 12) <= 0)
            goto end;
        }
        BIO_printf(bp, ":%d", ii);
      } 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_write(bp, "BAD INTEGER", 11) <= 0)
            goto end;
        }
        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_write(bp, "BAD ENUMERATED", 14) <= 0)
            goto end;
        }
        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 (!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:
  if (o != NULL)
    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    $0x110,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x64(%rbp)
movq   $0x0,-0x80(%rbp)
movq   $0x0,-0x88(%rbp)
movl   $0x6,-0x8c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
cmpl   $0x80,-0x20(%rbp)
jle    1290 <asn1_parse2+0x90>
mov    -0x8(%rbp),%rdi
lea    0x1d7c(%rip),%rsi
mov    $0x0,%al
call   1060 <BIO_printf@plt>
jmp    2032 <asn1_parse2+0xe32>
jmp    1295 <asn1_parse2+0x95>
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x40(%rbp),%rcx
mov    %al,-0xb5(%rbp)
jae    12bc <asn1_parse2+0xbc>
mov    -0x48(%rbp),%rax
cmp    -0x30(%rbp),%rax
setb   %al
mov    %al,-0xb5(%rbp)
mov    -0xb5(%rbp),%al
test   $0x1,%al
jne    12cf <asn1_parse2+0xcf>
jmp    202b <asn1_parse2+0xe2b>
mov    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%r8
lea    -0x30(%rbp),%rdi
lea    -0x58(%rbp),%rsi
lea    -0x5c(%rbp),%rdx
lea    -0x60(%rbp),%rcx
call   10c0 <ASN1_get_object@plt>
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
and    $0x80,%eax
cmp    $0x0,%eax
je     1334 <asn1_parse2+0x134>
mov    -0x8(%rbp),%rdi
lea    0x1d05(%rip),%rsi
mov    $0x12,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1328 <asn1_parse2+0x128>
jmp    2032 <asn1_parse2+0xe32>
movl   $0x0,-0x64(%rbp)
jmp    2032 <asn1_parse2+0xe32>
mov    -0x30(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x6c(%rbp)
movslq -0x6c(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
movslq -0x1c(%rbp),%rdx
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
add    %rax,%rdx
lea    0x1cb6(%rip),%rsi
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     1387 <asn1_parse2+0x187>
jmp    2032 <asn1_parse2+0xe32>
mov    -0x70(%rbp),%eax
mov    0x3bdf(%rip),%rcx
mov    (%rcx),%ecx
or     $0x1,%ecx
cmp    %ecx,%eax
je     13cf <asn1_parse2+0x1cf>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%edx
movslq -0x6c(%rbp),%rcx
mov    -0x58(%rbp),%r8
lea    0x1c79(%rip),%rsi
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     13ca <asn1_parse2+0x1ca>
jmp    2032 <asn1_parse2+0xe32>
jmp    13fc <asn1_parse2+0x1fc>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%edx
movslq -0x6c(%rbp),%rcx
lea    0x1c62(%rip),%rsi
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     13f7 <asn1_parse2+0x1f7>
jmp    2032 <asn1_parse2+0xe32>
jmp    13fc <asn1_parse2+0x1fc>
mov    -0x8(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0xbc(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     143a <asn1_parse2+0x23a>
mov    -0x20(%rbp),%eax
mov    %eax,-0xd4(%rbp)
jmp    1447 <asn1_parse2+0x247>
xor    %eax,%eax
mov    %eax,-0xd4(%rbp)
jmp    1447 <asn1_parse2+0x247>
mov    -0xbc(%rbp),%ecx
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%esi
mov    -0xd0(%rbp),%rdi
mov    -0xd4(%rbp),%r8d
call   1100 <asn1_print_info@plt>
cmp    $0x0,%eax
jne    147a <asn1_parse2+0x27a>
jmp    2032 <asn1_parse2+0xe32>
mov    -0x70(%rbp),%eax
mov    0x3aec(%rip),%rcx
and    (%rcx),%eax
cmp    $0x0,%eax
je     1615 <asn1_parse2+0x415>
mov    -0x30(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
lea    0x1b6c(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     14bf <asn1_parse2+0x2bf>
jmp    2032 <asn1_parse2+0xe32>
mov    -0x58(%rbp),%rax
cmp    -0x18(%rbp),%rax
jle    14ef <asn1_parse2+0x2ef>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rdx
lea    0x1b7d(%rip),%rsi
mov    $0x0,%al
call   1060 <BIO_printf@plt>
movl   $0x0,-0x64(%rbp)
jmp    2032 <asn1_parse2+0xe32>
cmpl   $0x21,-0x70(%rbp)
jne    1599 <asn1_parse2+0x399>
cmpq   $0x0,-0x58(%rbp)
jne    1599 <asn1_parse2+0x399>
jmp    1509 <asn1_parse2+0x309>
mov    -0x8(%rbp),%rdi
mov    -0x40(%rbp),%rdx
mov    -0x30(%rbp),%rax
sub    %rax,%rdx
movslq -0x1c(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x10(%rbp),%rsi
mov    (%rsi),%rsi
sub    %rsi,%rcx
add    %rcx,%rax
mov    %eax,%ecx
mov    -0x20(%rbp),%r8d
add    $0x1,%r8d
mov    -0x24(%rbp),%r9d
mov    0x10(%rbp),%eax
lea    -0x30(%rbp),%rsi
mov    %eax,(%rsp)
call   1070 <asn1_parse2@plt>
mov    %eax,-0x74(%rbp)
cmpl   $0x0,-0x74(%rbp)
jne    1563 <asn1_parse2+0x363>
movl   $0x0,-0x64(%rbp)
jmp    2032 <asn1_parse2+0xe32>
cmpl   $0x2,-0x74(%rbp)
je     157b <asn1_parse2+0x37b>
mov    -0x30(%rbp),%rax
cmp    -0x40(%rbp),%rax
jb     158f <asn1_parse2+0x38f>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x58(%rbp)
jmp    1594 <asn1_parse2+0x394>
jmp    1509 <asn1_parse2+0x309>
jmp    1610 <asn1_parse2+0x410>
jmp    159e <asn1_parse2+0x39e>
mov    -0x30(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    160b <asn1_parse2+0x40b>
mov    -0x8(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    -0x30(%rbp),%rax
sub    %rax,%rdx
movslq -0x1c(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x10(%rbp),%rsi
mov    (%rsi),%rsi
sub    %rsi,%rcx
add    %rcx,%rax
mov    %eax,%ecx
mov    -0x20(%rbp),%r8d
add    $0x1,%r8d
mov    -0x24(%rbp),%r9d
mov    0x10(%rbp),%eax
lea    -0x30(%rbp),%rsi
mov    %eax,(%rsp)
call   1070 <asn1_parse2@plt>
mov    %eax,-0x74(%rbp)
cmpl   $0x0,-0x74(%rbp)
jne    1606 <asn1_parse2+0x406>
movl   $0x0,-0x64(%rbp)
jmp    2032 <asn1_parse2+0xe32>
jmp    159e <asn1_parse2+0x39e>
jmp    1610 <asn1_parse2+0x410>
jmp    2017 <asn1_parse2+0xe17>
cmpl   $0x0,-0x60(%rbp)
je     1654 <asn1_parse2+0x454>
mov    -0x58(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
lea    0x19dc(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     164f <asn1_parse2+0x44f>
jmp    2032 <asn1_parse2+0xe32>
jmp    2012 <asn1_parse2+0xe12>
movl   $0x0,-0x68(%rbp)
mov    -0x5c(%rbp),%eax
mov    0x391b(%rip),%rcx
cmp    (%rcx),%eax
je     16eb <asn1_parse2+0x4eb>
mov    -0x5c(%rbp),%eax
mov    0x3921(%rip),%rcx
cmp    (%rcx),%eax
je     16eb <asn1_parse2+0x4eb>
mov    -0x5c(%rbp),%eax
mov    0x38ff(%rip),%rcx
cmp    (%rcx),%eax
je     16eb <asn1_parse2+0x4eb>
mov    -0x5c(%rbp),%eax
mov    0x3935(%rip),%rcx
cmp    (%rcx),%eax
je     16eb <asn1_parse2+0x4eb>
mov    -0x5c(%rbp),%eax
mov    0x393b(%rip),%rcx
cmp    (%rcx),%eax
je     16eb <asn1_parse2+0x4eb>
mov    -0x5c(%rbp),%eax
mov    0x3901(%rip),%rcx
cmp    (%rcx),%eax
je     16eb <asn1_parse2+0x4eb>
mov    -0x5c(%rbp),%eax
mov    0x388f(%rip),%rcx
cmp    (%rcx),%eax
je     16eb <asn1_parse2+0x4eb>
mov    -0x5c(%rbp),%eax
mov    0x38d5(%rip),%rcx
cmp    (%rcx),%eax
jne    1747 <asn1_parse2+0x547>
mov    -0x8(%rbp),%rdi
lea    0x19a6(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     170f <asn1_parse2+0x50f>
jmp    2032 <asn1_parse2+0xe32>
cmpq   $0x0,-0x58(%rbp)
jle    1742 <asn1_parse2+0x542>
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x58(%rbp),%rax
mov    %eax,%edx
call   1120 <BIO_write@plt>
mov    -0x58(%rbp),%rcx
movslq %ecx,%rcx
cmp    %rcx,%rax
je     1742 <asn1_parse2+0x542>
jmp    2032 <asn1_parse2+0xe32>
jmp    1fa6 <asn1_parse2+0xda6>
mov    -0x5c(%rbp),%eax
mov    0x3877(%rip),%rcx
cmp    (%rcx),%eax
jne    17e7 <asn1_parse2+0x5e7>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rdx
movslq -0x6c(%rbp),%rax
add    %rax,%rdx
lea    -0x80(%rbp),%rdi
lea    -0x50(%rbp),%rsi
call   1080 <d2i_ASN1_OBJECT@plt>
cmp    $0x0,%rax
je     17b9 <asn1_parse2+0x5b9>
mov    -0x8(%rbp),%rdi
lea    0x190e(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     17a7 <asn1_parse2+0x5a7>
jmp    2032 <asn1_parse2+0xe32>
mov    -0x8(%rbp),%rdi
mov    -0x80(%rbp),%rsi
call   1030 <i2a_ASN1_OBJECT@plt>
jmp    17e2 <asn1_parse2+0x5e2>
mov    -0x8(%rbp),%rdi
lea    0x18b1(%rip),%rsi
mov    $0xb,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     17dd <asn1_parse2+0x5dd>
jmp    2032 <asn1_parse2+0xe32>
jmp    17e2 <asn1_parse2+0x5e2>
jmp    1fa1 <asn1_parse2+0xda1>
mov    -0x5c(%rbp),%eax
mov    0x379f(%rip),%rcx
cmp    (%rcx),%eax
jne    1872 <asn1_parse2+0x672>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rdx
movslq -0x6c(%rbp),%rax
add    %rax,%rdx
xor    %eax,%eax
mov    %eax,%edi
lea    -0x50(%rbp),%rsi
call   10f0 <d2i_ASN1_BOOLEAN@plt>
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jge    1855 <asn1_parse2+0x655>
mov    -0x8(%rbp),%rdi
lea    0x184a(%rip),%rsi
mov    $0xc,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1850 <asn1_parse2+0x650>
jmp    2032 <asn1_parse2+0xe32>
jmp    1855 <asn1_parse2+0x655>
mov    -0x8(%rbp),%rdi
mov    -0x90(%rbp),%edx
lea    0x1828(%rip),%rsi
mov    $0x0,%al
call   1060 <BIO_printf@plt>
jmp    1f9c <asn1_parse2+0xd9c>
mov    -0x5c(%rbp),%eax
mov    0x36dc(%rip),%rcx
cmp    (%rcx),%eax
jne    1889 <asn1_parse2+0x689>
jmp    1f97 <asn1_parse2+0xd97>
mov    -0x5c(%rbp),%eax
mov    0x36d5(%rip),%rcx
cmp    (%rcx),%eax
jne    1b8e <asn1_parse2+0x98e>
movl   $0x1,-0x98(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rdx
movslq -0x6c(%rbp),%rax
add    %rax,%rdx
xor    %eax,%eax
mov    %eax,%edi
lea    -0x50(%rbp),%rsi
call   1040 <d2i_ASN1_OCTET_STRING@plt>
mov    %rax,-0x88(%rbp)
cmpq   $0x0,-0x88(%rbp)
je     1b72 <asn1_parse2+0x972>
mov    -0x88(%rbp),%rax
cmpl   $0x0,(%rax)
jle    1b72 <asn1_parse2+0x972>
mov    -0x88(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x88(%rbp),%rcx
cmp    (%rcx),%eax
jge    19b8 <asn1_parse2+0x7b8>
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jge    1978 <asn1_parse2+0x778>
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0xa,%eax
je     1978 <asn1_parse2+0x778>
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0xd,%eax
je     1978 <asn1_parse2+0x778>
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x9,%eax
jne    1990 <asn1_parse2+0x790>
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x7e,%eax
jle    199f <asn1_parse2+0x79f>
movl   $0x0,-0x98(%rbp)
jmp    19b8 <asn1_parse2+0x7b8>
jmp    19a4 <asn1_parse2+0x7a4>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1903 <asn1_parse2+0x703>
cmpl   $0x0,-0x98(%rbp)
je     1a13 <asn1_parse2+0x813>
mov    -0x8(%rbp),%rdi
lea    0x16cc(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     19e9 <asn1_parse2+0x7e9>
jmp    2032 <asn1_parse2+0xe32>
mov    -0x8(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x88(%rbp),%rax
mov    (%rax),%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1a0e <asn1_parse2+0x80e>
jmp    2032 <asn1_parse2+0xe32>
jmp    1b6d <asn1_parse2+0x96d>
cmpl   $0x0,0x10(%rbp)
jne    1aae <asn1_parse2+0x8ae>
mov    -0x8(%rbp),%rdi
lea    0x166a(%rip),%rsi
mov    $0xb,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1a41 <asn1_parse2+0x841>
jmp    2032 <asn1_parse2+0xe32>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x88(%rbp),%rcx
cmp    (%rcx),%eax
jge    1aa9 <asn1_parse2+0x8a9>
mov    -0x8(%rbp),%rdi
mov    -0x50(%rbp),%rax
movslq -0x94(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
lea    0x1624(%rip),%rsi
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     1a90 <asn1_parse2+0x890>
jmp    2032 <asn1_parse2+0xe32>
jmp    1a95 <asn1_parse2+0x895>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1a4b <asn1_parse2+0x84b>
jmp    1b68 <asn1_parse2+0x968>
cmpl   $0x0,-0x68(%rbp)
jne    1ae1 <asn1_parse2+0x8e1>
mov    -0x8(%rbp),%rdi
lea    0x154f(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1adc <asn1_parse2+0x8dc>
jmp    2032 <asn1_parse2+0xe32>
jmp    1ae1 <asn1_parse2+0x8e1>
mov    -0x8(%rbp),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0xe0(%rbp)
cmpl   $0xffffffff,0x10(%rbp)
je     1b13 <asn1_parse2+0x913>
mov    0x10(%rbp),%eax
mov    -0x88(%rbp),%rcx
cmp    (%rcx),%eax
jle    1b27 <asn1_parse2+0x927>
mov    -0x88(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xec(%rbp)
jmp    1b30 <asn1_parse2+0x930>
mov    0x10(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xe0(%rbp),%rsi
mov    -0xe8(%rbp),%rdi
mov    -0xec(%rbp),%eax
movslq %eax,%rdx
mov    -0x8c(%rbp),%ecx
call   10d0 <BIO_dump_indent@plt>
cmp    $0x0,%rax
jg     1b61 <asn1_parse2+0x961>
jmp    2032 <asn1_parse2+0xe32>
movl   $0x1,-0x68(%rbp)
jmp    1b6d <asn1_parse2+0x96d>
jmp    1b72 <asn1_parse2+0x972>
mov    -0x88(%rbp),%rdi
call   1050 <ASN1_OCTET_STRING_free@plt>
movq   $0x0,-0x88(%rbp)
jmp    1f92 <asn1_parse2+0xd92>
mov    -0x5c(%rbp),%eax
mov    0x3418(%rip),%rcx
cmp    (%rcx),%eax
jne    1d25 <asn1_parse2+0xb25>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rdx
movslq -0x6c(%rbp),%rax
add    %rax,%rdx
xor    %eax,%eax
mov    %eax,%edi
lea    -0x50(%rbp),%rsi
call   10b0 <d2i_ASN1_INTEGER@plt>
mov    %rax,-0xa0(%rbp)
cmpq   $0x0,-0xa0(%rbp)
je     1ceb <asn1_parse2+0xaeb>
mov    -0x8(%rbp),%rdi
lea    0x14bc(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1bf9 <asn1_parse2+0x9f9>
jmp    2032 <asn1_parse2+0xe32>
mov    -0xa0(%rbp),%rax
mov    (%rax),%rax
mov    0x336e(%rip),%rcx
cmp    (%rcx),%rax
jne    1c3c <asn1_parse2+0xa3c>
mov    -0x8(%rbp),%rdi
lea    0x1485(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1c37 <asn1_parse2+0xa37>
jmp    2032 <asn1_parse2+0xe32>
jmp    1c3c <asn1_parse2+0xa3c>
movl   $0x0,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0xa0(%rbp),%rcx
cmp    0x8(%rcx),%eax
jge    1cac <asn1_parse2+0xaac>
mov    -0x8(%rbp),%rdi
mov    -0xa0(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0xa4(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
lea    0x1421(%rip),%rsi
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     1c93 <asn1_parse2+0xa93>
jmp    2032 <asn1_parse2+0xe32>
jmp    1c98 <asn1_parse2+0xa98>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1c46 <asn1_parse2+0xa46>
mov    -0xa0(%rbp),%rax
cmpl   $0x0,0x8(%rax)
jne    1ce6 <asn1_parse2+0xae6>
mov    -0x8(%rbp),%rdi
lea    0x13dd(%rip),%rsi
mov    $0x2,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1ce1 <asn1_parse2+0xae1>
jmp    2032 <asn1_parse2+0xe32>
jmp    1ce6 <asn1_parse2+0xae6>
jmp    1d14 <asn1_parse2+0xb14>
mov    -0x8(%rbp),%rdi
lea    0x13b2(%rip),%rsi
mov    $0xb,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1d0f <asn1_parse2+0xb0f>
jmp    2032 <asn1_parse2+0xe32>
jmp    1d14 <asn1_parse2+0xb14>
mov    -0xa0(%rbp),%rdi
call   1110 <ASN1_INTEGER_free@plt>
jmp    1f8d <asn1_parse2+0xd8d>
mov    -0x5c(%rbp),%eax
mov    0x3271(%rip),%rcx
cmp    (%rcx),%eax
jne    1ebc <asn1_parse2+0xcbc>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rdx
movslq -0x6c(%rbp),%rax
add    %rax,%rdx
xor    %eax,%eax
mov    %eax,%edi
lea    -0x50(%rbp),%rsi
call   1090 <d2i_ASN1_ENUMERATED@plt>
mov    %rax,-0xb0(%rbp)
cmpq   $0x0,-0xb0(%rbp)
je     1e82 <asn1_parse2+0xc82>
mov    -0x8(%rbp),%rdi
lea    0x1325(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1d90 <asn1_parse2+0xb90>
jmp    2032 <asn1_parse2+0xe32>
mov    -0xb0(%rbp),%rax
mov    (%rax),%rax
mov    0x3237(%rip),%rcx
cmp    (%rcx),%rax
jne    1dd3 <asn1_parse2+0xbd3>
mov    -0x8(%rbp),%rdi
lea    0x12ee(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1dce <asn1_parse2+0xbce>
jmp    2032 <asn1_parse2+0xe32>
jmp    1dd3 <asn1_parse2+0xbd3>
movl   $0x0,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    -0xb0(%rbp),%rcx
cmp    0x8(%rcx),%eax
jge    1e43 <asn1_parse2+0xc43>
mov    -0x8(%rbp),%rdi
mov    -0xb0(%rbp),%rax
mov    0x10(%rax),%rax
movslq -0xb4(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
lea    0x128a(%rip),%rsi
mov    $0x0,%al
call   1060 <BIO_printf@plt>
cmp    $0x0,%rax
jg     1e2a <asn1_parse2+0xc2a>
jmp    2032 <asn1_parse2+0xe32>
jmp    1e2f <asn1_parse2+0xc2f>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    1ddd <asn1_parse2+0xbdd>
mov    -0xb0(%rbp),%rax
cmpl   $0x0,0x8(%rax)
jne    1e7d <asn1_parse2+0xc7d>
mov    -0x8(%rbp),%rdi
lea    0x1246(%rip),%rsi
mov    $0x2,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1e78 <asn1_parse2+0xc78>
jmp    2032 <asn1_parse2+0xe32>
jmp    1e7d <asn1_parse2+0xc7d>
jmp    1eab <asn1_parse2+0xcab>
mov    -0x8(%rbp),%rdi
lea    0x1227(%rip),%rsi
mov    $0xe,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1ea6 <asn1_parse2+0xca6>
jmp    2032 <asn1_parse2+0xe32>
jmp    1eab <asn1_parse2+0xcab>
mov    -0xb0(%rbp),%rdi
call   10a0 <ASN1_ENUMERATED_free@plt>
jmp    1f88 <asn1_parse2+0xd88>
cmpq   $0x0,-0x58(%rbp)
jle    1f83 <asn1_parse2+0xd83>
cmpl   $0x0,0x10(%rbp)
je     1f83 <asn1_parse2+0xd83>
cmpl   $0x0,-0x68(%rbp)
jne    1f04 <asn1_parse2+0xd04>
mov    -0x8(%rbp),%rdi
lea    0x112c(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1eff <asn1_parse2+0xcff>
jmp    2032 <asn1_parse2+0xe32>
jmp    1f04 <asn1_parse2+0xd04>
mov    -0x8(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0xf8(%rbp)
cmpl   $0xffffffff,0x10(%rbp)
je     1f32 <asn1_parse2+0xd32>
movslq 0x10(%rbp),%rax
cmp    -0x58(%rbp),%rax
jle    1f42 <asn1_parse2+0xd42>
mov    -0x58(%rbp),%rax
mov    %rax,-0x108(%rbp)
jmp    1f4d <asn1_parse2+0xd4d>
movslq 0x10(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0xf8(%rbp),%rsi
mov    -0x100(%rbp),%rdi
mov    -0x108(%rbp),%rdx
mov    -0x8c(%rbp),%ecx
call   10d0 <BIO_dump_indent@plt>
cmp    $0x0,%rax
jg     1f7c <asn1_parse2+0xd7c>
jmp    2032 <asn1_parse2+0xe32>
movl   $0x1,-0x68(%rbp)
jmp    1f88 <asn1_parse2+0xd88>
jmp    1f8d <asn1_parse2+0xd8d>
jmp    1f92 <asn1_parse2+0xd92>
jmp    1f97 <asn1_parse2+0xd97>
jmp    1f9c <asn1_parse2+0xd9c>
jmp    1fa1 <asn1_parse2+0xda1>
jmp    1fa6 <asn1_parse2+0xda6>
cmpl   $0x0,-0x68(%rbp)
jne    1fd9 <asn1_parse2+0xdd9>
mov    -0x8(%rbp),%rdi
lea    0x1057(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
cmp    $0x0,%rax
jg     1fd4 <asn1_parse2+0xdd4>
jmp    2032 <asn1_parse2+0xe32>
jmp    1fd9 <asn1_parse2+0xdd9>
mov    -0x58(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x5c(%rbp),%eax
mov    0x3009(%rip),%rcx
cmp    (%rcx),%eax
jne    200d <asn1_parse2+0xe0d>
cmpl   $0x0,-0x60(%rbp)
jne    200d <asn1_parse2+0xe0d>
movl   $0x2,-0x64(%rbp)
jmp    2032 <asn1_parse2+0xe32>
jmp    2012 <asn1_parse2+0xe12>
jmp    2017 <asn1_parse2+0xe17>
mov    -0x58(%rbp),%rcx
mov    -0x18(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x18(%rbp)
jmp    1295 <asn1_parse2+0x95>
movl   $0x1,-0x64(%rbp)
cmpq   $0x0,-0x80(%rbp)
je     2046 <asn1_parse2+0xe46>
mov    -0x80(%rbp),%rdi
call   10e0 <ASN1_OBJECT_free@plt>
mov    -0x88(%rbp),%rdi
call   1050 <ASN1_OCTET_STRING_free@plt>
mov    -0x30(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x64(%rbp),%eax
add    $0x110,%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
movq   $0x0,0x60(%rsp)
mov    %rsi,0x58(%rsp)
mov    (%rsi),%rax
mov    %rax,0x30(%rsp)
mov    %rax,0x20(%rsp)
cmp    $0x80,%r8d
jle    124a <asn1_parse2+0x4a>
lea    0xdc4(%rip),%rsi
xor    %ebx,%ebx
xor    %eax,%eax
call   1060 <BIO_printf@plt>
jmp    1c18 <asn1_parse2+0xa18>
mov    %rdx,%r14
test   %rdx,%rdx
jle    1bf6 <asn1_parse2+0x9f6>
mov    %r9d,%r15d
mov    %rdi,0x10(%rsp)
mov    0x30(%rsp),%rax
lea    (%rax,%r14,1),%r9
mov    %ecx,0x50(%rsp)
movslq %ecx,%r12
test   %r15d,%r15d
mov    %r8d,%eax
cmove  %r15d,%eax
mov    %eax,0x6c(%rsp)
mov    %r8,0x80(%rsp)
lea    0x1(%r8),%eax
mov    %eax,0x54(%rsp)
movslq 0xc0(%rsp),%rax
mov    %rax,0x70(%rsp)
lea    0x20(%rsp),%rdi
lea    0x18(%rsp),%rsi
lea    0x3c(%rsp),%rdx
lea    0x38(%rsp),%rcx
mov    %r15d,0x68(%rsp)
mov    %r9,0x40(%rsp)
mov    %r12,0x78(%rsp)
mov    %r14,%r8
call   10c0 <ASN1_get_object@plt>
mov    %eax,%r15d
test   $0x80,%r15b
jne    1c00 <asn1_parse2+0xa00>
mov    0x20(%rsp),%ebx
mov    0x30(%rsp),%rbp
lea    (%r12,%rbp,1),%rdx
mov    0x58(%rsp),%rax
sub    (%rax),%rdx
xor    %r13d,%r13d
mov    0x10(%rsp),%rdi
lea    0xd32(%rip),%rsi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1bfc <asn1_parse2+0x9fc>
mov    %r14,0x48(%rsp)
sub    %ebp,%ebx
movslq %ebx,%r14
mov    0x2c5a(%rip),%rax
mov    (%rax),%eax
or     $0x1,%eax
cmp    %eax,%r15d
jne    1350 <asn1_parse2+0x150>
xor    %r13d,%r13d
mov    0x10(%rsp),%rbx
mov    %rbx,%rdi
lea    0xd11(%rip),%rsi
mov    0x80(%rsp),%rdx
mov    %r14,%rcx
xor    %eax,%eax
call   1060 <BIO_printf@plt>
jmp    1379 <asn1_parse2+0x179>
cs nopw 0x0(%rax,%rax,1)
mov    0x18(%rsp),%r8
xor    %r13d,%r13d
mov    0x10(%rsp),%rbx
mov    %rbx,%rdi
lea    0xcc6(%rip),%rsi
mov    0x80(%rsp),%rdx
mov    %r14,%rcx
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1bfc <asn1_parse2+0x9fc>
mov    0x3c(%rsp),%esi
mov    0x38(%rsp),%edx
mov    %rbx,%rdi
mov    %r15d,%ecx
mov    0x6c(%rsp),%r8d
call   1100 <asn1_print_info@plt>
xor    %r13d,%r13d
test   %eax,%eax
je     1bfc <asn1_parse2+0x9fc>
sub    %r14,0x48(%rsp)
mov    0x2bbf(%rip),%rax
test   %r15d,(%rax)
je     14e0 <asn1_parse2+0x2e0>
mov    0x20(%rsp),%r12
add    0x18(%rsp),%r12
mov    0x10(%rsp),%r13
mov    %r13,%rdi
lea    0xc3f(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    0x18(%rsp),%rax
mov    0x48(%rsp),%r14
cmp    %r14,%rax
jg     1c54 <asn1_parse2+0xa54>
cmp    $0x21,%r15d
mov    0x68(%rsp),%r15d
mov    0x50(%rsp),%ebp
mov    0xc0(%rsp),%ebx
jne    14bf <asn1_parse2+0x2bf>
test   %rax,%rax
jne    14bf <asn1_parse2+0x2bf>
mov    0x20(%rsp),%rcx
mov    0x40(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
mov    %r9,%rdx
sub    %rcx,%rdx
mov    0x58(%rsp),%rax
sub    (%rax),%ecx
add    %ebp,%ecx
mov    %ebx,(%rsp)
mov    %r13,%rdi
lea    0x20(%rsp),%rsi
mov    0x54(%rsp),%r8d
mov    %r15d,%r9d
call   1070 <asn1_parse2@plt>
mov    %eax,%r13d
test   %eax,%eax
je     1bfc <asn1_parse2+0x9fc>
cmp    $0x2,%r13d
je     160d <asn1_parse2+0x40d>
mov    0x20(%rsp),%rcx
mov    0x40(%rsp),%r9
cmp    %r9,%rcx
mov    0x50(%rsp),%ebp
mov    0xc0(%rsp),%ebx
mov    0x10(%rsp),%r13
jb     1430 <asn1_parse2+0x230>
jmp    1617 <asn1_parse2+0x417>
mov    %r12,%rdx
sub    %rcx,%rdx
mov    0x58(%rsp),%rax
sub    (%rax),%ecx
add    %ebp,%ecx
mov    %ebx,(%rsp)
mov    %r13,%rdi
lea    0x20(%rsp),%rsi
mov    0x54(%rsp),%r8d
mov    %r15d,%r9d
call   1070 <asn1_parse2@plt>
test   %eax,%eax
je     1c16 <asn1_parse2+0xa16>
mov    0x20(%rsp),%rcx
cmp    %r12,%rcx
jb     1490 <asn1_parse2+0x290>
xor    %ebx,%ebx
mov    0x40(%rsp),%r9
jmp    1624 <asn1_parse2+0x424>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x0,0x38(%rsp)
je     151f <asn1_parse2+0x31f>
mov    0x18(%rsp),%rax
add    %rax,0x20(%rsp)
mov    0x10(%rsp),%rdi
lea    0xb15(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
mov    $0x0,%ebx
jle    1c16 <asn1_parse2+0xa16>
mov    0x20(%rsp),%rcx
jmp    1b4b <asn1_parse2+0x94b>
mov    0x3c(%rsp),%eax
mov    0x2a56(%rip),%rcx
cmp    (%rcx),%eax
mov    $0x0,%ebx
je     162e <asn1_parse2+0x42e>
mov    0x2a5a(%rip),%rcx
cmp    (%rcx),%eax
je     162e <asn1_parse2+0x42e>
mov    0x2a3b(%rip),%rcx
cmp    (%rcx),%eax
je     162e <asn1_parse2+0x42e>
mov    0x2a74(%rip),%rcx
cmp    (%rcx),%eax
je     162e <asn1_parse2+0x42e>
mov    0x2a7d(%rip),%rcx
cmp    (%rcx),%eax
je     162e <asn1_parse2+0x42e>
mov    0x2a46(%rip),%rcx
cmp    (%rcx),%eax
je     162e <asn1_parse2+0x42e>
mov    0x29d7(%rip),%rcx
cmp    (%rcx),%eax
je     162e <asn1_parse2+0x42e>
mov    0x2a20(%rip),%rcx
cmp    (%rcx),%eax
je     162e <asn1_parse2+0x42e>
mov    0x2a21(%rip),%rcx
cmp    (%rcx),%eax
jne    167e <asn1_parse2+0x47e>
mov    0x30(%rsp),%rax
mov    %rax,0x28(%rsp)
add    0x18(%rsp),%r14
lea    0x60(%rsp),%rdi
lea    0x28(%rsp),%rsi
mov    %r14,%rdx
call   1080 <d2i_ASN1_OBJECT@plt>
test   %rax,%rax
je     17f5 <asn1_parse2+0x5f5>
mov    0x10(%rsp),%rbp
mov    %rbp,%rdi
lea    0xab4(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    0x60(%rsp),%rsi
mov    %rbp,%rdi
call   1030 <i2a_ASN1_OBJECT@plt>
jmp    1afa <asn1_parse2+0x8fa>
mov    0x20(%rsp),%rcx
mov    0x40(%rsp),%r9
mov    %rcx,%rax
sub    %r12,%rax
mov    %rax,0x18(%rsp)
xor    %ebx,%ebx
mov    0x78(%rsp),%r12
jmp    1b55 <asn1_parse2+0x955>
mov    0x10(%rsp),%rbp
mov    %rbp,%rdi
lea    0xa5f(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    0x18(%rsp),%rdx
test   %rdx,%rdx
jle    1afa <asn1_parse2+0x8fa>
mov    0x20(%rsp),%rsi
mov    %rbp,%rdi
call   1120 <BIO_write@plt>
movslq 0x18(%rsp),%rcx
cmp    %rcx,%rax
je     1afa <asn1_parse2+0x8fa>
jmp    1c16 <asn1_parse2+0xa16>
mov    0x290b(%rip),%rcx
cmp    (%rcx),%eax
jne    16e9 <asn1_parse2+0x4e9>
mov    0x30(%rsp),%rax
mov    %rax,0x28(%rsp)
add    0x18(%rsp),%r14
xor    %edi,%edi
lea    0x28(%rsp),%rsi
mov    %r14,%rdx
call   10f0 <d2i_ASN1_BOOLEAN@plt>
mov    %eax,%r14d
test   %eax,%eax
mov    0x10(%rsp),%rbp
jns    16d0 <asn1_parse2+0x4d0>
mov    %rbp,%rdi
lea    0x9c4(%rip),%rsi
mov    $0xc,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    %rbp,%rdi
lea    0x9b4(%rip),%rsi
mov    %r14d,%edx
xor    %eax,%eax
call   1060 <BIO_printf@plt>
jmp    1afa <asn1_parse2+0x8fa>
mov    0x2868(%rip),%rcx
cmp    (%rcx),%eax
mov    0x10(%rsp),%rbp
je     1afa <asn1_parse2+0x8fa>
mov    0x2864(%rip),%rcx
cmp    (%rcx),%eax
jne    181c <asn1_parse2+0x61c>
mov    0x30(%rsp),%rax
mov    %rax,0x28(%rsp)
add    0x18(%rsp),%r14
xor    %edi,%edi
lea    0x28(%rsp),%rsi
mov    %r14,%rdx
call   1040 <d2i_ASN1_OCTET_STRING@plt>
mov    %rax,%r14
test   %rax,%rax
je     1aa0 <asn1_parse2+0x8a0>
mov    (%r14),%eax
test   %eax,%eax
jle    1aa0 <asn1_parse2+0x8a0>
mov    0x8(%r14),%rcx
mov    %rcx,0x28(%rsp)
xor    %edx,%edx
mov    $0x2600,%edi
jmp    1765 <asn1_parse2+0x565>
cmp    $0x7e,%bl
ja     177c <asn1_parse2+0x57c>
add    $0x1,%rdx
cmp    %rdx,%rax
je     1a65 <asn1_parse2+0x865>
movzbl (%rcx,%rdx,1),%ebx
cmp    $0x1f,%bl
ja     1753 <asn1_parse2+0x553>
cmp    $0xd,%bl
ja     177c <asn1_parse2+0x57c>
movzbl %bl,%esi
bt     %rsi,%rdi
jb     1758 <asn1_parse2+0x558>
cmpl   $0x0,0xc0(%rsp)
je     1b92 <asn1_parse2+0x992>
mov    0x10(%rsp),%rbx
mov    %rbx,%rdi
lea    0x879(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c74 <asn1_parse2+0xa74>
movslq (%r14),%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    %rbx,%rdi
mov    $0x6,%ecx
call   10d0 <BIO_dump_indent@plt>
test   %rax,%rax
mov    $0x0,%ebx
jle    1c74 <asn1_parse2+0xa74>
mov    %r14,%rdi
call   1050 <ASN1_OCTET_STRING_free@plt>
jmp    1b17 <asn1_parse2+0x917>
mov    0x10(%rsp),%rbp
mov    %rbp,%rdi
lea    0x871(%rip),%rsi
mov    $0xb,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jg     1afa <asn1_parse2+0x8fa>
jmp    1c16 <asn1_parse2+0xa16>
mov    0x278d(%rip),%rcx
cmp    (%rcx),%eax
jne    190a <asn1_parse2+0x70a>
mov    0x30(%rsp),%rax
mov    %rax,0x28(%rsp)
add    0x18(%rsp),%r14
xor    %edi,%edi
lea    0x28(%rsp),%rsi
mov    %r14,%rdx
call   10b0 <d2i_ASN1_INTEGER@plt>
mov    %rax,%rbp
test   %rax,%rax
mov    0x10(%rsp),%r14
mov    %r14,%rdi
je     1ab1 <asn1_parse2+0x8b1>
lea    0x838(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    0x0(%rbp),%rax
mov    0x26f6(%rip),%rcx
cmp    (%rcx),%rax
jne    18a4 <asn1_parse2+0x6a4>
mov    %r14,%rdi
lea    0x812(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    0x8(%rbp),%eax
test   %eax,%eax
jle    18e9 <asn1_parse2+0x6e9>
xor    %ebx,%ebx
lea    0x7ea(%rip),%r14
mov    0x10(%rbp),%rax
movzbl (%rax,%rbx,1),%edx
xor    %r13d,%r13d
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1bfc <asn1_parse2+0x9fc>
add    $0x1,%rbx
movslq 0x8(%rbp),%rax
cmp    %rax,%rbx
jl     18b4 <asn1_parse2+0x6b4>
mov    0x10(%rsp),%r14
test   %eax,%eax
mov    $0x0,%ebx
jne    1acb <asn1_parse2+0x8cb>
mov    %r14,%rdi
lea    0x7a5(%rip),%rsi
mov    $0x2,%edx
jmp    1abd <asn1_parse2+0x8bd>
mov    0x268f(%rip),%rcx
cmp    (%rcx),%eax
jne    19f5 <asn1_parse2+0x7f5>
mov    0x30(%rsp),%rax
mov    %rax,0x28(%rsp)
add    0x18(%rsp),%r14
xor    %edi,%edi
lea    0x28(%rsp),%rsi
mov    %r14,%rdx
call   1090 <d2i_ASN1_ENUMERATED@plt>
mov    %rax,%rbp
test   %rax,%rax
mov    0x10(%rsp),%r14
mov    %r14,%rdi
je     1ad5 <asn1_parse2+0x8d5>
lea    0x74a(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    0x0(%rbp),%rax
mov    0x2668(%rip),%rcx
cmp    (%rcx),%rax
jne    1992 <asn1_parse2+0x792>
mov    %r14,%rdi
lea    0x724(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    0x8(%rbp),%eax
test   %eax,%eax
jle    19d9 <asn1_parse2+0x7d9>
xor    %ebx,%ebx
lea    0x6fc(%rip),%r14
mov    0x10(%rbp),%rax
movzbl (%rax,%rbx,1),%edx
xor    %r13d,%r13d
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1bfc <asn1_parse2+0x9fc>
add    $0x1,%rbx
movslq 0x8(%rbp),%rax
cmp    %rax,%rbx
jl     19a2 <asn1_parse2+0x7a2>
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
test   %eax,%eax
jne    1aef <asn1_parse2+0x8ef>
mov    %r14,%rdi
lea    0x6ba(%rip),%rsi
mov    $0x2,%edx
jmp    1ae1 <asn1_parse2+0x8e1>
cmpl   $0x0,0xc0(%rsp)
mov    0x10(%rsp),%rbp
je     1afa <asn1_parse2+0x8fa>
cmpq   $0x0,0x18(%rsp)
jle    1afa <asn1_parse2+0x8fa>
mov    %rbp,%rdi
lea    0x5f4(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    0x18(%rsp),%rax
mov    0x70(%rsp),%rdx
cmp    %rdx,%rax
cmovl  %rax,%rdx
cmpl   $0xffffffff,0xc0(%rsp)
ff
mov    0x20(%rsp),%rsi
cmove  %rax,%rdx
mov    %rbp,%rdi
mov    $0x6,%ecx
call   10d0 <BIO_dump_indent@plt>
jmp    1b0e <asn1_parse2+0x90e>
mov    0x10(%rsp),%rbx
mov    %rbx,%rdi
lea    0x628(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c74 <asn1_parse2+0xa74>
mov    0x28(%rsp),%rsi
mov    (%r14),%edx
mov    %rbx,%rdi
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c74 <asn1_parse2+0xa74>
mov    %r14,%rdi
call   1050 <ASN1_OCTET_STRING_free@plt>
xor    %ebx,%ebx
mov    0x10(%rsp),%rbp
jmp    1afa <asn1_parse2+0x8fa>
lea    0x5f0(%rip),%rsi
mov    $0xb,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    %rbp,%rdi
call   1110 <ASN1_INTEGER_free@plt>
jmp    1af7 <asn1_parse2+0x8f7>
lea    0x5d8(%rip),%rsi
mov    $0xe,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    %rbp,%rdi
call   10a0 <ASN1_ENUMERATED_free@plt>
mov    %r14,%rbp
mov    %rbp,%rdi
lea    0x50e(%rip),%rsi
mov    $0x1,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c16 <asn1_parse2+0xa16>
mov    0x20(%rsp),%rcx
add    0x18(%rsp),%rcx
mov    %rcx,0x20(%rsp)
mov    0x3c(%rsp),%eax
mov    0x24c7(%rip),%rdx
cmp    (%rdx),%eax
jne    1b4b <asn1_parse2+0x94b>
cmpl   $0x0,0x38(%rsp)
mov    0x48(%rsp),%r14
mov    0x40(%rsp),%r9
jne    1b55 <asn1_parse2+0x955>
jmp    1c6c <asn1_parse2+0xa6c>
mov    0x48(%rsp),%r14
mov    0x40(%rsp),%r9
mov    $0x1,%r13d
cmp    %r9,%rcx
jae    1c1b <asn1_parse2+0xa1b>
sub    0x18(%rsp),%r14
cmp    %rcx,0x30(%rsp)
mov    %rcx,0x30(%rsp)
lea    0x20(%rsp),%rdi
lea    0x18(%rsp),%rsi
lea    0x3c(%rsp),%rdx
lea    0x38(%rsp),%rcx
jb     12bc <asn1_parse2+0xbc>
jmp    1c1b <asn1_parse2+0xa1b>
mov    0x10(%rsp),%rdi
lea    0x4f4(%rip),%rsi
mov    $0xb,%edx
call   1120 <BIO_write@plt>
test   %rax,%rax
jle    1c74 <asn1_parse2+0xa74>
cmpl   $0x0,(%r14)
jle    1aa0 <asn1_parse2+0x8a0>
xor    %ebx,%ebx
mov    0x28(%rsp),%rax
movzbl (%rax,%rbx,1),%edx
xor    %r13d,%r13d
mov    0x10(%rsp),%rdi
lea    0x4c9(%rip),%rsi
xor    %eax,%eax
call   1060 <BIO_printf@plt>
test   %rax,%rax
jle    1c74 <asn1_parse2+0xa74>
add    $0x1,%rbx
movslq (%r14),%rax
cmp    %rax,%rbx
jl     1bbd <asn1_parse2+0x9bd>
jmp    1aa0 <asn1_parse2+0x8a0>
mov    $0x1,%r13d
xor    %ebx,%ebx
jmp    1c1b <asn1_parse2+0xa1b>
lea    0x40d(%rip),%rsi
mov    0x10(%rsp),%rdi
mov    $0x12,%edx
call   1120 <BIO_write@plt>
xor    %ebx,%ebx
xor    %r13d,%r13d
mov    0x60(%rsp),%rdi
test   %rdi,%rdi
je     1c2a <asn1_parse2+0xa2a>
call   10e0 <ASN1_OBJECT_free@plt>
mov    %rbx,%rdi
call   1050 <ASN1_OCTET_STRING_free@plt>
mov    0x20(%rsp),%rax
mov    0x58(%rsp),%rcx
mov    %rax,(%rcx)
mov    %r13d,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x3fe(%rip),%rsi
xor    %ebx,%ebx
mov    %r13,%rdi
mov    %r14,%rdx
xor    %eax,%eax
call   1060 <BIO_printf@plt>
jmp    1c18 <asn1_parse2+0xa18>
mov    $0x2,%r13d
jmp    1c1b <asn1_parse2+0xa1b>
mov    %r14,%rbx
jmp    1c1b <asn1_parse2+0xa1b>

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

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