#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 /*<<< orphan*/ buf;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int EOF;
int /*<<< orphan*/ fatal(char *, char *);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
scalar_t__ isspace(char);
char *sipStrdup(char *);
char *strchr(char *, char);
int /*<<< orphan*/ usage();
char parseopt(int argc, char **argv, char *opts, char **flags, int *optnrp,
              char **optargp) {
  char arg, *op, *fname;
  int optnr;
  static FILE *fp = NULL;
  optnr = *optnrp;
  fname = *flags;
  if (fname == NULL && optnr < argc && argv[optnr][0] == '@') {
    fname = *flags = &argv[optnr][1];
    *optnrp = ++optnr;
  }
  if (fname != NULL && fp == NULL && (fp = fopen(fname, "r")) == NULL)
    fatal("Unable to open %s\n", fname);
  if (fp != NULL) {
    char buf[200], *cp, *fname;
    int ch;
    fname = *flags;
    cp = buf;
    while ((ch = fgetc(fp)) != EOF) {
      if (cp == buf && isspace(ch))
        continue;
      if (ch == '\n')
        break;
      if (cp == &buf[sizeof(buf) - 1])
        fatal("A flag in %s is too long\n", fname);
      *cp++ = (char)ch;
    }
    *cp = '\0';
    if (ch == EOF) {
      fclose(fp);
      fp = NULL;
      *flags = NULL;
    }
    if (buf[0] != '\0') {
      if (buf[0] != '-' || buf[1] == '\0')
        fatal("An non-flag was given in %s\n", fname);
      arg = buf[1];
      for (cp = &buf[2]; *cp != '\0'; ++cp)
        if (!isspace(*cp))
          break;
      if (*cp == '\0')
        cp = NULL;
      else
        cp = sipStrdup(cp);
      *optargp = cp;
      if ((op = strchr(opts, arg)) == NULL)
        fatal("An invalid flag was given in %s\n", fname);
      if (op[1] == ':' && cp == NULL)
        fatal("Missing flag argument in %s\n", fname);
      if (op[1] != ':' && cp != NULL)
        fatal("Unexpected flag argument in %s\n", fname);
      return arg;
    }
  }
  if (optnr >= argc || argv[optnr] == NULL || argv[optnr][0] != '-')
    return '\0';
  arg = argv[optnr][1];
  if (arg == '\0' || (op = strchr(opts, arg)) == NULL)
    usage();
  if (op[1] == ':') {
    if (argv[optnr][2] != '\0') {
      *optargp = &argv[optnr][2];
      ++optnr;
    } else if (optnr + 1 >= argc || argv[optnr + 1] == NULL)
      usage();
    else {
      *optargp = argv[optnr + 1];
      optnr += 2;
    }
  } else if (argv[optnr][2] != '\0')
    usage();
  else {
    *optargp = NULL;
    ++optnr;
  }
  *optnrp = optnr;
  return arg;
}


