#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_4__ TYPE_1__;

/* Type definitions */
struct TYPE_4__ {
  int type;
  int length;
  int *data;
};
typedef TYPE_1__ ASN1_INTEGER;

/* Variables and functions */
int /*<<< orphan*/ ASN1_INTEGER_valid(TYPE_1__ *);
int V_ASN1_NEG;
int /*<<< orphan*/ memcpy(unsigned char *, int *, int);
int i2c_ASN1_INTEGER(ASN1_INTEGER *a, unsigned char **pp) {
  int pad = 0, ret, i, neg;
  unsigned char *p, *n, pb = 0;
  if (!ASN1_INTEGER_valid(a))
    return 0;
  neg = a->type & V_ASN1_NEG;
  if (a->length == 0)
    ret = 1;
  else {
    ret = a->length;
    i = a->data[0];
    if (!neg && (i > 127)) {
      pad = 1;
      pb = 0;
    } else if (neg) {
      if (i > 128) {
        pad = 1;
        pb = 0xFF;
      } else if (i == 128) {
        for (i = 1; i < a->length; i++)
          if (a->data[i]) {
            pad = 1;
            pb = 0xFF;
            break;
          }
      }
    }
    ret += pad;
  }
  if (pp == NULL)
    return (ret);
  p = *pp;
  if (pad)
    *(p++) = pb;
  if (a->length == 0)
    *(p++) = 0;
  else if (!neg)
    memcpy(p, a->data, a->length);
  else {
    n = a->data + a->length - 1;
    p += a->length - 1;
    i = a->length;
    while (!*n) {
      *(p--) = 0;
      n--;
      i--;
    }
    *(p--) = ((*(n--)) ^ 0xff) + 1;
    i--;
    for (; i > 0; i--)
      *(p--) = *(n--) ^ 0xff;
  }
  *pp += ret;
  return (ret);
}


