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

/* Variables and functions */
int /*<<< orphan*/ rs_error(int /*<<< orphan*/ *, int /*<<< orphan*/ *, char *,
                            ...);
int /*<<< orphan*/ strcasecmp(char *, char *);
char *strchr(char const *, char);
int rs_parse_cmdline(int argc, char **argv, const char *optstring, int *i,
                     int *j, const char **arg) {
  char c;
  char *p;
  if (*i >= argc)
    return 0;
  if (argv[*i][0] != '-' || argv[*i][1] == 0) {
    *arg = argv[*i];
    (*i)++;
    *j = 1;
    return '#';
  }
  if (argv[*i][1] == '-') {
    if (!strcasecmp(argv[*i], "--help")) {
      (*i)++;
      *j = 1;
      return '!';
    } else if (!strcasecmp(argv[*i], "--version")) {
      (*i)++;
      *j = 1;
      return '@';
    } else {
      rs_error(NULL, NULL, "unrecognized option %s (try --help)", argv[*i]);
      return '?';
    }
  }
  c = argv[*i][*j];
  if (c == ':' || !(p = strchr(optstring, c))) {
    rs_error(NULL, NULL, "unrecognized option -%c (try --help)", c);
    return '?';
  }
  if (p[1] == ':') {
    if (argv[*i][*j + 1]) {
      *arg = &argv[*i][*j + 1];
      (*i)++;
      *j = 1;
      return c;
    } else {
      (*i) += 2;
      *j = 1;
      if (*i > argc) {
        rs_error(NULL, NULL, "-%c: requires an argument", c);
        return '?';
      }
      *arg = argv[*i - 1];
      return c;
    }
  } else {
    if (argv[*i][*j + 1]) {
      (*j)++;
    } else {
      (*i)++;
      *j = 1;
    }
    *arg = NULL;
    return c;
  }
}