x86 assembly (clang, -O0):
<parseopt>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    120f <parseopt+0x8f>
mov    -0x4c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    120f <parseopt+0x8f>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x40,%eax
jne    120f <parseopt+0x8f>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    $0x1,%rax
mov    -0x20(%rbp),%rcx
mov    %rax,(%rcx)
mov    %rax,-0x48(%rbp)
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
cmpq   $0x0,-0x48(%rbp)
je     1259 <parseopt+0xd9>
cmpq   $0x0,0x2e46(%rip)
jne    1259 <parseopt+0xd9>
mov    -0x48(%rbp),%rdi
lea    0xdcd(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,0x2e29(%rip)
cmp    $0x0,%rax
jne    1259 <parseopt+0xd9>
mov    -0x48(%rbp),%rsi
lea    0xdae(%rip),%rdi
call   10a0 <fatal@plt>
cmpq   $0x0,0x2e07(%rip)
je     1511 <parseopt+0x391>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x130(%rbp)
lea    -0x120(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    0x2dde(%rip),%rdi
call   1060 <fgetc@plt>
mov    %eax,-0x134(%rbp)
mov    0x2d4c(%rip),%rcx
cmp    (%rcx),%eax
je     133f <parseopt+0x1bf>
mov    -0x128(%rbp),%rax
lea    -0x120(%rbp),%rcx
cmp    %rcx,%rax
jne    12d8 <parseopt+0x158>
mov    -0x134(%rbp),%eax
movsbl %al,%edi
call   1070 <isspace@plt>
cmp    $0x0,%rax
je     12d8 <parseopt+0x158>
jmp    1283 <parseopt+0x103>
cmpl   $0xa,-0x134(%rbp)
jne    12ea <parseopt+0x16a>
jmp    133f <parseopt+0x1bf>
mov    -0x128(%rbp),%rax
lea    -0x120(%rbp),%rcx
add    $0xc7,%rcx
cmp    %rcx,%rax
jne    131b <parseopt+0x19b>
mov    -0x130(%rbp),%rsi
lea    0xcff(%rip),%rdi
call   10a0 <fatal@plt>
mov    -0x134(%rbp),%eax
mov    %al,%cl
mov    -0x128(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x128(%rbp)
mov    %cl,(%rax)
jmp    1283 <parseopt+0x103>
mov    -0x128(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x134(%rbp),%eax
mov    0x2c92(%rip),%rcx
cmp    (%rcx),%eax
jne    1380 <parseopt+0x200>
mov    0x2d03(%rip),%rdi
call   1030 <fclose@plt>
movq   $0x0,0x2cf3(%rip)
mov    -0x20(%rbp),%rax
movq   $0x0,(%rax)
movsbl -0x120(%rbp),%eax
cmp    $0x0,%eax
je     150c <parseopt+0x38c>
movsbl -0x120(%rbp),%eax
cmp    $0x2d,%eax
jne    13b0 <parseopt+0x230>
movsbl -0x11f(%rbp),%eax
cmp    $0x0,%eax
jne    13c3 <parseopt+0x243>
mov    -0x130(%rbp),%rsi
lea    0xc71(%rip),%rdi
call   10a0 <fatal@plt>
mov    -0x11f(%rbp),%al
mov    %al,-0x31(%rbp)
lea    -0x120(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     142b <parseopt+0x2ab>
mov    -0x128(%rbp),%rax
movsbl (%rax),%edi
call   1070 <isspace@plt>
cmp    $0x0,%rax
jne    140f <parseopt+0x28f>
jmp    142b <parseopt+0x2ab>
jmp    1414 <parseopt+0x294>
mov    -0x128(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x128(%rbp)
jmp    13de <parseopt+0x25e>
mov    -0x128(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    144e <parseopt+0x2ce>
movq   $0x0,-0x128(%rbp)
jmp    1461 <parseopt+0x2e1>
mov    -0x128(%rbp),%rdi
call   1040 <sipStrdup@plt>
mov    %rax,-0x128(%rbp)
mov    -0x128(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rdi
movsbl -0x31(%rbp),%esi
call   1050 <strchr@plt>
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jne    149d <parseopt+0x31d>
mov    -0x130(%rbp),%rsi
lea    0xbb4(%rip),%rdi
call   10a0 <fatal@plt>
mov    -0x40(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3a,%eax
jne    14cf <parseopt+0x34f>
cmpq   $0x0,-0x128(%rbp)
jne    14cf <parseopt+0x34f>
mov    -0x130(%rbp),%rsi
lea    0xba3(%rip),%rdi
call   10a0 <fatal@plt>
mov    -0x40(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3a,%eax
je     1501 <parseopt+0x381>
cmpq   $0x0,-0x128(%rbp)
je     1501 <parseopt+0x381>
mov    -0x130(%rbp),%rsi
lea    0xb8e(%rip),%rdi
call   10a0 <fatal@plt>
mov    -0x31(%rbp),%al
mov    %al,-0x1(%rbp)
jmp    168c <parseopt+0x50c>
jmp    1511 <parseopt+0x391>
mov    -0x4c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1548 <parseopt+0x3c8>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1548 <parseopt+0x3c8>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
je     1551 <parseopt+0x3d1>
movb   $0x0,-0x1(%rbp)
jmp    168c <parseopt+0x50c>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x1(%rax),%al
mov    %al,-0x31(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x0,%eax
je     158b <parseopt+0x40b>
mov    -0x18(%rbp),%rdi
movsbl -0x31(%rbp),%esi
call   1050 <strchr@plt>
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jne    1592 <parseopt+0x412>
mov    $0x0,%al
call   1080 <usage@plt>
mov    -0x40(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3a,%eax
jne    163f <parseopt+0x4bf>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x2(%rax),%eax
cmp    $0x0,%eax
je     15e1 <parseopt+0x461>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
add    $0x2,%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    163a <parseopt+0x4ba>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
cmp    -0x8(%rbp),%eax
jge    1608 <parseopt+0x488>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpq   $0x0,(%rax,%rcx,8)
jne    1614 <parseopt+0x494>
mov    $0x0,%al
call   1080 <usage@plt>
jmp    1635 <parseopt+0x4b5>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x4c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x4c(%rbp)
jmp    163a <parseopt+0x4ba>
jmp    167d <parseopt+0x4fd>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x2(%rax),%eax
cmp    $0x0,%eax
je     1664 <parseopt+0x4e4>
mov    $0x0,%al
call   1080 <usage@plt>
jmp    1678 <parseopt+0x4f8>
mov    -0x30(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    167d <parseopt+0x4fd>
mov    -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x31(%rbp),%al
mov    %al,-0x1(%rbp)
movsbl -0x1(%rbp),%eax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parseopt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r9,0x8(%rsp)
mov    %rcx,%r15
mov    %rdx,0x28(%rsp)
mov    %rsi,(%rsp)
mov    %edi,%r14d
mov    %r8,0x20(%rsp)
mov    (%r8),%ebp
mov    (%rcx),%rbx
test   %rbx,%rbx
je     11eb <parseopt+0x6b>
cmpq   $0x0,0x2eab(%rip)
jne    122b <parseopt+0xab>
lea    0xe3a(%rip),%rsi
mov    %rbx,%rdi
call   1090 <fopen@plt>
mov    %rax,0x2e93(%rip)
test   %rax,%rax
jne    122b <parseopt+0xab>
lea    0xe21(%rip),%rdi
mov    %rbx,%rsi
call   10a0 <fatal@plt>
jmp    121d <parseopt+0x9d>
cmp    %r14d,%ebp
jge    121d <parseopt+0x9d>
movslq %ebp,%rax
mov    (%rsp),%rcx
mov    (%rcx,%rax,8),%rbx
cmpb   $0x40,(%rbx)
jne    121d <parseopt+0x9d>
add    $0x1,%rbx
mov    %rbx,(%r15)
add    $0x1,%ebp
mov    0x20(%rsp),%rax
mov    %ebp,(%rax)
cmpq   $0x0,0x2e4f(%rip)
jne    122b <parseopt+0xab>
jmp    11bf <parseopt+0x3f>
cmpq   $0x0,0x2e43(%rip)
je     1332 <parseopt+0x1b2>
mov    %r14d,0x1c(%rsp)
lea    0x30(%rsp),%rbx
mov    (%r15),%rax
mov    %rax,0x10(%rsp)
mov    0x2da4(%rip),%r13
mov    %rbx,%r14
jmp    1250 <parseopt+0xd0>
mov    %r12b,(%r14)
add    $0x1,%r14
mov    0x2e11(%rip),%rdi
call   1060 <fgetc@plt>
cmp    0x0(%r13),%eax
je     12a2 <parseopt+0x122>
mov    %eax,%r12d
cmp    %rbx,%r14
jne    1278 <parseopt+0xf8>
movsbl %r12b,%edi
call   1070 <isspace@plt>
test   %rax,%rax
jne    1250 <parseopt+0xd0>
cmp    $0xa,%r12d
je     142b <parseopt+0x2ab>
lea    0xf7(%rsp),%rax
cmp    %rax,%r14
jne    1249 <parseopt+0xc9>
lea    0xd7f(%rip),%rdi
mov    0x10(%rsp),%rsi
call   10a0 <fatal@plt>
jmp    1249 <parseopt+0xc9>
movb   $0x0,(%r14)
mov    0x2dbb(%rip),%rdi
call   1030 <fclose@plt>
movq   $0x0,0x2dab(%rip)
movq   $0x0,(%r15)
mov    0x30(%rsp),%al
test   %al,%al
mov    0x1c(%rsp),%r14d
je     1332 <parseopt+0x1b2>
cmp    $0x2d,%al
jne    12df <parseopt+0x15f>
mov    0x31(%rsp),%r12b
test   %r12b,%r12b
jne    12f5 <parseopt+0x175>
lea    0xd49(%rip),%rdi
mov    0x10(%rsp),%rsi
call   10a0 <fatal@plt>
mov    0x31(%rsp),%r12b
mov    0x32(%rsp),%al
test   %al,%al
je     13b6 <parseopt+0x236>
lea    0x32(%rsp),%rbp
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsbl %al,%edi
call   1070 <isspace@plt>
test   %rax,%rax
je     13a3 <parseopt+0x223>
movzbl 0x1(%rbp),%eax
add    $0x1,%rbp
test   %al,%al
jne    1310 <parseopt+0x190>
jmp    13b8 <parseopt+0x238>
cmp    %r14d,%ebp
jge    139e <parseopt+0x21e>
movslq %ebp,%rbx
mov    (%rsp),%rax
mov    (%rax,%rbx,8),%rax
test   %rax,%rax
je     139e <parseopt+0x21e>
cmpb   $0x2d,(%rax)
jne    139e <parseopt+0x21e>
mov    0x1(%rax),%r12b
test   %r12b,%r12b
je     148a <parseopt+0x30a>
movsbl %r12b,%esi
mov    0x28(%rsp),%rdi
call   1050 <strchr@plt>
test   %rax,%rax
je     148a <parseopt+0x30a>
mov    (%rsp),%rcx
mov    (%rcx,%rbx,8),%rcx
cmpb   $0x3a,0x1(%rax)
mov    0x2(%rcx),%al
jne    1441 <parseopt+0x2c1>
test   %al,%al
je     1456 <parseopt+0x2d6>
add    $0x2,%rcx
mov    0x8(%rsp),%rax
mov    %rcx,(%rax)
jmp    1451 <parseopt+0x2d1>
xor    %r12d,%r12d
jmp    1416 <parseopt+0x296>
cmpb   $0x0,0x0(%rbp)
je     13b6 <parseopt+0x236>
mov    %rbp,%rdi
call   1040 <sipStrdup@plt>
mov    %rax,%rbx
jmp    13b8 <parseopt+0x238>
xor    %ebx,%ebx
mov    0x8(%rsp),%rax
mov    %rbx,(%rax)
movsbl %r12b,%esi
mov    0x28(%rsp),%rdi
call   1050 <strchr@plt>
mov    %rax,%rbp
test   %rax,%rax
jne    13e7 <parseopt+0x267>
lea    0xc6f(%rip),%rdi
mov    0x10(%rsp),%rsi
call   10a0 <fatal@plt>
mov    0x1(%rbp),%al
cmp    $0x3a,%al
jne    13fc <parseopt+0x27c>
test   %rbx,%rbx
jne    13fc <parseopt+0x27c>
lea    0xc73(%rip),%rdi
jmp    140c <parseopt+0x28c>
cmp    $0x3a,%al
je     1416 <parseopt+0x296>
test   %rbx,%rbx
je     1416 <parseopt+0x296>
lea    0xc7e(%rip),%rdi
mov    0x10(%rsp),%rsi
call   10a0 <fatal@plt>
mov    %r12d,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x0(%r13),%eax
movb   $0x0,(%r14)
cmp    $0xa,%eax
je     12a6 <parseopt+0x126>
jmp    12c4 <parseopt+0x144>
test   %al,%al
jne    147a <parseopt+0x2fa>
mov    0x8(%rsp),%rax
movq   $0x0,(%rax)
add    $0x1,%ebp
jmp    1481 <parseopt+0x301>
lea    0x1(%rbp),%eax
cmp    %r14d,%eax
jge    147a <parseopt+0x2fa>
cltq
mov    (%rsp),%rcx
mov    (%rcx,%rax,8),%rax
test   %rax,%rax
je     147a <parseopt+0x2fa>
mov    0x8(%rsp),%rcx
mov    %rax,(%rcx)
add    $0x2,%ebp
jmp    1481 <parseopt+0x301>
xor    %eax,%eax
call   1080 <usage@plt>
mov    0x20(%rsp),%rax
mov    %ebp,(%rax)
jmp    1416 <parseopt+0x296>
xor    %eax,%eax
call   1080 <usage@plt>

LLVM IR (-O0):
@parseopt.fp = internal global i32* null
@.str = [2 x i8] c"r\00"
@.str.1 = [19 x i8] c"Unable to open %s\0A\00"
@EOF = global i32 0
@.str.2 = [26 x i8] c"A flag in %s is too long\0A\00"
@.str.3 = [29 x i8] c"An non-flag was given in %s\0A\00"
@.str.4 = [33 x i8] c"An invalid flag was given in %s\0A\00"
@.str.5 = [29 x i8] c"Missing flag argument in %s\0A\00"
@.str.6 = [32 x i8] c"Unexpected flag argument in %s\0A\00"
define signext i8 @parseopt(i32 %0, i8** %1, i8* %2, i8** %3, i32* %4, i8** %5) {
%7 = alloca i8
%8 = alloca i32
%9 = alloca i8**
%10 = alloca i8*
%11 = alloca i8**
%12 = alloca i32*
%13 = alloca i8**
%14 = alloca i8
%15 = alloca i8*
%16 = alloca i8*
%17 = alloca i32
%18 = alloca [200 x i8]
%19 = alloca i8*
%20 = alloca i8*
%21 = alloca i32
store i32 %0, i32* %8
store i8** %1, i8*** %9
store i8* %2, i8** %10
store i8** %3, i8*** %11
store i32* %4, i32** %12
store i8** %5, i8*** %13
%22 = load i32*, i32** %12
%23 = load i32, i32* %22
store i32 %23, i32* %17
%24 = load i8**, i8*** %11
%25 = load i8*, i8** %24
store i8* %25, i8** %16
%26 = load i8*, i8** %16
%27 = icmp eq i8* %26, null
br i1 %27, label %28, label %53
28: ; preds = %6
%29 = load i32, i32* %17
%30 = load i32, i32* %8
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %53
32: ; preds = %28
%33 = load i8**, i8*** %9
%34 = load i32, i32* %17
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i8*, i8** %33, i64 %35
%37 = load i8*, i8** %36
%38 = getelementptr inbounds i8, i8* %37, i64 0
%39 = load i8, i8* %38
%40 = sext i8 %39 to i32
%41 = icmp eq i32 %40, 64
br i1 %41, label %42, label %53
42: ; preds = %32
%43 = load i8**, i8*** %9
%44 = load i32, i32* %17
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i8*, i8** %43, i64 %45
%47 = load i8*, i8** %46
%48 = getelementptr inbounds i8, i8* %47, i64 1
%49 = load i8**, i8*** %11
store i8* %48, i8** %49
store i8* %48, i8** %16
%50 = load i32, i32* %17
%51 = add nsw i32 %50, 1
store i32 %51, i32* %17
%52 = load i32*, i32** %12
store i32 %51, i32* %52
br label %53
53: ; preds = %42, %32, %28, %6
%54 = load i8*, i8** %16
%55 = icmp ne i8* %54, null
br i1 %55, label %56, label %66
56: ; preds = %53
%57 = load i32*, i32** @parseopt.fp
%58 = icmp eq i32* %57, null
br i1 %58, label %59, label %66
59: ; preds = %56
%60 = load i8*, i8** %16
%61 = call i32* @fopen(i8* %60, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32* %61, i32** @parseopt.fp
%62 = icmp eq i32* %61, null
br i1 %62, label %63, label %66
63: ; preds = %59
%64 = load i8*, i8** %16
%65 = call i32 @fatal(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0), i8* %64)
br label %66
66: ; preds = %63, %59, %56, %53
%67 = load i32*, i32** @parseopt.fp
%68 = icmp ne i32* %67, null
br i1 %68, label %69, label %196
69: ; preds = %66
%70 = load i8**, i8*** %11
%71 = load i8*, i8** %70
store i8* %71, i8** %20
%72 = getelementptr inbounds [200 x i8], [200 x i8]* %18, i64 0, i64 0
store i8* %72, i8** %19
br label %73
73: ; preds = %99, %87, %69
%74 = load i32*, i32** @parseopt.fp
%75 = call i32 @fgetc(i32* %74)
store i32 %75, i32* %21
%76 = load i32, i32* @EOF
%77 = icmp ne i32 %75, %76
br i1 %77, label %78, label %104
78: ; preds = %73
%79 = load i8*, i8** %19
%80 = getelementptr inbounds [200 x i8], [200 x i8]* %18, i64 0, i64 0
%81 = icmp eq i8* %79, %80
br i1 %81, label %82, label %88
82: ; preds = %78
%83 = load i32, i32* %21
%84 = trunc i32 %83 to i8
%85 = call i64 @isspace(i8 signext %84)
%86 = icmp ne i64 %85, 0
br i1 %86, label %87, label %88
87: ; preds = %82
br label %73
88: ; preds = %82, %78
%89 = load i32, i32* %21
%90 = icmp eq i32 %89, 10
br i1 %90, label %91, label %92
91: ; preds = %88
br label %104
92: ; preds = %88
%93 = load i8*, i8** %19
%94 = getelementptr inbounds [200 x i8], [200 x i8]* %18, i64 0, i64 199
%95 = icmp eq i8* %93, %94
br i1 %95, label %96, label %99
96: ; preds = %92
%97 = load i8*, i8** %20
%98 = call i32 @fatal(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0), i8* %97)
br label %99
99: ; preds = %96, %92
%100 = load i32, i32* %21
%101 = trunc i32 %100 to i8
%102 = load i8*, i8** %19
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %19
store i8 %101, i8* %102
br label %73
104: ; preds = %91, %73
%105 = load i8*, i8** %19
store i8 0, i8* %105
%106 = load i32, i32* %21
%107 = load i32, i32* @EOF
%108 = icmp eq i32 %106, %107
br i1 %108, label %109, label %113
109: ; preds = %104
%110 = load i32*, i32** @parseopt.fp
%111 = call i32 @fclose(i32* %110)
store i32* null, i32** @parseopt.fp
%112 = load i8**, i8*** %11
store i8* null, i8** %112
br label %113
113: ; preds = %109, %104
%114 = getelementptr inbounds [200 x i8], [200 x i8]* %18, i64 0, i64 0
%115 = load i8, i8* %114
%116 = sext i8 %115 to i32
%117 = icmp ne i32 %116, 0
br i1 %117, label %118, label %195
118: ; preds = %113
%119 = getelementptr inbounds [200 x i8], [200 x i8]* %18, i64 0, i64 0
%120 = load i8, i8* %119
%121 = sext i8 %120 to i32
%122 = icmp ne i32 %121, 45
br i1 %122, label %128, label %123
123: ; preds = %118
%124 = getelementptr inbounds [200 x i8], [200 x i8]* %18, i64 0, i64 1
%125 = load i8, i8* %124
%126 = sext i8 %125 to i32
%127 = icmp eq i32 %126, 0
br i1 %127, label %128, label %131
128: ; preds = %123, %118
%129 = load i8*, i8** %20
%130 = call i32 @fatal(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i8* %129)
br label %131
131: ; preds = %128, %123
%132 = getelementptr inbounds [200 x i8], [200 x i8]* %18, i64 0, i64 1
%133 = load i8, i8* %132
store i8 %133, i8* %14
%134 = getelementptr inbounds [200 x i8], [200 x i8]* %18, i64 0, i64 2
store i8* %134, i8** %19
br label %135
135: ; preds = %147, %131
%136 = load i8*, i8** %19
%137 = load i8, i8* %136
%138 = sext i8 %137 to i32
%139 = icmp ne i32 %138, 0
br i1 %139, label %140, label %150
140: ; preds = %135
%141 = load i8*, i8** %19
%142 = load i8, i8* %141
%143 = call i64 @isspace(i8 signext %142)
%144 = icmp ne i64 %143, 0
br i1 %144, label %146, label %145
145: ; preds = %140
br label %150
146: ; preds = %140
br label %147
147: ; preds = %146
%148 = load i8*, i8** %19
%149 = getelementptr inbounds i8, i8* %148, i32 1
store i8* %149, i8** %19
br label %135
150: ; preds = %145, %135
%151 = load i8*, i8** %19
%152 = load i8, i8* %151
%153 = sext i8 %152 to i32
%154 = icmp eq i32 %153, 0
br i1 %154, label %155, label %156
155: ; preds = %150
store i8* null, i8** %19
br label %159
156: ; preds = %150
%157 = load i8*, i8** %19
%158 = call i8* @sipStrdup(i8* %157)
store i8* %158, i8** %19
br label %159
159: ; preds = %156, %155
%160 = load i8*, i8** %19
%161 = load i8**, i8*** %13
store i8* %160, i8** %161
%162 = load i8*, i8** %10
%163 = load i8, i8* %14
%164 = call i8* @strchr(i8* %162, i8 signext %163)
store i8* %164, i8** %15
%165 = icmp eq i8* %164, null
br i1 %165, label %166, label %169
166: ; preds = %159
%167 = load i8*, i8** %20
%168 = call i32 @fatal(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0), i8* %167)
br label %169
169: ; preds = %166, %159
%170 = load i8*, i8** %15
%171 = getelementptr inbounds i8, i8* %170, i64 1
%172 = load i8, i8* %171
%173 = sext i8 %172 to i32
%174 = icmp eq i32 %173, 58
br i1 %174, label %175, label %181
175: ; preds = %169
%176 = load i8*, i8** %19
%177 = icmp eq i8* %176, null
br i1 %177, label %178, label %181
178: ; preds = %175
%179 = load i8*, i8** %20
%180 = call i32 @fatal(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), i8* %179)
br label %181
181: ; preds = %178, %175, %169
%182 = load i8*, i8** %15
%183 = getelementptr inbounds i8, i8* %182, i64 1
%184 = load i8, i8* %183
%185 = sext i8 %184 to i32
%186 = icmp ne i32 %185, 58
br i1 %186, label %187, label %193
187: ; preds = %181
%188 = load i8*, i8** %19
%189 = icmp ne i8* %188, null
br i1 %189, label %190, label %193
190: ; preds = %187
%191 = load i8*, i8** %20
%192 = call i32 @fatal(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.6, i64 0, i64 0), i8* %191)
br label %193
193: ; preds = %190, %187, %181
%194 = load i8, i8* %14
store i8 %194, i8* %7
br label %310
195: ; preds = %113
br label %196
196: ; preds = %195, %66
%197 = load i32, i32* %17
%198 = load i32, i32* %8
%199 = icmp sge i32 %197, %198
br i1 %199, label %217, label %200
200: ; preds = %196
%201 = load i8**, i8*** %9
%202 = load i32, i32* %17
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i8*, i8** %201, i64 %203
%205 = load i8*, i8** %204
%206 = icmp eq i8* %205, null
br i1 %206, label %217, label %207
207: ; preds = %200
%208 = load i8**, i8*** %9
%209 = load i32, i32* %17
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i8*, i8** %208, i64 %210
%212 = load i8*, i8** %211
%213 = getelementptr inbounds i8, i8* %212, i64 0
%214 = load i8, i8* %213
%215 = sext i8 %214 to i32
%216 = icmp ne i32 %215, 45
br i1 %216, label %217, label %218
217: ; preds = %207, %200, %196
store i8 0, i8* %7
br label %310
218: ; preds = %207
%219 = load i8**, i8*** %9
%220 = load i32, i32* %17
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i8*, i8** %219, i64 %221
%223 = load i8*, i8** %222
%224 = getelementptr inbounds i8, i8* %223, i64 1
%225 = load i8, i8* %224
store i8 %225, i8* %14
%226 = load i8, i8* %14
%227 = sext i8 %226 to i32
%228 = icmp eq i32 %227, 0
br i1 %228, label %234, label %229
229: ; preds = %218
%230 = load i8*, i8** %10
%231 = load i8, i8* %14
%232 = call i8* @strchr(i8* %230, i8 signext %231)
store i8* %232, i8** %15
%233 = icmp eq i8* %232, null
br i1 %233, label %234, label %236
234: ; preds = %229, %218
%235 = call i32 (...) @usage()
br label %236
236: ; preds = %234, %229
%237 = load i8*, i8** %15
%238 = getelementptr inbounds i8, i8* %237, i64 1
%239 = load i8, i8* %238
%240 = sext i8 %239 to i32
%241 = icmp eq i32 %240, 58
br i1 %241, label %242, label %289
242: ; preds = %236
%243 = load i8**, i8*** %9
%244 = load i32, i32* %17
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds i8*, i8** %243, i64 %245
%247 = load i8*, i8** %246
%248 = getelementptr inbounds i8, i8* %247, i64 2
%249 = load i8, i8* %248
%250 = sext i8 %249 to i32
%251 = icmp ne i32 %250, 0
br i1 %251, label %252, label %262
252: ; preds = %242
%253 = load i8**, i8*** %9
%254 = load i32, i32* %17
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds i8*, i8** %253, i64 %255
%257 = load i8*, i8** %256
%258 = getelementptr inbounds i8, i8* %257, i64 2
%259 = load i8**, i8*** %13
store i8* %258, i8** %259
%260 = load i32, i32* %17
%261 = add nsw i32 %260, 1
store i32 %261, i32* %17
br label %288
262: ; preds = %242
%263 = load i32, i32* %17
%264 = add nsw i32 %263, 1
%265 = load i32, i32* %8
%266 = icmp sge i32 %264, %265
br i1 %266, label %275, label %267
267: ; preds = %262
%268 = load i8**, i8*** %9
%269 = load i32, i32* %17
%270 = add nsw i32 %269, 1
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i8*, i8** %268, i64 %271
%273 = load i8*, i8** %272
%274 = icmp eq i8* %273, null
br i1 %274, label %275, label %277
275: ; preds = %267, %262
%276 = call i32 (...) @usage()
br label %287
277: ; preds = %267
%278 = load i8**, i8*** %9
%279 = load i32, i32* %17
%280 = add nsw i32 %279, 1
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds i8*, i8** %278, i64 %281
%283 = load i8*, i8** %282
%284 = load i8**, i8*** %13
store i8* %283, i8** %284
%285 = load i32, i32* %17
%286 = add nsw i32 %285, 2
store i32 %286, i32* %17
br label %287
287: ; preds = %277, %275
br label %288
288: ; preds = %287, %252
br label %306
289: ; preds = %236
%290 = load i8**, i8*** %9
%291 = load i32, i32* %17
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i8*, i8** %290, i64 %292
%294 = load i8*, i8** %293
%295 = getelementptr inbounds i8, i8* %294, i64 2
%296 = load i8, i8* %295
%297 = sext i8 %296 to i32
%298 = icmp ne i32 %297, 0
br i1 %298, label %299, label %301
299: ; preds = %289
%300 = call i32 (...) @usage()
br label %305
301: ; preds = %289
%302 = load i8**, i8*** %13
store i8* null, i8** %302
%303 = load i32, i32* %17
%304 = add nsw i32 %303, 1
store i32 %304, i32* %17
br label %305
305: ; preds = %301, %299
br label %306
306: ; preds = %305, %288
%307 = load i32, i32* %17
%308 = load i32*, i32** %12
store i32 %307, i32* %308
%309 = load i8, i8* %14
store i8 %309, i8* %7
br label %310
310: ; preds = %306, %217, %193
%311 = load i8, i8* %7
ret i8 %311
}

LLVM IR (-O2):
@parseopt.fp = internal unnamed_addr global i32* null
@.str = [2 x i8] c"r\00"
@.str.1 = [19 x i8] c"Unable to open %s\0A\00"
@EOF = global i32 0
@.str.2 = [26 x i8] c"A flag in %s is too long\0A\00"
@.str.3 = [29 x i8] c"An non-flag was given in %s\0A\00"
@.str.4 = [33 x i8] c"An invalid flag was given in %s\0A\00"
@.str.5 = [29 x i8] c"Missing flag argument in %s\0A\00"
@.str.6 = [32 x i8] c"Unexpected flag argument in %s\0A\00"
define signext i8 @parseopt(i32 %0, i8** nocapture %1, i8* %2, i8** nocapture %3, i32* nocapture %4, i8** nocapture writeonly %5) {
%7 = alloca [200 x i8]
%8 = load i32, i32* %4
%9 = load i8*, i8** %3
%10 = icmp eq i8* %9, null
br i1 %10, label %11, label %22
11: ; preds = %6
%12 = icmp slt i32 %8, %0
br i1 %12, label %13, label %32
13: ; preds = %11
%14 = sext i32 %8 to i64
%15 = getelementptr inbounds i8*, i8** %1, i64 %14
%16 = load i8*, i8** %15
%17 = load i8, i8* %16
%18 = icmp eq i8 %17, 64
br i1 %18, label %19, label %32
19: ; preds = %13
%20 = getelementptr inbounds i8, i8* %16, i64 1
store i8* %20, i8** %3
%21 = add nsw i32 %8, 1
store i32 %21, i32* %4
br label %22
22: ; preds = %19, %6
%23 = phi i8* [ %20, %19 ], [ %9, %6 ]
%24 = phi i32 [ %21, %19 ], [ %8, %6 ]
%25 = load i32*, i32** @parseopt.fp
%26 = icmp eq i32* %25, null
br i1 %26, label %27, label %36
27: ; preds = %22
%28 = tail call i32* @fopen(i8* %23, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32* %28, i32** @parseopt.fp
%29 = icmp eq i32* %28, null
br i1 %29, label %30, label %36
30: ; preds = %27
%31 = tail call i32 @fatal(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0), i8* %23)
br label %32
32: ; preds = %30, %13, %11
%33 = phi i32 [ %24, %30 ], [ %8, %13 ], [ %8, %11 ]
%34 = load i32*, i32** @parseopt.fp
%35 = icmp eq i32* %34, null
br i1 %35, label %122, label %36
36: ; preds = %22, %27, %32
%37 = phi i32 [ %33, %32 ], [ %24, %27 ], [ %24, %22 ]
%38 = getelementptr inbounds [200 x i8], [200 x i8]* %7, i64 0, i64 0
%39 = load i8*, i8** %3
%40 = getelementptr inbounds [200 x i8], [200 x i8]* %7, i64 0, i64 199
br label %41
41: ; preds = %61, %36
%42 = phi i8* [ %63, %61 ], [ %38, %36 ]
%43 = icmp eq i8* %42, %38
br label %44
44: ; preds = %41, %51
%45 = load i32*, i32** @parseopt.fp
%46 = call i32 @fgetc(i32* %45)
%47 = load i32, i32* @EOF
%48 = icmp eq i32 %46, %47
br i1 %48, label %49, label %50
49: ; preds = %44
store i8 0, i8* %42
br label %67
50: ; preds = %44
br i1 %43, label %51, label %55
51: ; preds = %50
%52 = trunc i32 %46 to i8
%53 = call i64 @isspace(i8 signext %52)
%54 = icmp eq i64 %53, 0
br i1 %54, label %55, label %44
55: ; preds = %51, %50
%56 = icmp eq i32 %46, 10
br i1 %56, label %64, label %57
57: ; preds = %55
%58 = icmp eq i8* %42, %40
br i1 %58, label %59, label %61
59: ; preds = %57
%60 = call i32 @fatal(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0), i8* %39)
br label %61
61: ; preds = %59, %57
%62 = trunc i32 %46 to i8
%63 = getelementptr inbounds i8, i8* %42, i64 1
store i8 %62, i8* %42
br label %41
64: ; preds = %55
%65 = load i32, i32* @EOF
store i8 0, i8* %42
%66 = icmp eq i32 %65, 10
br i1 %66, label %67, label %70
67: ; preds = %49, %64
%68 = load i32*, i32** @parseopt.fp
%69 = call i32 @fclose(i32* %68)
store i32* null, i32** @parseopt.fp
store i8* null, i8** %3
br label %70
70: ; preds = %67, %64
%71 = load i8, i8* %38
%72 = icmp eq i8 %71, 0
br i1 %72, label %73, label %74
73: ; preds = %70
br label %122
74: ; preds = %70
%75 = icmp ne i8 %71, 45
%76 = getelementptr inbounds [200 x i8], [200 x i8]* %7, i64 0, i64 1
%77 = load i8, i8* %76
%78 = icmp eq i8 %77, 0
%79 = select i1 %75, i1 true, i1 %78
br i1 %79, label %80, label %83
80: ; preds = %74
%81 = call i32 @fatal(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.3, i64 0, i64 0), i8* %39)
%82 = load i8, i8* %76
br label %83
83: ; preds = %74, %80
%84 = phi i8 [ %77, %74 ], [ %82, %80 ]
%85 = getelementptr inbounds [200 x i8], [200 x i8]* %7, i64 0, i64 2
%86 = load i8, i8* %85
%87 = icmp eq i8 %86, 0
br i1 %87, label %102, label %88
88: ; preds = %83, %93
%89 = phi i8 [ %95, %93 ], [ %86, %83 ]
%90 = phi i8* [ %94, %93 ], [ %85, %83 ]
%91 = call i64 @isspace(i8 signext %89)
%92 = icmp eq i64 %91, 0
br i1 %92, label %97, label %93
93: ; preds = %88
%94 = getelementptr inbounds i8, i8* %90, i64 1
%95 = load i8, i8* %94
%96 = icmp eq i8 %95, 0
br i1 %96, label %102, label %88
97: ; preds = %88
%98 = load i8, i8* %90
%99 = icmp eq i8 %98, 0
br i1 %99, label %102, label %100
100: ; preds = %97
%101 = call i8* @sipStrdup(i8* %90)
br label %102
102: ; preds = %93, %83, %97, %100
%103 = phi i8* [ %101, %100 ], [ null, %97 ], [ null, %83 ], [ null, %93 ]
store i8* %103, i8** %5
%104 = call i8* @strchr(i8* dereferenceable(1) %2, i8 signext %84)
%105 = icmp eq i8* %104, null
br i1 %105, label %106, label %108
106: ; preds = %102
%107 = call i32 @fatal(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0), i8* %39)
br label %108
108: ; preds = %106, %102
%109 = getelementptr inbounds i8, i8* %104, i64 1
%110 = load i8, i8* %109
%111 = icmp eq i8 %110, 58
%112 = icmp eq i8* %103, null
%113 = select i1 %111, i1 %112, i1 false
br i1 %113, label %118, label %114
114: ; preds = %108
%115 = icmp ne i8 %110, 58
%116 = icmp ne i8* %103, null
%117 = select i1 %115, i1 %116, i1 false
br i1 %117, label %118, label %121
118: ; preds = %114, %108
%119 = phi i8* [ getelementptr inbounds ([29 x i8], [29 x i8]* @.str.5, i64 0, i64 0), %108 ], [ getelementptr inbounds ([32 x i8], [32 x i8]* @.str.6, i64 0, i64 0), %114 ]
%120 = call i32 @fatal(i8* %119, i8* %39)
br label %121
121: ; preds = %118, %114
br label %172
122: ; preds = %73, %32
%123 = phi i32 [ %33, %32 ], [ %37, %73 ]
%124 = icmp slt i32 %123, %0
br i1 %124, label %125, label %172
125: ; preds = %122
%126 = sext i32 %123 to i64
%127 = getelementptr inbounds i8*, i8** %1, i64 %126
%128 = load i8*, i8** %127
%129 = icmp eq i8* %128, null
br i1 %129, label %172, label %130
130: ; preds = %125
%131 = load i8, i8* %128
%132 = icmp eq i8 %131, 45
br i1 %132, label %133, label %172
133: ; preds = %130
%134 = getelementptr inbounds i8, i8* %128, i64 1
%135 = load i8, i8* %134
%136 = icmp eq i8 %135, 0
br i1 %136, label %140, label %137
137: ; preds = %133
%138 = call i8* @strchr(i8* dereferenceable(1) %2, i8 signext %135)
%139 = icmp eq i8* %138, null
br i1 %139, label %140, label %142
140: ; preds = %137, %133
%141 = call i32 (...) @usage()
unreachable
142: ; preds = %137
%143 = getelementptr inbounds i8, i8* %138, i64 1
%144 = load i8, i8* %143
%145 = icmp eq i8 %144, 58
%146 = load i8*, i8** %127
%147 = getelementptr inbounds i8, i8* %146, i64 2
%148 = load i8, i8* %147
%149 = icmp eq i8 %148, 0
br i1 %145, label %150, label %165
150: ; preds = %142
br i1 %149, label %153, label %151
151: ; preds = %150
store i8* %147, i8** %5
%152 = add nsw i32 %123, 1
br label %170
153: ; preds = %150
%154 = add nsw i32 %123, 1
%155 = icmp slt i32 %154, %0
br i1 %155, label %156, label %161
156: ; preds = %153
%157 = sext i32 %154 to i64
%158 = getelementptr inbounds i8*, i8** %1, i64 %157
%159 = load i8*, i8** %158
%160 = icmp eq i8* %159, null
br i1 %160, label %161, label %163
161: ; preds = %156, %153
%162 = call i32 (...) @usage()
br label %170
163: ; preds = %156
store i8* %159, i8** %5
%164 = add nsw i32 %123, 2
br label %170
165: ; preds = %142
br i1 %149, label %168, label %166
166: ; preds = %165
%167 = call i32 (...) @usage()
br label %170
168: ; preds = %165
store i8* null, i8** %5
%169 = add nsw i32 %123, 1
br label %170
170: ; preds = %166, %168, %151, %163, %161
%171 = phi i32 [ %152, %151 ], [ %123, %161 ], [ %164, %163 ], [ %123, %166 ], [ %169, %168 ]
store i32 %171, i32* %4
br label %172
172: ; preds = %121, %122, %125, %130, %170
%173 = phi i8 [ %135, %170 ], [ %84, %121 ], [ 0, %130 ], [ 0, %125 ], [ 0, %122 ]
ret i8 %173
}