x86 assembly (clang, -O0):
<i2c_ASN1_INTEGER>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movb   $0x0,-0x39(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <ASN1_INTEGER_valid@plt>
cmp    $0x0,%eax
jne    1159 <i2c_ASN1_INTEGER+0x39>
movl   $0x0,-0x4(%rbp)
jmp    140d <i2c_ASN1_INTEGER+0x2ed>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    0x2e82(%rip),%rcx
and    (%rcx),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jne    1185 <i2c_ASN1_INTEGER+0x65>
movl   $0x1,-0x20(%rbp)
jmp    1261 <i2c_ASN1_INTEGER+0x141>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    (%rax),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x28(%rbp)
jne    11c0 <i2c_ASN1_INTEGER+0xa0>
cmpl   $0x7f,-0x24(%rbp)
jle    11c0 <i2c_ASN1_INTEGER+0xa0>
movl   $0x1,-0x1c(%rbp)
movb   $0x0,-0x39(%rbp)
jmp    1258 <i2c_ASN1_INTEGER+0x138>
cmpl   $0x0,-0x28(%rbp)
je     1253 <i2c_ASN1_INTEGER+0x133>
cmpl   $0x80,-0x24(%rbp)
jle    11e7 <i2c_ASN1_INTEGER+0xc7>
movl   $0x1,-0x1c(%rbp)
movb   $0xff,-0x39(%rbp)
jmp    124e <i2c_ASN1_INTEGER+0x12e>
cmpl   $0x80,-0x24(%rbp)
jne    1249 <i2c_ASN1_INTEGER+0x129>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    1244 <i2c_ASN1_INTEGER+0x124>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x24(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1231 <i2c_ASN1_INTEGER+0x111>
movl   $0x1,-0x1c(%rbp)
movb   $0xff,-0x39(%rbp)
jmp    1244 <i2c_ASN1_INTEGER+0x124>
jmp    1236 <i2c_ASN1_INTEGER+0x116>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11fb <i2c_ASN1_INTEGER+0xdb>
jmp    1249 <i2c_ASN1_INTEGER+0x129>
jmp    124e <i2c_ASN1_INTEGER+0x12e>
jmp    1253 <i2c_ASN1_INTEGER+0x133>
jmp    1258 <i2c_ASN1_INTEGER+0x138>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1277 <i2c_ASN1_INTEGER+0x157>
mov    -0x20(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    140d <i2c_ASN1_INTEGER+0x2ed>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     12a0 <i2c_ASN1_INTEGER+0x180>
mov    -0x39(%rbp),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
cmpl   $0x0,0x4(%rax)
jne    12c5 <i2c_ASN1_INTEGER+0x1a5>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movb   $0x0,(%rax)
jmp    13f4 <i2c_ASN1_INTEGER+0x2d4>
cmpl   $0x0,-0x28(%rbp)
jne    12ec <i2c_ASN1_INTEGER+0x1cc>
mov    -0x30(%rbp),%rdi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%edx
call   1040 <memcpy@plt>
jmp    13ef <i2c_ASN1_INTEGER+0x2cf>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    -0x10(%rbp),%rcx
movslq 0x4(%rcx),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x38(%rbp),%rax
cmpb   $0x0,(%rax)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1346 <i2c_ASN1_INTEGER+0x226>
jmp    1372 <i2c_ASN1_INTEGER+0x252>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x30(%rbp)
movb   $0x0,(%rax)
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    132d <i2c_ASN1_INTEGER+0x20d>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
xor    $0xff,%eax
add    $0x1,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    13ea <i2c_ASN1_INTEGER+0x2ca>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
xor    $0xff,%eax
mov    %al,%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    13a8 <i2c_ASN1_INTEGER+0x288>
jmp    13ef <i2c_ASN1_INTEGER+0x2cf>
jmp    13f4 <i2c_ASN1_INTEGER+0x2d4>
mov    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x20(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<i2c_ASN1_INTEGER>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rsi,%r14
mov    %rdi,%rbx
call   1030 <ASN1_INTEGER_valid@plt>
test   %eax,%eax
je     1172 <i2c_ASN1_INTEGER+0x52>
mov    0x4(%rbx),%edx
test   %rdx,%rdx
je     1177 <i2c_ASN1_INTEGER+0x57>
mov    0x2ea2(%rip),%rax
mov    (%rax),%ebp
and    (%rbx),%ebp
mov    0x8(%rbx),%rsi
mov    (%rsi),%edi
sete   %cl
cmp    $0x7f,%edi
setg   %al
test   %ebp,%ebp
je     118b <i2c_ASN1_INTEGER+0x6b>
cmp    $0x80,%edi
jle    11f0 <i2c_ASN1_INTEGER+0xd0>
mov    $0x1,%ecx
mov    $0xff,%al
jmp    1192 <i2c_ASN1_INTEGER+0x72>
xor    %r15d,%r15d
jmp    11e4 <i2c_ASN1_INTEGER+0xc4>
test   %r14,%r14
je     122c <i2c_ASN1_INTEGER+0x10c>
mov    (%r14),%rdi
mov    $0x1,%r15d
jmp    11db <i2c_ASN1_INTEGER+0xbb>
and    %al,%cl
xor    %eax,%eax
movzbl %cl,%ecx
lea    (%rcx,%rdx,1),%r15d
test   %r14,%r14
je     11e4 <i2c_ASN1_INTEGER+0xc4>
mov    (%r14),%rdi
test   %ecx,%ecx
je     11ab <i2c_ASN1_INTEGER+0x8b>
mov    %al,(%rdi)
add    $0x1,%rdi
mov    0x4(%rbx),%edx
test   %edx,%edx
je     11db <i2c_ASN1_INTEGER+0xbb>
mov    0x8(%rbx),%rsi
test   %ebp,%ebp
je     1234 <i2c_ASN1_INTEGER+0x114>
movslq %edx,%rcx
lea    (%rcx,%rdi,1),%rax
add    $0xffffffffffffffff,%rax
mov    -0x4(%rsi,%rcx,4),%bl
test   %bl,%bl
je     123b <i2c_ASN1_INTEGER+0x11b>
lea    (%rsi,%rcx,4),%rcx
add    $0xfffffffffffffffc,%rcx
jmp    1269 <i2c_ASN1_INTEGER+0x149>
movb   $0x0,(%rdi)
movslq %r15d,%rax
add    %rax,(%r14)
mov    %r15d,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
cmp    $0x80,%edi
jne    12cc <i2c_ASN1_INTEGER+0x1ac>
mov    $0x0,%eax
cmp    $0x2,%edx
jl     1192 <i2c_ASN1_INTEGER+0x72>
mov    $0x1,%ecx
nopl   (%rax)
cmpl   $0x0,(%rsi,%rcx,4)
jne    1169 <i2c_ASN1_INTEGER+0x49>
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1210 <i2c_ASN1_INTEGER+0xf0>
xor    %ecx,%ecx
xor    %eax,%eax
jmp    1192 <i2c_ASN1_INTEGER+0x72>
mov    $0x1,%r15d
jmp    11e4 <i2c_ASN1_INTEGER+0xc4>
call   1040 <memcpy@plt>
jmp    11de <i2c_ASN1_INTEGER+0xbe>
lea    (%rsi,%rcx,4),%rcx
add    $0xfffffffffffffffb,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movb   $0x0,(%rax)
add    $0xffffffffffffffff,%rax
add    $0xffffffff,%edx
movzbl (%rcx),%ebx
add    $0xffffffffffffffff,%rcx
test   %bl,%bl
je     1250 <i2c_ASN1_INTEGER+0x130>
add    $0x1,%rcx
neg    %bl
mov    %bl,(%rax)
cmp    $0x2,%edx
jl     11de <i2c_ASN1_INTEGER+0xbe>
xor    %ebp,%ebp
mov    %edx,%esi
sub    $0x2,%esi
cmovb  %ebp,%esi
cmp    $0x3,%esi
jb     12a1 <i2c_ASN1_INTEGER+0x181>
mov    %edx,%edi
sub    $0x2,%edi
cmovb  %ebp,%edi
not    %rdi
lea    (%rax,%rdi,1),%rbp
cmp    %rcx,%rbp
jae    12d3 <i2c_ASN1_INTEGER+0x1b3>
add    %rcx,%rdi
cmp    %rax,%rdi
jae    12d3 <i2c_ASN1_INTEGER+0x1b3>
mov    %rcx,%rsi
mov    %rax,%rbx
add    $0x1,%edx
xor    %eax,%eax
nopl   0x0(%rax)
movzbl -0x1(%rsi,%rax,1),%ecx
not    %cl
mov    %cl,-0x1(%rbx,%rax,1)
add    $0xffffffffffffffff,%rax
lea    (%rdx,%rax,1),%ecx
cmp    $0x2,%ecx
ja     12b0 <i2c_ASN1_INTEGER+0x190>
jmp    11de <i2c_ASN1_INTEGER+0xbe>
xor    %eax,%eax
jmp    1192 <i2c_ASN1_INTEGER+0x72>
lea    0x1(%rsi),%r10
movabs $0x1fffffff0,%r9
xor    %r8d,%r8d
cmp    $0xf,%esi
jae    12f0 <i2c_ASN1_INTEGER+0x1d0>
xor    %edi,%edi
jmp    13b7 <i2c_ASN1_INTEGER+0x297>
mov    %r10,%rdi
and    %r9,%rdi
lea    -0x10(%rdi),%rbx
mov    %rbx,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %esi,%r11d
and    $0x3,%r11d
cmp    $0x30,%rbx
jae    1316 <i2c_ASN1_INTEGER+0x1f6>
xor    %ebx,%ebx
jmp    136d <i2c_ASN1_INTEGER+0x24d>
and    $0xfffffffffffffffc,%rsi
xor    %ebx,%ebx
pcmpeqd %xmm0,%xmm0
movdqu -0x10(%rcx,%rbx,1),%xmm1
pxor   %xmm0,%xmm1
movdqu %xmm1,-0x10(%rax,%rbx,1)
movdqu -0x20(%rcx,%rbx,1),%xmm1
pxor   %xmm0,%xmm1
movdqu %xmm1,-0x20(%rax,%rbx,1)
movdqu -0x30(%rcx,%rbx,1),%xmm1
pxor   %xmm0,%xmm1
movdqu %xmm1,-0x30(%rax,%rbx,1)
movdqu -0x40(%rcx,%rbx,1),%xmm1
pxor   %xmm0,%xmm1
movdqu %xmm1,-0x40(%rax,%rbx,1)
add    $0xffffffffffffffc0,%rbx
add    $0xfffffffffffffffc,%rsi
jne    1320 <i2c_ASN1_INTEGER+0x200>
neg    %rbx
test   %r11,%r11
je     13a8 <i2c_ASN1_INTEGER+0x288>
mov    $0xfffffffffffffff0,%rsi
sub    %rbx,%rsi
lea    (%rax,%rsi,1),%r12
add    %rcx,%rsi
shl    $0x4,%r11
xor    %ebp,%ebp
pcmpeqd %xmm0,%xmm0
movdqu (%rsi,%rbp,1),%xmm1
pxor   %xmm0,%xmm1
movdqu %xmm1,(%r12,%rbp,1)
add    $0xfffffffffffffff0,%rbp
mov    %r11,%rbx
add    %rbp,%rbx
jne    138d <i2c_ASN1_INTEGER+0x26d>
cmp    %rdi,%r10
je     11de <i2c_ASN1_INTEGER+0xbe>
test   $0xc,%r10b
je     1411 <i2c_ASN1_INTEGER+0x2f1>
mov    %edx,%r11d
sub    $0x2,%r11d
cmovb  %r8d,%r11d
add    $0x1,%r11
add    $0xc,%r9
and    %r11,%r9
mov    %rcx,%rsi
sub    %r9,%rsi
mov    %rax,%rbx
sub    %r9,%rbx
sub    %r9d,%edx
neg    %rdi
and    $0xfffffffffffffffc,%r10
neg    %r10
cs nopw 0x0(%rax,%rax,1)
mov    -0x4(%rcx,%rdi,1),%ebp
not    %ebp
mov    %ebp,-0x4(%rax,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%r10
jne    13f0 <i2c_ASN1_INTEGER+0x2d0>
cmp    %r9,%r11
je     11de <i2c_ASN1_INTEGER+0xbe>
jmp    12a7 <i2c_ASN1_INTEGER+0x187>
sub    %edi,%edx
sub    %rdi,%rax
sub    %rdi,%rcx
jmp    12a1 <i2c_ASN1_INTEGER+0x181>

LLVM IR (-O0):
%struct.TYPE_4__ = type { i32, i32, i32* }
@V_ASN1_NEG = global i32 0
define i32 @i2c_ASN1_INTEGER(%struct.TYPE_4__* %0, i8** %1) {
%3 = alloca i32
%4 = alloca %struct.TYPE_4__*
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i8*
%12 = alloca i8
store %struct.TYPE_4__* %0, %struct.TYPE_4__** %4
store i8** %1, i8*** %5
store i32 0, i32* %6
store i8 0, i8* %12
%13 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%14 = call i32 @ASN1_INTEGER_valid(%struct.TYPE_4__* %13)
%15 = icmp ne i32 %14, 0
br i1 %15, label %17, label %16
16: ; preds = %2
store i32 0, i32* %3
br label %185
17: ; preds = %2
%18 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%19 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %18, i32 0, i32 0
%20 = load i32, i32* %19
%21 = load i32, i32* @V_ASN1_NEG
%22 = and i32 %20, %21
store i32 %22, i32* %9
%23 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%24 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %23, i32 0, i32 1
%25 = load i32, i32* %24
%26 = icmp eq i32 %25, 0
br i1 %26, label %27, label %28
27: ; preds = %17
store i32 1, i32* %7
br label %82
28: ; preds = %17
%29 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%30 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %29, i32 0, i32 1
%31 = load i32, i32* %30
store i32 %31, i32* %7
%32 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%33 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %32, i32 0, i32 2
%34 = load i32*, i32** %33
%35 = getelementptr inbounds i32, i32* %34, i64 0
%36 = load i32, i32* %35
store i32 %36, i32* %8
%37 = load i32, i32* %9
%38 = icmp ne i32 %37, 0
br i1 %38, label %43, label %39
39: ; preds = %28
%40 = load i32, i32* %8
%41 = icmp sgt i32 %40, 127
br i1 %41, label %42, label %43
42: ; preds = %39
store i32 1, i32* %6
store i8 0, i8* %12
br label %78
43: ; preds = %39, %28
%44 = load i32, i32* %9
%45 = icmp ne i32 %44, 0
br i1 %45, label %46, label %77
46: ; preds = %43
%47 = load i32, i32* %8
%48 = icmp sgt i32 %47, 128
br i1 %48, label %49, label %50
49: ; preds = %46
store i32 1, i32* %6
store i8 -1, i8* %12
br label %76
50: ; preds = %46
%51 = load i32, i32* %8
%52 = icmp eq i32 %51, 128
br i1 %52, label %53, label %75
53: ; preds = %50
store i32 1, i32* %8
br label %54
54: ; preds = %71, %53
%55 = load i32, i32* %8
%56 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%57 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %56, i32 0, i32 1
%58 = load i32, i32* %57
%59 = icmp slt i32 %55, %58
br i1 %59, label %60, label %74
60: ; preds = %54
%61 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%62 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %61, i32 0, i32 2
%63 = load i32*, i32** %62
%64 = load i32, i32* %8
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i32, i32* %63, i64 %65
%67 = load i32, i32* %66
%68 = icmp ne i32 %67, 0
br i1 %68, label %69, label %70
69: ; preds = %60
store i32 1, i32* %6
store i8 -1, i8* %12
br label %74
70: ; preds = %60
br label %71
71: ; preds = %70
%72 = load i32, i32* %8
%73 = add nsw i32 %72, 1
store i32 %73, i32* %8
br label %54
74: ; preds = %69, %54
br label %75
75: ; preds = %74, %50
br label %76
76: ; preds = %75, %49
br label %77
77: ; preds = %76, %43
br label %78
78: ; preds = %77, %42
%79 = load i32, i32* %6
%80 = load i32, i32* %7
%81 = add nsw i32 %80, %79
store i32 %81, i32* %7
br label %82
82: ; preds = %78, %27
%83 = load i8**, i8*** %5
%84 = icmp eq i8** %83, null
br i1 %84, label %85, label %87
85: ; preds = %82
%86 = load i32, i32* %7
store i32 %86, i32* %3
br label %185
87: ; preds = %82
%88 = load i8**, i8*** %5
%89 = load i8*, i8** %88
store i8* %89, i8** %10
%90 = load i32, i32* %6
%91 = icmp ne i32 %90, 0
br i1 %91, label %92, label %96
92: ; preds = %87
%93 = load i8, i8* %12
%94 = load i8*, i8** %10
%95 = getelementptr inbounds i8, i8* %94, i32 1
store i8* %95, i8** %10
store i8 %93, i8* %94
br label %96
96: ; preds = %92, %87
%97 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%98 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %97, i32 0, i32 1
%99 = load i32, i32* %98
%100 = icmp eq i32 %99, 0
br i1 %100, label %101, label %104
101: ; preds = %96
%102 = load i8*, i8** %10
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %10
store i8 0, i8* %102
br label %178
104: ; preds = %96
%105 = load i32, i32* %9
%106 = icmp ne i32 %105, 0
br i1 %106, label %116, label %107
107: ; preds = %104
%108 = load i8*, i8** %10
%109 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%110 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %109, i32 0, i32 2
%111 = load i32*, i32** %110
%112 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%113 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %112, i32 0, i32 1
%114 = load i32, i32* %113
%115 = call i32 @memcpy(i8* %108, i32* %111, i32 %114)
br label %177
116: ; preds = %104
%117 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%118 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %117, i32 0, i32 2
%119 = load i32*, i32** %118
%120 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%121 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %120, i32 0, i32 1
%122 = load i32, i32* %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i32, i32* %119, i64 %123
%125 = getelementptr inbounds i32, i32* %124, i64 -1
%126 = bitcast i32* %125 to i8*
store i8* %126, i8** %11
%127 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%128 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %127, i32 0, i32 1
%129 = load i32, i32* %128
%130 = sub nsw i32 %129, 1
%131 = load i8*, i8** %10
%132 = sext i32 %130 to i64
%133 = getelementptr inbounds i8, i8* %131, i64 %132
store i8* %133, i8** %10
%134 = load %struct.TYPE_4__*, %struct.TYPE_4__** %4
%135 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %134, i32 0, i32 1
%136 = load i32, i32* %135
store i32 %136, i32* %8
br label %137
137: ; preds = %142, %116
%138 = load i8*, i8** %11
%139 = load i8, i8* %138
%140 = icmp ne i8 %139, 0
%141 = xor i1 %140, true
br i1 %141, label %142, label %149
142: ; preds = %137
%143 = load i8*, i8** %10
%144 = getelementptr inbounds i8, i8* %143, i32 -1
store i8* %144, i8** %10
store i8 0, i8* %143
%145 = load i8*, i8** %11
%146 = getelementptr inbounds i8, i8* %145, i32 -1
store i8* %146, i8** %11
%147 = load i32, i32* %8
%148 = add nsw i32 %147, -1
store i32 %148, i32* %8
br label %137
149: ; preds = %137
%150 = load i8*, i8** %11
%151 = getelementptr inbounds i8, i8* %150, i32 -1
store i8* %151, i8** %11
%152 = load i8, i8* %150
%153 = zext i8 %152 to i32
%154 = xor i32 %153, 255
%155 = add nsw i32 %154, 1
%156 = trunc i32 %155 to i8
%157 = load i8*, i8** %10
%158 = getelementptr inbounds i8, i8* %157, i32 -1
store i8* %158, i8** %10
store i8 %156, i8* %157
%159 = load i32, i32* %8
%160 = add nsw i32 %159, -1
store i32 %160, i32* %8
br label %161
161: ; preds = %173, %149
%162 = load i32, i32* %8
%163 = icmp sgt i32 %162, 0
br i1 %163, label %164, label %176
164: ; preds = %161
%165 = load i8*, i8** %11
%166 = getelementptr inbounds i8, i8* %165, i32 -1
store i8* %166, i8** %11
%167 = load i8, i8* %165
%168 = zext i8 %167 to i32
%169 = xor i32 %168, 255
%170 = trunc i32 %169 to i8
%171 = load i8*, i8** %10
%172 = getelementptr inbounds i8, i8* %171, i32 -1
store i8* %172, i8** %10
store i8 %170, i8* %171
br label %173
173: ; preds = %164
%174 = load i32, i32* %8
%175 = add nsw i32 %174, -1
store i32 %175, i32* %8
br label %161
176: ; preds = %161
br label %177
177: ; preds = %176, %107
br label %178
178: ; preds = %177, %101
%179 = load i32, i32* %7
%180 = load i8**, i8*** %5
%181 = load i8*, i8** %180
%182 = sext i32 %179 to i64
%183 = getelementptr inbounds i8, i8* %181, i64 %182
store i8* %183, i8** %180
%184 = load i32, i32* %7
store i32 %184, i32* %3
br label %185
185: ; preds = %178, %85, %16
%186 = load i32, i32* %3
ret i32 %186
}

LLVM IR (-O2):
%struct.TYPE_4__ = type { i32, i32, i32* }
@V_ASN1_NEG = global i32 0
define i32 @i2c_ASN1_INTEGER(%struct.TYPE_4__* %0, i8** %1) {
%3 = tail call i32 @ASN1_INTEGER_valid(%struct.TYPE_4__* %0)
%4 = icmp eq i32 %3, 0
br i1 %4, label %243, label %5
5: ; preds = %2
%6 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %0, i64 0, i32 0
%7 = load i32, i32* %6
%8 = load i32, i32* @V_ASN1_NEG
%9 = and i32 %8, %7
%10 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %0, i64 0, i32 1
%11 = load i32, i32* %10
%12 = icmp eq i32 %11, 0
br i1 %12, label %42, label %13
13: ; preds = %5
%14 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %0, i64 0, i32 2
%15 = load i32*, i32** %14
%16 = load i32, i32* %15
%17 = icmp eq i32 %9, 0
%18 = icmp sgt i32 %16, 127
%19 = select i1 %17, i1 %18, i1 false
%20 = zext i1 %19 to i32
br i1 %17, label %37, label %21
21: ; preds = %13
%22 = icmp sgt i32 %16, 128
br i1 %22, label %37, label %23
23: ; preds = %21
%24 = icmp eq i32 %16, 128
%25 = icmp sgt i32 %11, 1
%26 = select i1 %24, i1 %25, i1 false
br i1 %26, label %27, label %37
27: ; preds = %23
%28 = zext i32 %11 to i64
br label %31
29: ; preds = %31
%30 = icmp eq i64 %36, %28
br i1 %30, label %37, label %31
31: ; preds = %27, %29
%32 = phi i64 [ 1, %27 ], [ %36, %29 ]
%33 = getelementptr inbounds i32, i32* %15, i64 %32
%34 = load i32, i32* %33
%35 = icmp eq i32 %34, 0
%36 = add nuw nsw i64 %32, 1
br i1 %35, label %29, label %37
37: ; preds = %31, %29, %13, %23, %21
%38 = phi i32 [ 0, %23 ], [ %20, %13 ], [ 1, %21 ], [ 1, %31 ], [ 0, %29 ]
%39 = phi i8 [ 0, %23 ], [ 0, %13 ], [ -1, %21 ], [ -1, %31 ], [ 0, %29 ]
%40 = add nsw i32 %38, %11
%41 = icmp eq i8** %1, null
br i1 %41, label %243, label %46
42: ; preds = %5
%43 = icmp eq i8** %1, null
br i1 %43, label %243, label %44
44: ; preds = %42
%45 = load i8*, i8** %1
br label %56
46: ; preds = %37
%47 = load i8*, i8** %1
%48 = icmp eq i32 %38, 0
br i1 %48, label %52, label %49
49: ; preds = %46
%50 = getelementptr inbounds i8, i8* %47, i64 1
store i8 %39, i8* %47
%51 = load i32, i32* %10
br label %52
52: ; preds = %49, %46
%53 = phi i32 [ %51, %49 ], [ %11, %46 ]
%54 = phi i8* [ %50, %49 ], [ %47, %46 ]
%55 = icmp eq i32 %53, 0
br i1 %55, label %56, label %59
56: ; preds = %44, %52
%57 = phi i8* [ %45, %44 ], [ %54, %52 ]
%58 = phi i32 [ 1, %44 ], [ %40, %52 ]
store i8 0, i8* %57
br label %238
59: ; preds = %52
%60 = icmp eq i32 %9, 0
%61 = getelementptr inbounds %struct.TYPE_4__, %struct.TYPE_4__* %0, i64 0, i32 2
%62 = load i32*, i32** %61
br i1 %60, label %63, label %65
63: ; preds = %59
%64 = tail call i32 @memcpy(i8* %54, i32* %62, i32 %53)
br label %238
65: ; preds = %59
%66 = sext i32 %53 to i64
%67 = getelementptr inbounds i32, i32* %62, i64 %66
%68 = getelementptr inbounds i32, i32* %67, i64 -1
%69 = bitcast i32* %68 to i8*
%70 = add nsw i32 %53, -1
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i8, i8* %54, i64 %71
%73 = load i8, i8* %69
%74 = icmp eq i8 %73, 0
br i1 %74, label %75, label %84
75: ; preds = %65, %75
%76 = phi i8* [ %80, %75 ], [ %69, %65 ]
%77 = phi i8* [ %79, %75 ], [ %72, %65 ]
%78 = phi i32 [ %81, %75 ], [ %53, %65 ]
%79 = getelementptr inbounds i8, i8* %77, i64 -1
store i8 0, i8* %77
%80 = getelementptr inbounds i8, i8* %76, i64 -1
%81 = add nsw i32 %78, -1
%82 = load i8, i8* %80
%83 = icmp eq i8 %82, 0
br i1 %83, label %75, label %84
84: ; preds = %75, %65
%85 = phi i32 [ %53, %65 ], [ %81, %75 ]
%86 = phi i8* [ %72, %65 ], [ %79, %75 ]
%87 = phi i8* [ %69, %65 ], [ %80, %75 ]
%88 = phi i8 [ %73, %65 ], [ %82, %75 ]
%89 = sub i8 0, %88
store i8 %89, i8* %86
%90 = icmp sgt i32 %85, 1
br i1 %90, label %91, label %238
91: ; preds = %84
%92 = call i32 @llvm.umin.i32(i32 %85, i32 2)
%93 = sub i32 %85, %92
%94 = zext i32 %93 to i64
%95 = add nuw nsw i64 %94, 1
%96 = icmp ult i32 %93, 3
br i1 %96, label %224, label %97
97: ; preds = %91
%98 = call i32 @llvm.umin.i32(i32 %85, i32 2)
%99 = sub i32 %85, %98
%100 = zext i32 %99 to i64
%101 = xor i64 %100, -1
%102 = getelementptr i8, i8* %86, i64 %101
%103 = getelementptr i8, i8* %87, i64 %101
%104 = icmp ult i8* %102, %87
%105 = icmp ult i8* %103, %86
%106 = and i1 %104, %105
br i1 %106, label %224, label %107
107: ; preds = %97
%108 = icmp ult i32 %93, 15
br i1 %108, label %195, label %109
109: ; preds = %107
%110 = and i64 %95, 8589934576
%111 = add nsw i64 %110, -16
%112 = lshr exact i64 %111, 4
%113 = add nuw nsw i64 %112, 1
%114 = and i64 %113, 3
%115 = icmp ult i64 %111, 48
br i1 %115, label %164, label %116
116: ; preds = %109
%117 = and i64 %113, 2305843009213693948
%118 = getelementptr i8, i8* %86, i64 -16
%119 = getelementptr i8, i8* %87, i64 -16
%120 = getelementptr i8, i8* %86, i64 -16
%121 = getelementptr i8, i8* %87, i64 -16
%122 = getelementptr i8, i8* %86, i64 -16
%123 = getelementptr i8, i8* %87, i64 -16
%124 = getelementptr i8, i8* %86, i64 -16
%125 = getelementptr i8, i8* %87, i64 -16
br label %126
126: ; preds = %126, %116
%127 = phi i64 [ 0, %116 ], [ %161, %126 ]
%128 = phi i64 [ 0, %116 ], [ %162, %126 ]
%129 = sub i64 0, %127
%130 = sub i64 0, %127
%131 = getelementptr inbounds i8, i8* %119, i64 %129
%132 = bitcast i8* %131 to <16 x i8>*
%133 = load <16 x i8>, <16 x i8>* %132
%134 = xor <16 x i8> %133, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%135 = getelementptr inbounds i8, i8* %118, i64 %130
%136 = bitcast i8* %135 to <16 x i8>*
store <16 x i8> %134, <16 x i8>* %136
%137 = sub nuw nsw i64 -16, %127
%138 = sub nuw nsw i64 -16, %127
%139 = getelementptr inbounds i8, i8* %121, i64 %137
%140 = bitcast i8* %139 to <16 x i8>*
%141 = load <16 x i8>, <16 x i8>* %140
%142 = xor <16 x i8> %141, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%143 = getelementptr inbounds i8, i8* %120, i64 %138
%144 = bitcast i8* %143 to <16 x i8>*
store <16 x i8> %142, <16 x i8>* %144
%145 = sub nuw nsw i64 -32, %127
%146 = sub nuw nsw i64 -32, %127
%147 = getelementptr inbounds i8, i8* %123, i64 %145
%148 = bitcast i8* %147 to <16 x i8>*
%149 = load <16 x i8>, <16 x i8>* %148
%150 = xor <16 x i8> %149, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%151 = getelementptr inbounds i8, i8* %122, i64 %146
%152 = bitcast i8* %151 to <16 x i8>*
store <16 x i8> %150, <16 x i8>* %152
%153 = sub nuw nsw i64 -48, %127
%154 = sub nuw nsw i64 -48, %127
%155 = getelementptr inbounds i8, i8* %125, i64 %153
%156 = bitcast i8* %155 to <16 x i8>*
%157 = load <16 x i8>, <16 x i8>* %156
%158 = xor <16 x i8> %157, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%159 = getelementptr inbounds i8, i8* %124, i64 %154
%160 = bitcast i8* %159 to <16 x i8>*
store <16 x i8> %158, <16 x i8>* %160
%161 = add nuw i64 %127, 64
%162 = add i64 %128, 4
%163 = icmp eq i64 %162, %117
br i1 %163, label %164, label %126
164: ; preds = %126, %109
%165 = phi i64 [ 0, %109 ], [ %161, %126 ]
%166 = icmp eq i64 %114, 0
br i1 %166, label %184, label %167
167: ; preds = %164
%168 = getelementptr i8, i8* %86, i64 -16
%169 = getelementptr i8, i8* %87, i64 -16
br label %170
170: ; preds = %170, %167
%171 = phi i64 [ %165, %167 ], [ %181, %170 ]
%172 = phi i64 [ 0, %167 ], [ %182, %170 ]
%173 = sub i64 0, %171
%174 = sub i64 0, %171
%175 = getelementptr inbounds i8, i8* %169, i64 %173
%176 = bitcast i8* %175 to <16 x i8>*
%177 = load <16 x i8>, <16 x i8>* %176
%178 = xor <16 x i8> %177, <i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1, i8 -1>
%179 = getelementptr inbounds i8, i8* %168, i64 %174
%180 = bitcast i8* %179 to <16 x i8>*
store <16 x i8> %178, <16 x i8>* %180
%181 = add nuw i64 %171, 16
%182 = add i64 %172, 1
%183 = icmp eq i64 %182, %114
br i1 %183, label %184, label %170
184: ; preds = %170, %164
%185 = icmp eq i64 %95, %110
br i1 %185, label %238, label %186
186: ; preds = %184
%187 = trunc i64 %110 to i32
%188 = sub i32 %85, %187
%189 = sub nsw i64 0, %110
%190 = getelementptr i8, i8* %86, i64 %189
%191 = sub nsw i64 0, %110
%192 = getelementptr i8, i8* %87, i64 %191
%193 = and i64 %95, 12
%194 = icmp eq i64 %193, 0
br i1 %194, label %224, label %195
195: ; preds = %107, %186
%196 = phi i64 [ %110, %186 ], [ 0, %107 ]
%197 = call i32 @llvm.umin.i32(i32 %85, i32 2)
%198 = sub i32 %85, %197
%199 = zext i32 %198 to i64
%200 = add nuw nsw i64 %199, 1
%201 = and i64 %200, 8589934588
%202 = sub nsw i64 0, %201
%203 = getelementptr i8, i8* %87, i64 %202
%204 = sub nsw i64 0, %201
%205 = getelementptr i8, i8* %86, i64 %204
%206 = trunc i64 %201 to i32
%207 = sub i32 %85, %206
%208 = getelementptr i8, i8* %86, i64 -4
%209 = getelementptr i8, i8* %87, i64 -4
br label %210
210: ; preds = %210, %195
%211 = phi i64 [ %196, %195 ], [ %220, %210 ]
%212 = sub i64 0, %211
%213 = sub i64 0, %211
%214 = getelementptr inbounds i8, i8* %209, i64 %212
%215 = bitcast i8* %214 to <4 x i8>*
%216 = load <4 x i8>, <4 x i8>* %215
%217 = xor <4 x i8> %216, <i8 -1, i8 -1, i8 -1, i8 -1>
%218 = getelementptr inbounds i8, i8* %208, i64 %213
%219 = bitcast i8* %218 to <4 x i8>*
store <4 x i8> %217, <4 x i8>* %219
%220 = add nuw i64 %211, 4
%221 = icmp eq i64 %220, %201
br i1 %221, label %222, label %210
222: ; preds = %210
%223 = icmp eq i64 %200, %201
br i1 %223, label %238, label %224
224: ; preds = %97, %91, %186, %222
%225 = phi i8* [ %87, %91 ], [ %87, %97 ], [ %192, %186 ], [ %203, %222 ]
%226 = phi i8* [ %86, %91 ], [ %86, %97 ], [ %190, %186 ], [ %205, %222 ]
%227 = phi i32 [ %85, %91 ], [ %85, %97 ], [ %188, %186 ], [ %207, %222 ]
br label %228
228: ; preds = %224, %228
%229 = phi i8* [ %233, %228 ], [ %225, %224 ]
%230 = phi i8* [ %232, %228 ], [ %226, %224 ]
%231 = phi i32 [ %234, %228 ], [ %227, %224 ]
%232 = getelementptr inbounds i8, i8* %230, i64 -1
%233 = getelementptr inbounds i8, i8* %229, i64 -1
%234 = add nsw i32 %231, -1
%235 = load i8, i8* %233
%236 = xor i8 %235, -1
store i8 %236, i8* %232
%237 = icmp ugt i32 %231, 2
br i1 %237, label %228, label %238
238: ; preds = %228, %184, %222, %84, %63, %56
%239 = phi i32 [ %40, %84 ], [ %40, %63 ], [ %58, %56 ], [ %40, %222 ], [ %40, %184 ], [ %40, %228 ]
%240 = load i8*, i8** %1
%241 = sext i32 %239 to i64
%242 = getelementptr inbounds i8, i8* %240, i64 %241
store i8* %242, i8** %1
br label %243
243: ; preds = %42, %37, %2, %238
%244 = phi i32 [ %239, %238 ], [ 0, %2 ], [ %40, %37 ], [ 1, %42 ]
ret i32 %244
}