#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 atoi(char *);
int ParseArgument(int numargs, char **arglist, char *optionchars, int parse) {
  int i;
  char uc[2], lc[2];
  for (i = 0; i < 2; i++) {
    if (optionchars[i] == '\0') {
      uc[i] = '\0';
      lc[i] = '\0';
      continue;
    }
    if ((((int)optionchars[i]) >= 65) && (((int)optionchars[i]) <= 90)) {
      uc[i] = optionchars[i];
      lc[i] = (char)(optionchars[i] + 32);
    } else {
      uc[i] = (char)(optionchars[i] - 32);
      lc[i] = optionchars[i];
    }
  }
  for (i = 1; i < numargs; i++) {
    if (arglist[i][0] == '-' &&
        (arglist[i][1] == lc[0] || arglist[i][1] == uc[0]) &&
        (arglist[i][2] == lc[1] || arglist[i][2] == uc[1])) {
      if (parse) {
        if (i == (numargs - 1))
          return (-1);
        if (parse == 1)
          return atoi(arglist[(i + 1)]);
        else
          return (i + 1);
      }
      return 1;
    }
  }
  if (parse)
    return (-1);
  return 0;
}


x86 assembly (clang, -O0):
<ParseArgument>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x2,-0x20(%rbp)
jge    11fd <ParseArgument+0xed>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1163 <ParseArgument+0x53>
movslq -0x20(%rbp),%rax
movb   $0x0,-0x22(%rbp,%rax,1)
movslq -0x20(%rbp),%rax
movb   $0x0,-0x24(%rbp,%rax,1)
jmp    11ef <ParseArgument+0xdf>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
jl     11be <ParseArgument+0xae>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5a,%eax
jg     11be <ParseArgument+0xae>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x22(%rbp,%rax,1)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0x20,%eax
mov    %al,%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x24(%rbp,%rax,1)
jmp    11ea <ParseArgument+0xda>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x20,%eax
mov    %al,%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x22(%rbp,%rax,1)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x24(%rbp,%rax,1)
jmp    11ef <ParseArgument+0xdf>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    112d <ParseArgument+0x1d>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1314 <ParseArgument+0x204>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    1301 <ParseArgument+0x1f1>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
movsbl -0x24(%rbp),%ecx
cmp    %ecx,%eax
je     1260 <ParseArgument+0x150>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x1(%rax),%eax
movsbl -0x22(%rbp),%ecx
cmp    %ecx,%eax
jne    1301 <ParseArgument+0x1f1>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x2(%rax),%eax
movsbl -0x23(%rbp),%ecx
cmp    %ecx,%eax
je     1298 <ParseArgument+0x188>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl 0x2(%rax),%eax
movsbl -0x21(%rbp),%ecx
cmp    %ecx,%eax
jne    1301 <ParseArgument+0x1f1>
cmpl   $0x0,-0x1c(%rbp)
je     12f5 <ParseArgument+0x1e5>
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    12bf <ParseArgument+0x1af>
movl   $0xffffffff,-0x4(%rbp)
jmp    1331 <ParseArgument+0x221>
cmpl   $0x1,-0x1c(%rbp)
jne    12e7 <ParseArgument+0x1d7>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <atoi@plt>
mov    %eax,-0x4(%rbp)
jmp    1331 <ParseArgument+0x221>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4(%rbp)
jmp    1331 <ParseArgument+0x221>
movl   $0x1,-0x4(%rbp)
jmp    1331 <ParseArgument+0x221>
jmp    1306 <ParseArgument+0x1f6>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1204 <ParseArgument+0xf4>
cmpl   $0x0,-0x1c(%rbp)
je     132a <ParseArgument+0x21a>
movl   $0xffffffff,-0x4(%rbp)
jmp    1331 <ParseArgument+0x221>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ParseArgument>:
push   %r14
push   %rbx
mov    (%rdx),%r8b
test   %r8b,%r8b
je     112f <ParseArgument+0x1f>
lea    -0x41(%r8),%eax
cmp    $0x19,%al
ja     1137 <ParseArgument+0x27>
mov    %r8d,%r9d
lea    0x20(%r8),%eax
mov    %eax,%r8d
jmp    113b <ParseArgument+0x2b>
xor    %r9d,%r9d
xor    %r8d,%r8d
jmp    113b <ParseArgument+0x2b>
lea    -0x20(%r8),%r9d
mov    0x1(%rdx),%r11b
test   %r11b,%r11b
je     1160 <ParseArgument+0x50>
lea    -0x41(%r11),%eax
cmp    $0x1a,%al
jae    116d <ParseArgument+0x5d>
mov    %r11d,%r10d
lea    0x20(%r11),%eax
mov    %eax,%r11d
cmp    $0x1,%edi
jg     1176 <ParseArgument+0x66>
jmp    11e1 <ParseArgument+0xd1>
xor    %r10d,%r10d
xor    %r11d,%r11d
cmp    $0x1,%edi
jg     1176 <ParseArgument+0x66>
jmp    11e1 <ParseArgument+0xd1>
lea    -0x20(%r11),%r10d
cmp    $0x1,%edi
jle    11e1 <ParseArgument+0xd1>
mov    %edi,%eax
mov    $0x1,%r14d
sub    %rax,%r14
mov    $0x2,%eax
jmp    11a2 <ParseArgument+0x92>
nopl   0x0(%rax,%rax,1)
lea    (%r14,%rax,1),%rdx
add    $0x1,%rdx
add    $0x1,%rax
cmp    $0x2,%rdx
je     11e1 <ParseArgument+0xd1>
mov    -0x8(%rsi,%rax,8),%rbx
cmpb   $0x2d,(%rbx)
jne    1190 <ParseArgument+0x80>
movzbl 0x1(%rbx),%edx
cmp    %r8b,%dl
je     11ba <ParseArgument+0xaa>
cmp    %r9b,%dl
jne    1190 <ParseArgument+0x80>
movzbl 0x2(%rbx),%edx
cmp    %r11b,%dl
je     11c8 <ParseArgument+0xb8>
cmp    %r10b,%dl
jne    1190 <ParseArgument+0x80>
test   %ecx,%ecx
je     11e9 <ParseArgument+0xd9>
cmp    %edi,%eax
je     11f0 <ParseArgument+0xe0>
cmp    $0x1,%ecx
jne    11e5 <ParseArgument+0xd5>
mov    (%rsi,%rax,8),%rdi
pop    %rbx
pop    %r14
jmp    1030 <atoi@plt>
neg    %ecx
sbb    %eax,%eax
pop    %rbx
pop    %r14
ret
mov    $0x1,%eax
jmp    11e5 <ParseArgument+0xd5>
mov    $0xffffffff,%eax
jmp    11e5 <ParseArgument+0xd5>

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

