#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 */

/* Type definitions */
typedef int u_int;

/* Variables and functions */
char *cgetcap(char *, char const *, char);
int /*<<< orphan*/ free(char *);
char *malloc(int);
char *realloc(char *, size_t);
int cgetstr(char *buf, const char *cap, char **str) {
  u_int m_room;
  char *bp, *mp;
  int len;
  char *mem;
  bp = cgetcap(buf, cap, '=');
  if (bp == NULL)
    return (-1);
  if ((mem = malloc(100)) == NULL)
    return (-2);
  m_room = 100;
  mp = mem;
  while (*bp != ':' && *bp != '\0') {
    if (*bp == '^') {
      bp++;
      if (*bp == ':' || *bp == '\0')
        break;
      *mp++ = *bp++ & 037;
    } else if (*bp == '\\') {
      bp++;
      if (*bp == ':' || *bp == '\0')
        break;
      if ('0' <= *bp && *bp <= '7') {
        int n, i;
        n = 0;
        i = 3;
        do {
          n = n * 8 + (*bp++ - '0');
        } while (--i && '0' <= *bp && *bp <= '7');
        *mp++ = n;
      } else
        switch (*bp++) {
        case 'b':
        case 'B':
          *mp++ = '\b';
          break;
        case 't':
        case 'T':
          *mp++ = '\t';
          break;
        case 'n':
        case 'N':
          *mp++ = '\n';
          break;
        case 'f':
        case 'F':
          *mp++ = '\f';
          break;
        case 'r':
        case 'R':
          *mp++ = '\r';
          break;
        case 'e':
        case 'E':
          *mp++ = ('[' & 037);
          break;
        case 'c':
        case 'C':
          *mp++ = ':';
          break;
        default:
          *mp++ = *(bp - 1);
          break;
        }
    } else
      *mp++ = *bp++;
    m_room--;
    if (m_room == 0) {
      size_t size = mp - mem;
      char *nmem;
      if ((nmem = realloc(mem, size + 100)) == NULL) {
        if (mem)
          free(mem);
        return (-2);
      }
      mem = nmem;
      m_room = 100;
      mp = mem + size;
    }
  }
  *mp++ = '\0';
  m_room--;
  len = mp - mem - 1;
  if (m_room != 0) {
    char *nmem;
    if ((nmem = realloc(mem, (size_t)(mp - mem))) == NULL) {
      if (mem)
        free(mem);
      return (-2);
    }
    mem = nmem;
  }
  *str = mem;
  return (len);
}