x86 assembly (clang, -O0):
<rs_parse_cmdline>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%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    -0x20(%rbp),%rax
mov    (%rax),%eax
cmp    -0x8(%rbp),%eax
jl     116a <rs_parse_cmdline+0x3a>
movl   $0x0,-0x4(%rbp)
jmp    145e <rs_parse_cmdline+0x32e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    11a1 <rs_parse_cmdline+0x71>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
jne    11d8 <rs_parse_cmdline+0xa8>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x23,-0x4(%rbp)
jmp    145e <rs_parse_cmdline+0x32e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2d,%eax
jne    12ae <rs_parse_cmdline+0x17e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xdf6(%rip),%rsi
call   1030 <strcasecmp@plt>
cmp    $0x0,%eax
jne    1239 <rs_parse_cmdline+0x109>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x21,-0x4(%rbp)
jmp    145e <rs_parse_cmdline+0x32e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xdb8(%rip),%rsi
call   1030 <strcasecmp@plt>
cmp    $0x0,%eax
jne    127e <rs_parse_cmdline+0x14e>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x40,-0x4(%rbp)
jmp    145e <rs_parse_cmdline+0x32e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rcx
xor    %eax,%eax
mov    %eax,%esi
lea    0xd79(%rip),%rdx
mov    %rsi,%rdi
mov    $0x0,%al
call   1050 <rs_error@plt>
movl   $0x3f,-0x4(%rbp)
jmp    145e <rs_parse_cmdline+0x32e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x31(%rbp)
movsbl -0x31(%rbp),%eax
cmp    $0x3a,%eax
je     12f2 <rs_parse_cmdline+0x1c2>
mov    -0x18(%rbp),%rdi
movsbl -0x31(%rbp),%esi
call   1040 <strchr@plt>
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jne    1317 <rs_parse_cmdline+0x1e7>
movsbl -0x31(%rbp),%ecx
xor    %eax,%eax
mov    %eax,%esi
lea    0xd34(%rip),%rdx
mov    %rsi,%rdi
mov    $0x0,%al
call   1050 <rs_error@plt>
movl   $0x3f,-0x4(%rbp)
jmp    145e <rs_parse_cmdline+0x32e>
mov    -0x40(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3a,%eax
jne    1402 <rs_parse_cmdline+0x2d2>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     1392 <rs_parse_cmdline+0x262>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
add    $0x1,%eax
cltq
add    %rax,%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
movsbl -0x31(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    145e <rs_parse_cmdline+0x32e>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x2,%ecx
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
cmp    -0x8(%rbp),%eax
jle    13db <rs_parse_cmdline+0x2ab>
movsbl -0x31(%rbp),%ecx
xor    %eax,%eax
mov    %eax,%esi
lea    0xc95(%rip),%rdx
mov    %rsi,%rdi
mov    $0x0,%al
call   1050 <rs_error@plt>
movl   $0x3f,-0x4(%rbp)
jmp    145e <rs_parse_cmdline+0x32e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
movsbl -0x31(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    145e <rs_parse_cmdline+0x32e>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%rcx
mov    (%rcx),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpb   $0x0,(%rax,%rcx,1)
je     1437 <rs_parse_cmdline+0x307>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    144c <rs_parse_cmdline+0x31c>
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x30(%rbp),%rax
movq   $0x0,(%rax)
movsbl -0x31(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rs_parse_cmdline>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
movslq (%rcx),%r15
xor    %ebp,%ebp
cmp    %edi,%r15d
jge    1179 <rs_parse_cmdline+0x49>
mov    %rcx,%r12
mov    %rsi,%r13
mov    (%rsi,%r15,8),%rbx
cmpb   $0x2d,(%rbx)
jne    1162 <rs_parse_cmdline+0x32>
mov    0x1(%rbx),%al
cmp    $0x2d,%al
je     118a <rs_parse_cmdline+0x5a>
test   %al,%al
jne    11d7 <rs_parse_cmdline+0xa7>
mov    %rbx,(%r9)
add    $0x1,%r15d
mov    %r15d,(%r12)
movl   $0x1,(%r8)
mov    $0x23,%ebp
mov    %ebp,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8,%rbp
lea    0xe6c(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcasecmp@plt>
test   %eax,%eax
je     125b <rs_parse_cmdline+0x12b>
lea    0xe5c(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcasecmp@plt>
test   %eax,%eax
je     1274 <rs_parse_cmdline+0x144>
lea    0xe4f(%rip),%rdx
xor    %edi,%edi
xor    %esi,%esi
mov    %rbx,%rcx
xor    %eax,%eax
call   1050 <rs_error@plt>
mov    $0x3f,%ebp
jmp    1179 <rs_parse_cmdline+0x49>
movslq (%r8),%rax
movsbl (%rbx,%rax,1),%ebp
cmp    $0x3a,%ebp
je     123d <rs_parse_cmdline+0x10d>
mov    %edi,%r14d
mov    %rdx,%rdi
mov    %rax,(%rsp)
mov    %ebp,%esi
mov    %r8,0x10(%rsp)
mov    %r9,0x8(%rsp)
call   1040 <strchr@plt>
mov    (%rsp),%rsi
mov    0x8(%rsp),%rdx
mov    0x10(%rsp),%rcx
test   %rax,%rax
je     123d <rs_parse_cmdline+0x10d>
cmpb   $0x3a,0x1(%rax)
mov    0x1(%rbx,%rsi,1),%al
jne    128d <rs_parse_cmdline+0x15d>
test   %al,%al
je     1297 <rs_parse_cmdline+0x167>
lea    (%rbx,%rsi,1),%rax
add    $0x1,%rax
mov    %rax,(%rdx)
add    $0x1,%r15d
mov    %r15d,(%r12)
movl   $0x1,(%rcx)
jmp    1179 <rs_parse_cmdline+0x49>
lea    0xdf1(%rip),%rdx
xor    %edi,%edi
xor    %esi,%esi
mov    %ebp,%ecx
xor    %eax,%eax
call   1050 <rs_error@plt>
mov    $0x3f,%ebp
jmp    1179 <rs_parse_cmdline+0x49>
add    $0x1,%r15d
mov    %r15d,(%r12)
movl   $0x1,0x0(%rbp)
mov    $0x21,%ebp
jmp    1179 <rs_parse_cmdline+0x49>
add    $0x1,%r15d
mov    %r15d,(%r12)
movl   $0x1,0x0(%rbp)
mov    $0x40,%ebp
jmp    1179 <rs_parse_cmdline+0x49>
test   %al,%al
je     12b7 <rs_parse_cmdline+0x187>
add    $0x1,%rsi
jmp    12c4 <rs_parse_cmdline+0x194>
add    $0x2,%r15d
mov    %r15d,(%r12)
movl   $0x1,(%rcx)
movslq (%r12),%rax
cmp    %r14d,%eax
jle    12d2 <rs_parse_cmdline+0x1a2>
lea    0xda5(%rip),%rdx
jmp    1244 <rs_parse_cmdline+0x114>
add    $0x1,%r15d
mov    %r15d,(%r12)
mov    $0x1,%esi
mov    %esi,(%rcx)
movq   $0x0,(%rdx)
jmp    1179 <rs_parse_cmdline+0x49>
mov    -0x8(%r13,%rax,8),%rax
mov    %rax,(%rdx)
jmp    1179 <rs_parse_cmdline+0x49>

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

LLVM IR (-O2):
@.str = [7 x i8] c"--help\00"
@.str.1 = [10 x i8] c"--version\00"
@.str.2 = [36 x i8] c"unrecognized option %s (try --help)\00"
@.str.3 = [37 x i8] c"unrecognized option -%c (try --help)\00"
@.str.4 = [26 x i8] c"-%c: requires an argument\00"
define i32 @rs_parse_cmdline(i32 %0, i8** nocapture %1, i8* %2, i32* nocapture %3, i32* nocapture %4, i8** nocapture writeonly %5) {
%7 = load i32, i32* %3
%8 = icmp slt i32 %7, %0
br i1 %8, label %9, label %72
9: ; preds = %6
%10 = sext i32 %7 to i64
%11 = getelementptr inbounds i8*, i8** %1, i64 %10
%12 = load i8*, i8** %11
%13 = load i8, i8* %12
%14 = icmp eq i8 %13, 45
br i1 %14, label %15, label %18
15: ; preds = %9
%16 = getelementptr inbounds i8, i8* %12, i64 1
%17 = load i8, i8* %16
switch i8 %17, label %32 [
i8 0, label %18
i8 45, label %20
]
18: ; preds = %15, %9
store i8* %12, i8** %5
%19 = add nsw i32 %7, 1
store i32 %19, i32* %3
store i32 1, i32* %4
br label %72
20: ; preds = %15
%21 = tail call i32 @strcasecmp(i8* %12, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0))
%22 = icmp eq i32 %21, 0
br i1 %22, label %23, label %25
23: ; preds = %20
%24 = add nsw i32 %7, 1
store i32 %24, i32* %3
store i32 1, i32* %4
br label %72
25: ; preds = %20
%26 = tail call i32 @strcasecmp(i8* %12, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
%27 = icmp eq i32 %26, 0
br i1 %27, label %28, label %30
28: ; preds = %25
%29 = add nsw i32 %7, 1
store i32 %29, i32* %3
store i32 1, i32* %4
br label %72
30: ; preds = %25
%31 = tail call i32 (i32*, i32*, i8*, ...) @rs_error(i32* null, i32* null, i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0), i8* %12)
br label %72
32: ; preds = %15
%33 = load i32, i32* %4
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i8, i8* %12, i64 %34
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = icmp eq i8 %36, 58
br i1 %38, label %42, label %39
39: ; preds = %32
%40 = tail call i8* @strchr(i8* dereferenceable(1) %2, i8 signext %36)
%41 = icmp eq i8* %40, null
br i1 %41, label %42, label %44
42: ; preds = %39, %32
%43 = tail call i32 (i32*, i32*, i8*, ...) @rs_error(i32* null, i32* null, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.3, i64 0, i64 0), i32 %37)
br label %72
44: ; preds = %39
%45 = getelementptr inbounds i8, i8* %40, i64 1
%46 = load i8, i8* %45
%47 = icmp eq i8 %46, 58
%48 = add nsw i32 %33, 1
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %12, i64 %49
%51 = load i8, i8* %50
%52 = icmp eq i8 %51, 0
br i1 %47, label %53, label %67
53: ; preds = %44
br i1 %52, label %56, label %54
54: ; preds = %53
store i8* %50, i8** %5
%55 = add nsw i32 %7, 1
store i32 %55, i32* %3
store i32 1, i32* %4
br label %72
56: ; preds = %53
%57 = add nsw i32 %7, 2
store i32 %57, i32* %3
store i32 1, i32* %4
%58 = load i32, i32* %3
%59 = icmp sgt i32 %58, %0
br i1 %59, label %60, label %62
60: ; preds = %56
%61 = tail call i32 (i32*, i32*, i8*, ...) @rs_error(i32* null, i32* null, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.4, i64 0, i64 0), i32 %37)
br label %72
62: ; preds = %56
%63 = add nsw i32 %58, -1
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8*, i8** %1, i64 %64
%66 = load i8*, i8** %65
store i8* %66, i8** %5
br label %72
67: ; preds = %44
br i1 %52, label %68, label %70
68: ; preds = %67
%69 = add nsw i32 %7, 1
store i32 %69, i32* %3
br label %70
70: ; preds = %67, %68
%71 = phi i32 [ 1, %68 ], [ %48, %67 ]
store i32 %71, i32* %4
store i8* null, i8** %5
br label %72
72: ; preds = %6, %70, %62, %60, %54, %42, %30, %28, %23, %18
%73 = phi i32 [ 35, %18 ], [ 63, %30 ], [ 64, %28 ], [ 33, %23 ], [ 63, %42 ], [ %37, %54 ], [ 63, %60 ], [ %37, %62 ], [ %37, %70 ], [ 0, %6 ]
ret i32 %73
}