LLVM IR (-O2):
define i32 @ParseArgument(i32 %0, i8** nocapture %1, i8* nocapture %2, i32 %3) {
%5 = load i8, i8* %2
%6 = icmp eq i8 %5, 0
br i1 %6, label %16, label %9
7: ; preds = %29
%8 = zext i32 %0 to i64
br label %33
9: ; preds = %4
%10 = add i8 %5, -65
%11 = icmp ult i8 %10, 26
br i1 %11, label %12, label %14
12: ; preds = %9
%13 = add nuw nsw i8 %5, 32
br label %16
14: ; preds = %9
%15 = add i8 %5, -32
br label %16
16: ; preds = %4, %12, %14
%17 = phi i8 [ %5, %12 ], [ %15, %14 ], [ 0, %4 ]
%18 = phi i8 [ %13, %12 ], [ %5, %14 ], [ 0, %4 ]
%19 = getelementptr inbounds i8, i8* %2, i64 1
%20 = load i8, i8* %19
%21 = icmp eq i8 %20, 0
br i1 %21, label %29, label %22
22: ; preds = %16
%23 = add i8 %20, -65
%24 = icmp ult i8 %23, 26
br i1 %24, label %27, label %25
25: ; preds = %22
%26 = add i8 %20, -32
br label %29
27: ; preds = %22
%28 = add nuw nsw i8 %20, 32
br label %29
29: ; preds = %16, %27, %25
%30 = phi i8 [ %20, %27 ], [ %26, %25 ], [ 0, %16 ]
%31 = phi i8 [ %28, %27 ], [ %20, %25 ], [ 0, %16 ]
%32 = icmp sgt i32 %0, 1
br i1 %32, label %7, label %70
33: ; preds = %7, %67
%34 = phi i64 [ 1, %7 ], [ %68, %67 ]
%35 = getelementptr inbounds i8*, i8** %1, i64 %34
%36 = load i8*, i8** %35
%37 = load i8, i8* %36
%38 = icmp eq i8 %37, 45
br i1 %38, label %39, label %67
39: ; preds = %33
%40 = getelementptr inbounds i8, i8* %36, i64 1
%41 = load i8, i8* %40
%42 = icmp eq i8 %41, %18
%43 = icmp eq i8 %41, %17
%44 = select i1 %42, i1 true, i1 %43
br i1 %44, label %45, label %67
45: ; preds = %39
%46 = getelementptr inbounds i8, i8* %36, i64 2
%47 = load i8, i8* %46
%48 = icmp eq i8 %47, %31
%49 = icmp eq i8 %47, %30
%50 = select i1 %48, i1 true, i1 %49
br i1 %50, label %51, label %67
51: ; preds = %45
%52 = trunc i64 %34 to i32
%53 = icmp eq i32 %3, 0
br i1 %53, label %73, label %54
54: ; preds = %51
%55 = add nsw i32 %0, -1
%56 = icmp eq i32 %55, %52
br i1 %56, label %73, label %57
57: ; preds = %54
%58 = icmp eq i32 %3, 1
br i1 %58, label %59, label %65
59: ; preds = %57
%60 = add nuw i64 %34, 1
%61 = and i64 %60, 4294967295
%62 = getelementptr inbounds i8*, i8** %1, i64 %61
%63 = load i8*, i8** %62
%64 = tail call i32 @atoi(i8* %63)
br label %73
65: ; preds = %57
%66 = add nuw nsw i32 %52, 1
br label %73
67: ; preds = %45, %39, %33
%68 = add nuw nsw i64 %34, 1
%69 = icmp eq i64 %68, %8
br i1 %69, label %70, label %33
70: ; preds = %67, %29
%71 = icmp ne i32 %3, 0
%72 = sext i1 %71 to i32
br label %73
73: ; preds = %70, %51, %54, %65, %59
%74 = phi i32 [ %64, %59 ], [ %66, %65 ], [ -1, %54 ], [ 1, %51 ], [ %72, %70 ]
ret i32 %74
}