#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 char_index(char *, char);
scalar_t__ is_boolean_parameter(char *, char *);
int /*<<< orphan*/ remove_eol(char *);
int /*<<< orphan*/ remove_quotes(char *);
int /*<<< orphan*/ sprintf(char *, char *, char *);
int strlen(char *);
int parse(int argc, char *argv[], char *fieldname, char *value, char separator,
          int start_index, int max_results) {
  int results = 0;
  int i, pos, c;
  char *str, *str2;
  for (i = 0; i < max_results; i++) {
    ((char *)&fieldname[i * 256])[0] = 0;
    ((char *)&value[i * 256])[0] = 0;
  }
  i = start_index;
  while (i < argc) {
    str = argv[i];
    if (strlen(argv[i]) > 0) {
      pos = char_index(str, separator);
      if (pos == -1) {
        sprintf((char *)&fieldname[results * 256], "%s", argv[i]);
        if (i < argc - 1) {
          if (is_boolean_parameter(argv[i], argv[i + 1]) == 0) {
            sprintf((char *)&value[results * 256], "%s", argv[i + 1]);
            i++;
          }
        }
      } else {
        str2 = (char *)&fieldname[results * 256];
        for (c = 0; c < pos; c++)
          str2[c] = str[c];
        str2[c] = 0;
        str2 = (char *)&value[results * 256];
        for (c = pos + 1; c < strlen(str); c++)
          str2[c - pos - 1] = str[c];
        str2[c - pos - 1] = 0;
      }
      results++;
      if (results >= max_results)
        break;
    }
    i++;
  }
  if (results > 0) {
    remove_eol((char *)&fieldname[(results - 1) * 256]);
    remove_eol((char *)&value[(results - 1) * 256]);
  }
  for (i = 0; i < results; i += 1)
    remove_quotes((char *)&value[i * 256]);
  return results;
}