x86 assembly (clang, -O0):
<cgetstr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    $0x3d,%edx
call   1060 <cgetcap@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1184 <cgetstr+0x44>
movl   $0xffffffff,-0x4(%rbp)
jmp    1588 <cgetstr+0x448>
mov    $0x64,%edi
call   1040 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jne    11a8 <cgetstr+0x68>
movl   $0xfffffffe,-0x4(%rbp)
jmp    1588 <cgetstr+0x448>
movl   $0x64,-0x24(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x3a,%ecx
mov    %al,-0x69(%rbp)
je     11dc <cgetstr+0x9c>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x69(%rbp)
mov    -0x69(%rbp),%al
test   $0x1,%al
jne    11ec <cgetstr+0xac>
jmp    14f6 <cgetstr+0x3b6>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5e,%eax
jne    125a <cgetstr+0x11a>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
je     1228 <cgetstr+0xe8>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    122d <cgetstr+0xed>
jmp    14f6 <cgetstr+0x3b6>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl (%rax),%eax
and    $0x1f,%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    1475 <cgetstr+0x335>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
jne    144e <cgetstr+0x30e>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
je     1296 <cgetstr+0x156>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    129b <cgetstr+0x15b>
jmp    14f6 <cgetstr+0x3b6>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
mov    $0x30,%eax
cmp    %ecx,%eax
jg     1353 <cgetstr+0x213>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x37,%eax
jg     1353 <cgetstr+0x213>
movl   $0x0,-0x4c(%rbp)
movl   $0x3,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x3,%eax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
movsbl (%rcx),%ecx
sub    $0x30,%ecx
add    %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x50(%rbp)
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x6a(%rbp)
je     132d <cgetstr+0x1ed>
mov    -0x30(%rbp),%rax
movsbl (%rax),%edx
xor    %eax,%eax
mov    $0x30,%ecx
cmp    %edx,%ecx
mov    %al,-0x6a(%rbp)
jg     132d <cgetstr+0x1ed>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x37,%eax
setle  %al
mov    %al,-0x6a(%rbp)
mov    -0x6a(%rbp),%al
test   $0x1,%al
jne    12cd <cgetstr+0x18d>
mov    -0x4c(%rbp),%eax
mov    %al,%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    1449 <cgetstr+0x309>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl (%rax),%eax
add    $0xffffffbe,%eax
mov    %eax,%ecx
mov    %rcx,-0x78(%rbp)
sub    $0x32,%eax
ja     142c <cgetstr+0x2ec>
mov    -0x78(%rbp),%rax
lea    0xc7e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x8,(%rax)
jmp    1444 <cgetstr+0x304>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x9,(%rax)
jmp    1444 <cgetstr+0x304>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0xa,(%rax)
jmp    1444 <cgetstr+0x304>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0xc,(%rax)
jmp    1444 <cgetstr+0x304>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0xd,(%rax)
jmp    1444 <cgetstr+0x304>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x1b,(%rax)
jmp    1444 <cgetstr+0x304>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x3a,(%rax)
jmp    1444 <cgetstr+0x304>
mov    -0x30(%rbp),%rax
mov    -0x1(%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    1449 <cgetstr+0x309>
jmp    1470 <cgetstr+0x330>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    1475 <cgetstr+0x335>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jne    14f1 <cgetstr+0x3b1>
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x58(%rbp),%rsi
add    $0x64,%rsi
call   1050 <realloc@plt>
mov    %rax,-0x60(%rbp)
cmp    $0x0,%rax
jne    14d6 <cgetstr+0x396>
cmpq   $0x0,-0x48(%rbp)
je     14ca <cgetstr+0x38a>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0xfffffffe,-0x4(%rbp)
jmp    1588 <cgetstr+0x448>
mov    -0x60(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x64,-0x24(%rbp)
mov    -0x48(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    11b7 <cgetstr+0x77>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movb   $0x0,(%rax)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
sub    $0x1,%rax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     1577 <cgetstr+0x437>
mov    -0x48(%rbp),%rdi
mov    -0x38(%rbp),%rsi
mov    -0x48(%rbp),%rax
sub    %rax,%rsi
call   1050 <realloc@plt>
mov    %rax,-0x68(%rbp)
cmp    $0x0,%rax
jne    156f <cgetstr+0x42f>
cmpq   $0x0,-0x48(%rbp)
je     1563 <cgetstr+0x423>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
movl   $0xfffffffe,-0x4(%rbp)
jmp    1588 <cgetstr+0x448>
mov    -0x68(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cgetstr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%rbx
mov    $0x3d,%edx
call   1060 <cgetcap@plt>
test   %rax,%rax
je     1317 <cgetstr+0x1d7>
mov    %rax,%rbp
mov    $0x64,%edi
call   1040 <malloc@plt>
mov    $0xfffffffe,%r15d
test   %rax,%rax
je     131d <cgetstr+0x1dd>
mov    %rax,%r13
mov    %rbx,(%rsp)
lea    0xe75(%rip),%r14
mov    %rax,%r12
xor    %ebx,%ebx
jmp    11b6 <cgetstr+0x76>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
mov    %al,0x0(%r13,%rbx,1)
add    $0x1,%rbx
cmp    $0x64,%ebx
je     12b6 <cgetstr+0x176>
movzbl 0x0(%rbp),%eax
cmp    $0x5d,%al
jg     1220 <cgetstr+0xe0>
cmp    $0x5c,%al
jne    1247 <cgetstr+0x107>
movzbl 0x1(%rbp),%ecx
test   %ecx,%ecx
je     12dc <cgetstr+0x19c>
cmp    $0x3a,%cl
je     12dc <cgetstr+0x19c>
mov    %ecx,%eax
and    $0xf8,%al
cmp    $0x30,%al
jne    125c <cgetstr+0x11c>
add    $0xffffffd0,%ecx
movzbl 0x2(%rbp),%eax
mov    %eax,%edx
and    $0xf8,%dl
cmp    $0x30,%dl
jne    127d <cgetstr+0x13d>
lea    (%rax,%rcx,8),%ecx
add    $0xffffffd0,%ecx
movzbl 0x3(%rbp),%eax
mov    %eax,%edx
and    $0xf8,%dl
cmp    $0x30,%dl
jne    1288 <cgetstr+0x148>
add    $0x4,%rbp
lea    (%rax,%rcx,8),%ecx
add    $0xffffffd0,%ecx
mov    %ecx,%eax
jmp    11a4 <cgetstr+0x64>
xchg   %ax,%ax
cmp    $0x5e,%al
jne    11a0 <cgetstr+0x60>
movzbl 0x1(%rbp),%eax
test   %al,%al
je     12dc <cgetstr+0x19c>
cmp    $0x3a,%al
je     12dc <cgetstr+0x19c>
add    $0x2,%rbp
and    $0x1f,%al
jmp    11a4 <cgetstr+0x64>
test   %al,%al
je     12dc <cgetstr+0x19c>
cmp    $0x3a,%al
jne    11a0 <cgetstr+0x60>
jmp    12dc <cgetstr+0x19c>
movsbl %cl,%edx
add    $0x2,%rbp
add    $0xffffffbe,%edx
cmp    $0x32,%edx
ja     121a <cgetstr+0xda>
mov    $0x8,%al
movslq (%r14,%rdx,4),%rdx
add    %r14,%rdx
jmp    *%rdx
mov    $0x3a,%al
jmp    11a4 <cgetstr+0x64>
add    $0x2,%rbp
mov    %ecx,%eax
jmp    11a4 <cgetstr+0x64>
add    $0x3,%rbp
mov    %ecx,%eax
jmp    11a4 <cgetstr+0x64>
mov    $0x1b,%al
jmp    11a4 <cgetstr+0x64>
mov    $0xc,%al
jmp    11a4 <cgetstr+0x64>
mov    $0xa,%al
jmp    11a4 <cgetstr+0x64>
mov    $0xd,%al
jmp    11a4 <cgetstr+0x64>
mov    $0x9,%al
jmp    11a4 <cgetstr+0x64>
sub    %r12,%r13
lea    (%rbx,%r13,1),%rsi
add    $0x64,%rsi
mov    %r12,%rdi
call   1050 <realloc@plt>
test   %rax,%rax
je     132f <cgetstr+0x1ef>
add    %rax,%r13
add    %rbx,%r13
mov    %rax,%r12
jmp    118e <cgetstr+0x4e>
movb   $0x0,0x0(%r13,%rbx,1)
mov    %r12,%rax
cmp    $0x63,%ebx
je     1305 <cgetstr+0x1c5>
mov    %r13,%rax
sub    %r12,%rax
lea    (%rax,%rbx,1),%rsi
add    $0x1,%rsi
mov    %r12,%rdi
call   1050 <realloc@plt>
test   %rax,%rax
je     132f <cgetstr+0x1ef>
sub    %r12d,%r13d
add    %rbx,%r13
mov    (%rsp),%rcx
mov    %rax,(%rcx)
mov    %r13d,%r15d
jmp    131d <cgetstr+0x1dd>
mov    $0xffffffff,%r15d
mov    %r15d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r12,%rdi
call   1030 <free@plt>
jmp    131d <cgetstr+0x1dd>

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

LLVM IR (-O2):
define i32 @cgetstr(i8* %0, i8* %1, i8** nocapture writeonly %2) {
%4 = tail call i8* @cgetcap(i8* %0, i8* %1, i8 signext 61)
%5 = icmp eq i8* %4, null
br i1 %5, label %100, label %6
6: ; preds = %3
%7 = tail call dereferenceable_or_null(100) i8* @malloc(i32 100)
%8 = icmp eq i8* %7, null
br i1 %8, label %100, label %9
9: ; preds = %6, %83
%10 = phi i8* [ %84, %83 ], [ %7, %6 ]
%11 = phi i8* [ %79, %83 ], [ %7, %6 ]
%12 = phi i8* [ %70, %83 ], [ %4, %6 ]
br label %13
13: ; preds = %9, %68
%14 = phi i8* [ %71, %68 ], [ %10, %9 ]
%15 = phi i8* [ %70, %68 ], [ %12, %9 ]
%16 = phi i32 [ %72, %68 ], [ 100, %9 ]
%17 = load i8, i8* %15
switch i8 %17, label %66 [
i8 58, label %85
i8 0, label %85
i8 94, label %18
i8 92, label %24
]
18: ; preds = %13
%19 = getelementptr inbounds i8, i8* %15, i64 1
%20 = load i8, i8* %19
switch i8 %20, label %21 [
i8 58, label %85
i8 0, label %85
]
21: ; preds = %18
%22 = getelementptr inbounds i8, i8* %15, i64 2
%23 = and i8 %20, 31
br label %68
24: ; preds = %13
%25 = getelementptr inbounds i8, i8* %15, i64 1
%26 = load i8, i8* %25
switch i8 %26, label %27 [
i8 58, label %85
i8 0, label %85
]
27: ; preds = %24
%28 = and i8 %26, -8
%29 = icmp eq i8 %28, 48
br i1 %29, label %30, label %56
30: ; preds = %27
%31 = getelementptr i8, i8* %15, i64 4
%32 = getelementptr inbounds i8, i8* %15, i64 2
%33 = zext i8 %26 to i32
%34 = add nsw i32 %33, -48
%35 = load i8, i8* %32
%36 = and i8 %35, -8
%37 = icmp eq i8 %36, 48
br i1 %37, label %38, label %52
38: ; preds = %30
%39 = shl nuw nsw i32 %34, 3
%40 = getelementptr inbounds i8, i8* %15, i64 3
%41 = zext i8 %35 to i32
%42 = add nsw i32 %39, -48
%43 = add nsw i32 %42, %41
%44 = load i8, i8* %40
%45 = and i8 %44, -8
%46 = icmp eq i8 %45, 48
br i1 %46, label %47, label %52
47: ; preds = %38
%48 = shl nuw nsw i32 %43, 3
%49 = zext i8 %44 to i32
%50 = add nsw i32 %48, -48
%51 = add nsw i32 %50, %49
br label %52
52: ; preds = %47, %38, %30
%53 = phi i8* [ %32, %30 ], [ %40, %38 ], [ %31, %47 ]
%54 = phi i32 [ %34, %30 ], [ %43, %38 ], [ %51, %47 ]
%55 = trunc i32 %54 to i8
br label %68
56: ; preds = %27
%57 = getelementptr inbounds i8, i8* %15, i64 2
%58 = sext i8 %26 to i32
switch i32 %58, label %65 [
i32 98, label %68
i32 66, label %68
i32 116, label %59
i32 84, label %59
i32 110, label %60
i32 78, label %60
i32 102, label %61
i32 70, label %61
i32 114, label %62
i32 82, label %62
i32 101, label %63
i32 69, label %63
i32 99, label %64
i32 67, label %64
]
59: ; preds = %56, %56
br label %68
60: ; preds = %56, %56
br label %68
61: ; preds = %56, %56
br label %68
62: ; preds = %56, %56
br label %68
63: ; preds = %56, %56
br label %68
64: ; preds = %56, %56
br label %68
65: ; preds = %56
br label %68
66: ; preds = %13
%67 = getelementptr inbounds i8, i8* %15, i64 1
br label %68
68: ; preds = %56, %56, %66, %59, %60, %61, %62, %63, %64, %65, %52, %21
%69 = phi i8 [ %17, %66 ], [ 9, %59 ], [ 10, %60 ], [ 12, %61 ], [ 13, %62 ], [ 27, %63 ], [ 58, %64 ], [ %26, %65 ], [ %55, %52 ], [ %23, %21 ], [ 8, %56 ], [ 8, %56 ]
%70 = phi i8* [ %67, %66 ], [ %57, %59 ], [ %57, %60 ], [ %57, %61 ], [ %57, %62 ], [ %57, %63 ], [ %57, %64 ], [ %57, %65 ], [ %53, %52 ], [ %22, %21 ], [ %57, %56 ], [ %57, %56 ]
store i8 %69, i8* %14
%71 = getelementptr inbounds i8, i8* %14, i64 1
%72 = add nsw i32 %16, -1
%73 = icmp eq i32 %72, 0
br i1 %73, label %74, label %13
74: ; preds = %68
%75 = ptrtoint i8* %71 to i64
%76 = ptrtoint i8* %11 to i64
%77 = sub i64 %75, %76
%78 = add i64 %77, 100
%79 = tail call i8* @realloc(i8* %11, i64 %78)
%80 = icmp eq i8* %79, null
br i1 %80, label %81, label %83
81: ; preds = %74
%82 = tail call i32 @free(i8* %11)
br label %100
83: ; preds = %74
%84 = getelementptr inbounds i8, i8* %79, i64 %77
br label %9
85: ; preds = %24, %24, %13, %13, %18, %18
%86 = getelementptr inbounds i8, i8* %14, i64 1
store i8 0, i8* %14
%87 = ptrtoint i8* %86 to i64
%88 = ptrtoint i8* %11 to i64
%89 = sub i64 %87, %88
%90 = trunc i64 %89 to i32
%91 = add i32 %90, -1
%92 = icmp eq i32 %16, 1
br i1 %92, label %98, label %93
93: ; preds = %85
%94 = tail call i8* @realloc(i8* %11, i64 %89)
%95 = icmp eq i8* %94, null
br i1 %95, label %96, label %98
96: ; preds = %93
%97 = tail call i32 @free(i8* %11)
br label %100
98: ; preds = %93, %85
%99 = phi i8* [ %11, %85 ], [ %94, %93 ]
store i8* %99, i8** %2
br label %100
100: ; preds = %96, %81, %6, %3, %98
%101 = phi i32 [ %91, %98 ], [ -1, %3 ], [ -2, %6 ], [ -2, %81 ], [ -2, %96 ]
ret i32 %101
}