x86 assembly (clang, -O0):
<parse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %r8b,%al
mov    0x10(%rbp),%r8d
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %al,-0x21(%rbp)
mov    %r9d,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    11cf <parse+0x6f>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x8,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
shl    $0x8,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1193 <parse+0x33>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13c5 <parse+0x265>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <strlen@plt>
cmp    $0x0,%eax
jle    13b7 <parse+0x257>
mov    -0x40(%rbp),%rdi
movsbl -0x21(%rbp),%esi
call   1040 <char_index@plt>
mov    %eax,-0x34(%rbp)
cmpl   $0xffffffff,-0x34(%rbp)
jne    12c8 <parse+0x168>
mov    -0x18(%rbp),%rdi
mov    -0x2c(%rbp),%eax
shl    $0x8,%eax
cltq
add    %rax,%rdi
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xdb9(%rip),%rsi
call   1070 <sprintf@plt>
mov    -0x30(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12c3 <parse+0x163>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
call   1080 <is_boolean_parameter@plt>
cmp    $0x0,%rax
jne    12be <parse+0x15e>
mov    -0x20(%rbp),%rdi
mov    -0x2c(%rbp),%eax
shl    $0x8,%eax
cltq
add    %rax,%rdi
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
lea    0xd50(%rip),%rsi
call   1070 <sprintf@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12c3 <parse+0x163>
jmp    1398 <parse+0x238>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x8,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1313 <parse+0x1b3>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12e3 <parse+0x183>
mov    -0x48(%rbp),%rax
movslq -0x38(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shl    $0x8,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x40(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x4c(%rbp),%eax
cmp    %ecx,%eax
jge    1384 <parse+0x224>
mov    -0x40(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    133c <parse+0x1dc>
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x10(%rbp),%eax
jl     13b2 <parse+0x252>
jmp    13c5 <parse+0x265>
jmp    13b7 <parse+0x257>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11d5 <parse+0x75>
cmpl   $0x0,-0x2c(%rbp)
jle    13fd <parse+0x29d>
mov    -0x18(%rbp),%rdi
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
shl    $0x8,%eax
cltq
add    %rax,%rdi
call   1060 <remove_eol@plt>
mov    -0x20(%rbp),%rdi
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
shl    $0x8,%eax
cltq
add    %rax,%rdi
call   1060 <remove_eol@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1432 <parse+0x2d2>
mov    -0x20(%rbp),%rdi
mov    -0x30(%rbp),%eax
shl    $0x8,%eax
cltq
add    %rax,%rdi
call   1050 <remove_quotes@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1404 <parse+0x2a4>
mov    -0x2c(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,%ebx
mov    %rcx,%r13
mov    %rdx,%r14
mov    %rsi,%r15
mov    %edi,%r12d
cmpl   $0x0,0x80(%rsp)
jle    1234 <parse+0xd4>
mov    0x80(%rsp),%edx
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    11a5 <parse+0x45>
xor    %ecx,%ecx
jmp    1201 <parse+0xa1>
and    $0xfffffffc,%edx
mov    $0x300,%esi
xor    %ecx,%ecx
nop
movb   $0x0,-0x300(%r14,%rsi,1)
movb   $0x0,-0x300(%r13,%rsi,1)
movb   $0x0,-0x200(%r14,%rsi,1)
movb   $0x0,-0x200(%r13,%rsi,1)
movb   $0x0,-0x100(%r14,%rsi,1)
movb   $0x0,-0x100(%r13,%rsi,1)
movb   $0x0,(%r14,%rsi,1)
movb   $0x0,0x0(%r13,%rsi,1)
add    $0x4,%rcx
add    $0x400,%rsi
cmp    %rcx,%rdx
jne    11b0 <parse+0x50>
test   %rax,%rax
je     1234 <parse+0xd4>
shl    $0x8,%rcx
lea    (%rcx,%r13,1),%rdx
add    %r14,%rcx
shl    $0x8,%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movb   $0x0,(%rcx,%rsi,1)
movb   $0x0,(%rdx,%rsi,1)
add    $0x100,%rsi
cmp    %rsi,%rax
jne    1220 <parse+0xc0>
xor    %eax,%eax
cmp    %r12d,%ebx
jge    15f9 <parse+0x499>
lea    -0x1(%r12),%eax
mov    %eax,0x14(%rsp)
lea    0x70(%r14),%rax
mov    %rax,0x28(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x30(%rsp)
lea    0x3(%r14),%rax
mov    %rax,0x38(%rsp)
xor    %eax,%eax
mov    %rax,(%rsp)
movsbl %r8b,%eax
mov    %eax,0x18(%rsp)
mov    %r15,0x8(%rsp)
mov    %r12,0x40(%rsp)
mov    %r14,0x20(%rsp)
jmp    12a1 <parse+0x141>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%r15
add    $0x1,%ebx
cmp    %r12d,%ebx
jge    15a2 <parse+0x442>
movslq %ebx,%rbp
mov    (%r15,%rbp,8),%r15
mov    %r15,%rdi
call   1040 <strlen@plt>
test   %eax,%eax
jle    1290 <parse+0x130>
mov    %r15,%rdi
mov    0x18(%rsp),%esi
call   1050 <char_index@plt>
mov    %eax,%r10d
mov    (%rsp),%rax
shl    $0x8,%eax
movslq %eax,%r12
lea    (%r14,%r12,1),%rdi
cmp    $0xffffffff,%r10d
je     13a0 <parse+0x240>
mov    %ebx,0x1c(%rsp)
mov    %r10d,%r14d
test   %r10d,%r10d
jle    13e7 <parse+0x287>
mov    %r10d,%r9d
cmp    $0x8,%r10d
jb     1313 <parse+0x1b3>
lea    (%r15,%r9,1),%rcx
cmp    %rcx,%rdi
jae    1471 <parse+0x311>
lea    (%r12,%r9,1),%rcx
add    0x20(%rsp),%rcx
cmp    %rcx,%r15
jae    1471 <parse+0x311>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rsi
and    $0x3,%rsi
je     1342 <parse+0x1e2>
nopw   0x0(%rax,%rax,1)
movzbl (%r15,%rcx,1),%eax
mov    %al,(%rdi,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1330 <parse+0x1d0>
mov    %r14d,%esi
cmp    $0x3,%rdx
jb     13e9 <parse+0x289>
mov    0x38(%rsp),%rax
lea    (%rax,%r12,1),%rdx
nopl   0x0(%rax,%rax,1)
movzbl (%r15,%rcx,1),%eax
mov    %al,-0x3(%rdx,%rcx,1)
movzbl 0x1(%r15,%rcx,1),%eax
mov    %al,-0x2(%rdx,%rcx,1)
movzbl 0x2(%r15,%rcx,1),%eax
mov    %al,-0x1(%rdx,%rcx,1)
movzbl 0x3(%r15,%rcx,1),%eax
mov    %al,(%rdx,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1360 <parse+0x200>
mov    %r14d,%esi
jmp    13e9 <parse+0x289>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rsp),%r15
mov    (%r15,%rbp,8),%rsi
call   1030 <strcpy@plt>
cmp    0x14(%rsp),%ebp
jge    144f <parse+0x2ef>
mov    (%r15,%rbp,8),%rdi
mov    0x8(%r15,%rbp,8),%rsi
call   1080 <is_boolean_parameter@plt>
test   %rax,%rax
jne    144f <parse+0x2ef>
lea    0x1(%rbp),%ebx
add    $0x1,%rbp
add    %r13,%r12
mov    (%r15,%rbp,8),%rsi
mov    %r12,%rdi
call   1030 <strcpy@plt>
jmp    144f <parse+0x2ef>
xor    %esi,%esi
mov    %esi,%eax
movb   $0x0,(%rdi,%rax,1)
add    %r13,%r12
lea    0x1(%r10),%ebp
mov    %r15,%rdi
mov    %r10,%rbx
call   1040 <strlen@plt>
cmp    %eax,%ebp
jge    1436 <parse+0x2d6>
movslq %ebp,%rbp
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
movzbl (%r15,%rbp,1),%eax
movslq %r14d,%r14
mov    %al,(%r12,%r14,1)
add    $0x1,%rbp
mov    %r15,%rdi
call   1040 <strlen@plt>
cltq
add    $0x1,%r14d
cmp    %rax,%rbp
jl     1410 <parse+0x2b0>
add    %ebx,%r14d
sub    %ebx,%r14d
movslq %r14d,%rax
movb   $0x0,(%r12,%rax,1)
mov    0x20(%rsp),%r14
mov    0x1c(%rsp),%ebx
mov    0x8(%rsp),%r15
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
cmp    0x80(%rsp),%eax
mov    0x40(%rsp),%r12
jl     1295 <parse+0x135>
jmp    15a2 <parse+0x442>
cmp    $0x20,%r10d
jae    147e <parse+0x31e>
xor    %ecx,%ecx
jmp    1571 <parse+0x411>
mov    %r9d,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rdx
jae    14a4 <parse+0x344>
xor    %ebp,%ebp
jmp    1520 <parse+0x3c0>
and    $0xfffffffffffffffc,%rsi
mov    0x28(%rsp),%rax
lea    (%rax,%r12,1),%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%r15,%rbp,1),%xmm0
movups 0x10(%r15,%rbp,1),%xmm1
movups %xmm0,-0x70(%rdx,%rbp,1)
movups %xmm1,-0x60(%rdx,%rbp,1)
movups 0x20(%r15,%rbp,1),%xmm0
movups 0x30(%r15,%rbp,1),%xmm1
movups %xmm0,-0x50(%rdx,%rbp,1)
movups %xmm1,-0x40(%rdx,%rbp,1)
movups 0x40(%r15,%rbp,1),%xmm0
movups 0x50(%r15,%rbp,1),%xmm1
movups %xmm0,-0x30(%rdx,%rbp,1)
movups %xmm1,-0x20(%rdx,%rbp,1)
movups 0x60(%r15,%rbp,1),%xmm0
movups 0x70(%r15,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rsi
jne    14c0 <parse+0x360>
test   %r8,%r8
je     155b <parse+0x3fb>
lea    (%r12,%rbp,1),%rdx
add    0x30(%rsp),%rdx
lea    (%r15,%rbp,1),%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    1540 <parse+0x3e0>
mov    %r14d,%esi
cmp    %r9,%rcx
je     13e9 <parse+0x289>
test   $0x18,%r9b
je     1315 <parse+0x1b5>
mov    %rcx,%rdx
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rdx,1),%rsi
mov    %rsi,(%rdi,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    1580 <parse+0x420>
mov    %r14d,%esi
cmp    %r9,%rcx
je     13e9 <parse+0x289>
jmp    1315 <parse+0x1b5>
mov    (%rsp),%rax
test   %eax,%eax
jle    15f9 <parse+0x499>
mov    %eax,%ecx
shl    $0x8,%ecx
add    $0xffffff00,%ecx
mov    %rax,%rbx
movslq %ecx,%rbp
add    %rbp,%r14
mov    %r14,%rdi
call   1070 <remove_eol@plt>
add    %r13,%rbp
mov    %rbp,%rdi
call   1070 <remove_eol@plt>
mov    %ebx,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,%rdi
call   1060 <remove_quotes@plt>
add    $0x100,%r13
add    $0xffffffffffffffff,%rbp
jne    15e0 <parse+0x480>
mov    (%rsp),%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @parse(i32 %0, i8** nocapture %1, i8* %2, i8* %3, i8 signext %4, i32 %5, i32 %6) {
%8 = icmp sgt i32 %6, 0
br i1 %8, label %9, label %28
9: ; preds = %7
%10 = zext i32 %6 to i64
%11 = add nsw i64 %10, -1
%12 = and i64 %10, 3
%13 = icmp ult i64 %11, 3
br i1 %13, label %16, label %14
14: ; preds = %9
%15 = and i64 %10, 4294967292
br label %32
16: ; preds = %32, %9
%17 = phi i64 [ 0, %9 ], [ %50, %32 ]
%18 = icmp eq i64 %12, 0
br i1 %18, label %28, label %19
19: ; preds = %16, %19
%20 = phi i64 [ %25, %19 ], [ %17, %16 ]
%21 = phi i64 [ %26, %19 ], [ 0, %16 ]
%22 = shl nsw i64 %20, 8
%23 = getelementptr inbounds i8, i8* %2, i64 %22
store i8 0, i8* %23
%24 = getelementptr inbounds i8, i8* %3, i64 %22
store i8 0, i8* %24
%25 = add nuw nsw i64 %20, 1
%26 = add i64 %21, 1
%27 = icmp eq i64 %26, %12
br i1 %27, label %28, label %19
28: ; preds = %16, %19, %7
%29 = icmp slt i32 %5, %0
br i1 %29, label %30, label %289
30: ; preds = %28
%31 = add nsw i32 %0, -1
br label %53
32: ; preds = %32, %14
%33 = phi i64 [ 0, %14 ], [ %50, %32 ]
%34 = phi i64 [ 0, %14 ], [ %51, %32 ]
%35 = shl nsw i64 %33, 8
%36 = getelementptr inbounds i8, i8* %2, i64 %35
store i8 0, i8* %36
%37 = getelementptr inbounds i8, i8* %3, i64 %35
store i8 0, i8* %37
%38 = shl i64 %33, 8
%39 = or i64 %38, 256
%40 = getelementptr inbounds i8, i8* %2, i64 %39
store i8 0, i8* %40
%41 = getelementptr inbounds i8, i8* %3, i64 %39
store i8 0, i8* %41
%42 = shl i64 %33, 8
%43 = or i64 %42, 512
%44 = getelementptr inbounds i8, i8* %2, i64 %43
store i8 0, i8* %44
%45 = getelementptr inbounds i8, i8* %3, i64 %43
store i8 0, i8* %45
%46 = shl i64 %33, 8
%47 = or i64 %46, 768
%48 = getelementptr inbounds i8, i8* %2, i64 %47
store i8 0, i8* %48
%49 = getelementptr inbounds i8, i8* %3, i64 %47
store i8 0, i8* %49
%50 = add nuw nsw i64 %33, 4
%51 = add i64 %34, 4
%52 = icmp eq i64 %51, %15
br i1 %52, label %16, label %32
53: ; preds = %30, %265
%54 = phi i32 [ 0, %30 ], [ %267, %265 ]
%55 = phi i32 [ %5, %30 ], [ %268, %265 ]
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds i8*, i8** %1, i64 %56
%58 = load i8*, i8** %57
%59 = tail call i32 @strlen(i8* %58)
%60 = icmp sgt i32 %59, 0
br i1 %60, label %61, label %265
61: ; preds = %53
%62 = tail call i32 @char_index(i8* %58, i8 signext %4)
%63 = icmp eq i32 %62, -1
%64 = shl nsw i32 %54, 8
%65 = sext i32 %64 to i64
%66 = getelementptr i8, i8* %2, i64 %65
br i1 %63, label %67, label %83
67: ; preds = %61
%68 = load i8*, i8** %57
%69 = tail call i8* @strcpy(i8* dereferenceable(1) %66, i8* dereferenceable(1) %68)
%70 = icmp slt i32 %55, %31
br i1 %70, label %71, label %261
71: ; preds = %67
%72 = load i8*, i8** %57
%73 = add nsw i32 %55, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8*, i8** %1, i64 %74
%76 = load i8*, i8** %75
%77 = tail call i64 @is_boolean_parameter(i8* %72, i8* %76)
%78 = icmp eq i64 %77, 0
br i1 %78, label %79, label %261
79: ; preds = %71
%80 = getelementptr inbounds i8, i8* %3, i64 %65
%81 = load i8*, i8** %75
%82 = tail call i8* @strcpy(i8* dereferenceable(1) %80, i8* dereferenceable(1) %81)
br label %261
83: ; preds = %61
%84 = icmp sgt i32 %62, 0
br i1 %84, label %85, label %231
85: ; preds = %83
%86 = zext i32 %62 to i64
%87 = icmp ult i32 %62, 8
br i1 %87, label %194, label %88
88: ; preds = %85
%89 = add nsw i64 %65, %86
%90 = getelementptr i8, i8* %2, i64 %89
%91 = getelementptr i8, i8* %58, i64 %86
%92 = icmp ult i8* %66, %91
%93 = icmp ult i8* %58, %90
%94 = and i1 %92, %93
br i1 %94, label %194, label %95
95: ; preds = %88
%96 = icmp ult i32 %62, 32
br i1 %96, label %179, label %97
97: ; preds = %95
%98 = and i64 %86, 4294967264
%99 = add nsw i64 %98, -32
%100 = lshr exact i64 %99, 5
%101 = add nuw nsw i64 %100, 1
%102 = and i64 %101, 3
%103 = icmp ult i64 %99, 96
br i1 %103, label %155, label %104
104: ; preds = %97
%105 = and i64 %101, 1152921504606846972
br label %106
106: ; preds = %106, %104
%107 = phi i64 [ 0, %104 ], [ %152, %106 ]
%108 = phi i64 [ 0, %104 ], [ %153, %106 ]
%109 = getelementptr inbounds i8, i8* %58, i64 %107
%110 = bitcast i8* %109 to <16 x i8>*
%111 = load <16 x i8>, <16 x i8>* %110
%112 = getelementptr inbounds i8, i8* %109, i64 16
%113 = bitcast i8* %112 to <16 x i8>*
%114 = load <16 x i8>, <16 x i8>* %113
%115 = getelementptr inbounds i8, i8* %66, i64 %107
%116 = bitcast i8* %115 to <16 x i8>*
store <16 x i8> %111, <16 x i8>* %116
%117 = getelementptr inbounds i8, i8* %115, i64 16
%118 = bitcast i8* %117 to <16 x i8>*
store <16 x i8> %114, <16 x i8>* %118
%119 = or i64 %107, 32
%120 = getelementptr inbounds i8, i8* %58, i64 %119
%121 = bitcast i8* %120 to <16 x i8>*
%122 = load <16 x i8>, <16 x i8>* %121
%123 = getelementptr inbounds i8, i8* %120, i64 16
%124 = bitcast i8* %123 to <16 x i8>*
%125 = load <16 x i8>, <16 x i8>* %124
%126 = getelementptr inbounds i8, i8* %66, i64 %119
%127 = bitcast i8* %126 to <16 x i8>*
store <16 x i8> %122, <16 x i8>* %127
%128 = getelementptr inbounds i8, i8* %126, i64 16
%129 = bitcast i8* %128 to <16 x i8>*
store <16 x i8> %125, <16 x i8>* %129
%130 = or i64 %107, 64
%131 = getelementptr inbounds i8, i8* %58, i64 %130
%132 = bitcast i8* %131 to <16 x i8>*
%133 = load <16 x i8>, <16 x i8>* %132
%134 = getelementptr inbounds i8, i8* %131, i64 16
%135 = bitcast i8* %134 to <16 x i8>*
%136 = load <16 x i8>, <16 x i8>* %135
%137 = getelementptr inbounds i8, i8* %66, i64 %130
%138 = bitcast i8* %137 to <16 x i8>*
store <16 x i8> %133, <16 x i8>* %138
%139 = getelementptr inbounds i8, i8* %137, i64 16
%140 = bitcast i8* %139 to <16 x i8>*
store <16 x i8> %136, <16 x i8>* %140
%141 = or i64 %107, 96
%142 = getelementptr inbounds i8, i8* %58, i64 %141
%143 = bitcast i8* %142 to <16 x i8>*
%144 = load <16 x i8>, <16 x i8>* %143
%145 = getelementptr inbounds i8, i8* %142, i64 16
%146 = bitcast i8* %145 to <16 x i8>*
%147 = load <16 x i8>, <16 x i8>* %146
%148 = getelementptr inbounds i8, i8* %66, i64 %141
%149 = bitcast i8* %148 to <16 x i8>*
store <16 x i8> %144, <16 x i8>* %149
%150 = getelementptr inbounds i8, i8* %148, i64 16
%151 = bitcast i8* %150 to <16 x i8>*
store <16 x i8> %147, <16 x i8>* %151
%152 = add nuw i64 %107, 128
%153 = add i64 %108, 4
%154 = icmp eq i64 %153, %105
br i1 %154, label %155, label %106
155: ; preds = %106, %97
%156 = phi i64 [ 0, %97 ], [ %152, %106 ]
%157 = icmp eq i64 %102, 0
br i1 %157, label %174, label %158
158: ; preds = %155, %158
%159 = phi i64 [ %171, %158 ], [ %156, %155 ]
%160 = phi i64 [ %172, %158 ], [ 0, %155 ]
%161 = getelementptr inbounds i8, i8* %58, i64 %159
%162 = bitcast i8* %161 to <16 x i8>*
%163 = load <16 x i8>, <16 x i8>* %162
%164 = getelementptr inbounds i8, i8* %161, i64 16
%165 = bitcast i8* %164 to <16 x i8>*
%166 = load <16 x i8>, <16 x i8>* %165
%167 = getelementptr inbounds i8, i8* %66, i64 %159
%168 = bitcast i8* %167 to <16 x i8>*
store <16 x i8> %163, <16 x i8>* %168
%169 = getelementptr inbounds i8, i8* %167, i64 16
%170 = bitcast i8* %169 to <16 x i8>*
store <16 x i8> %166, <16 x i8>* %170
%171 = add nuw i64 %159, 32
%172 = add i64 %160, 1
%173 = icmp eq i64 %172, %102
br i1 %173, label %174, label %158
174: ; preds = %158, %155
%175 = icmp eq i64 %98, %86
br i1 %175, label %231, label %176
176: ; preds = %174
%177 = and i64 %86, 24
%178 = icmp eq i64 %177, 0
br i1 %178, label %194, label %179
179: ; preds = %95, %176
%180 = phi i64 [ %98, %176 ], [ 0, %95 ]
%181 = zext i32 %62 to i64
%182 = and i64 %181, 4294967288
br label %183
183: ; preds = %183, %179
%184 = phi i64 [ %180, %179 ], [ %190, %183 ]
%185 = getelementptr inbounds i8, i8* %58, i64 %184
%186 = bitcast i8* %185 to <8 x i8>*
%187 = load <8 x i8>, <8 x i8>* %186
%188 = getelementptr inbounds i8, i8* %66, i64 %184
%189 = bitcast i8* %188 to <8 x i8>*
store <8 x i8> %187, <8 x i8>* %189
%190 = add nuw i64 %184, 8
%191 = icmp eq i64 %190, %182
br i1 %191, label %192, label %183
192: ; preds = %183
%193 = icmp eq i64 %182, %181
br i1 %193, label %231, label %194
194: ; preds = %88, %85, %176, %192
%195 = phi i64 [ 0, %85 ], [ 0, %88 ], [ %98, %176 ], [ %182, %192 ]
%196 = xor i64 %195, -1
%197 = add nsw i64 %196, %86
%198 = and i64 %86, 3
%199 = icmp eq i64 %198, 0
br i1 %199, label %209, label %200
200: ; preds = %194, %200
%201 = phi i64 [ %206, %200 ], [ %195, %194 ]
%202 = phi i64 [ %207, %200 ], [ 0, %194 ]
%203 = getelementptr inbounds i8, i8* %58, i64 %201
%204 = load i8, i8* %203
%205 = getelementptr inbounds i8, i8* %66, i64 %201
store i8 %204, i8* %205
%206 = add nuw nsw i64 %201, 1
%207 = add i64 %202, 1
%208 = icmp eq i64 %207, %198
br i1 %208, label %209, label %200
209: ; preds = %200, %194
%210 = phi i64 [ %195, %194 ], [ %206, %200 ]
%211 = icmp ult i64 %197, 3
br i1 %211, label %231, label %212
212: ; preds = %209, %212
%213 = phi i64 [ %229, %212 ], [ %210, %209 ]
%214 = getelementptr inbounds i8, i8* %58, i64 %213
%215 = load i8, i8* %214
%216 = getelementptr inbounds i8, i8* %66, i64 %213
store i8 %215, i8* %216
%217 = add nuw nsw i64 %213, 1
%218 = getelementptr inbounds i8, i8* %58, i64 %217
%219 = load i8, i8* %218
%220 = getelementptr inbounds i8, i8* %66, i64 %217
store i8 %219, i8* %220
%221 = add nuw nsw i64 %213, 2
%222 = getelementptr inbounds i8, i8* %58, i64 %221
%223 = load i8, i8* %222
%224 = getelementptr inbounds i8, i8* %66, i64 %221
store i8 %223, i8* %224
%225 = add nuw nsw i64 %213, 3
%226 = getelementptr inbounds i8, i8* %58, i64 %225
%227 = load i8, i8* %226
%228 = getelementptr inbounds i8, i8* %66, i64 %225
store i8 %227, i8* %228
%229 = add nuw nsw i64 %213, 4
%230 = icmp eq i64 %229, %86
br i1 %230, label %231, label %212
231: ; preds = %209, %212, %174, %192, %83
%232 = phi i32 [ 0, %83 ], [ %62, %192 ], [ %62, %174 ], [ %62, %212 ], [ %62, %209 ]
%233 = zext i32 %232 to i64
%234 = getelementptr inbounds i8, i8* %66, i64 %233
store i8 0, i8* %234
%235 = getelementptr inbounds i8, i8* %3, i64 %65
%236 = add i32 %62, 1
%237 = tail call i32 @strlen(i8* %58)
%238 = icmp slt i32 %236, %237
br i1 %238, label %239, label %256
239: ; preds = %231
%240 = sext i32 %236 to i64
br label %241
241: ; preds = %239, %241
%242 = phi i64 [ %240, %239 ], [ %249, %241 ]
%243 = phi i32 [ %62, %239 ], [ %253, %241 ]
%244 = getelementptr inbounds i8, i8* %58, i64 %242
%245 = load i8, i8* %244
%246 = sub i32 %243, %62
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds i8, i8* %235, i64 %247
store i8 %245, i8* %248
%249 = add nsw i64 %242, 1
%250 = tail call i32 @strlen(i8* %58)
%251 = sext i32 %250 to i64
%252 = icmp slt i64 %249, %251
%253 = trunc i64 %242 to i32
br i1 %252, label %241, label %254
254: ; preds = %241
%255 = trunc i64 %242 to i32
br label %256
256: ; preds = %254, %231
%257 = phi i32 [ %62, %231 ], [ %255, %254 ]
%258 = sub i32 %257, %62
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i8, i8* %235, i64 %259
store i8 0, i8* %260
br label %261
261: ; preds = %67, %79, %71, %256
%262 = phi i32 [ %73, %79 ], [ %55, %71 ], [ %55, %67 ], [ %55, %256 ]
%263 = add nsw i32 %54, 1
%264 = icmp slt i32 %263, %6
br i1 %264, label %265, label %270
265: ; preds = %261, %53
%266 = phi i32 [ %262, %261 ], [ %55, %53 ]
%267 = phi i32 [ %263, %261 ], [ %54, %53 ]
%268 = add nsw i32 %266, 1
%269 = icmp slt i32 %268, %0
br i1 %269, label %53, label %270
270: ; preds = %265, %261
%271 = phi i32 [ %267, %265 ], [ %263, %261 ]
%272 = icmp sgt i32 %271, 0
br i1 %272, label %273, label %289
273: ; preds = %270
%274 = shl i32 %271, 8
%275 = add i32 %274, -256
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds i8, i8* %2, i64 %276
%278 = tail call i32 @remove_eol(i8* %277)
%279 = getelementptr inbounds i8, i8* %3, i64 %276
%280 = tail call i32 @remove_eol(i8* %279)
%281 = zext i32 %271 to i64
br label %282
282: ; preds = %273, %282
%283 = phi i64 [ 0, %273 ], [ %287, %282 ]
%284 = shl nsw i64 %283, 8
%285 = getelementptr inbounds i8, i8* %3, i64 %284
%286 = tail call i32 @remove_quotes(i8* %285)
%287 = add nuw nsw i64 %283, 1
%288 = icmp eq i64 %287, %281
br i1 %288, label %289, label %282
289: ; preds = %282, %28, %270
%290 = phi i32 [ %271, %270 ], [ 0, %28 ], [ %271, %282 ]
ret i32 %290
}