#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 */
char *parselong(const char *optstring, const char *opt, char **longoptarg) {
  char *cp;
  char *ip;
  char *op;
  int match;
  cp = ip = (char *)optstring;
  do {
    if (*ip != '(' && *++ip == '\0')
      break;
    if (*ip == ':' && *++ip == '\0')
      break;
    while (*ip == '(') {
      if (*++ip == '\0')
        break;
      op = (char *)opt;
      match = 1;
      while (*ip != ')' && *ip != '\0' && *op != '\0')
        match = (*ip++ == *op++ && match);
      if (match && *ip == ')' && (*op == '\0' || *op == '=')) {
        if ((*op) == '=') {
          (*longoptarg) = op + 1;
        } else {
          (*longoptarg) = NULL;
        }
        return (cp);
      }
      if (*ip == ')' && *++ip == '\0')
        break;
    }
    cp = ip;
    while ((cp > optstring) && ((*cp) == ':')) {
      --cp;
    }
  } while (*cp != '\0');
  return (NULL);
}


x86 assembly (clang, -O0):
<parselong>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x28,%eax
je     114d <parselong+0x4d>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
jne    114d <parselong+0x4d>
jmp    1365 <parselong+0x265>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
jne    117e <parselong+0x7e>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
jne    117e <parselong+0x7e>
jmp    1365 <parselong+0x265>
jmp    1183 <parselong+0x83>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x28,%eax
jne    1304 <parselong+0x204>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
jne    11b4 <parselong+0xb4>
jmp    1304 <parselong+0x204>
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x29,%ecx
mov    %al,-0x3d(%rbp)
je     11fd <parselong+0xfd>
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x3d(%rbp)
je     11fd <parselong+0xfd>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    120d <parselong+0x10d>
jmp    1258 <parselong+0x158>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl (%rax),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
movsbl (%rax),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x3e(%rbp)
jne    1248 <parselong+0x148>
cmpl   $0x0,-0x3c(%rbp)
setne  %al
mov    %al,-0x3e(%rbp)
mov    -0x3e(%rbp),%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x3c(%rbp)
jmp    11c3 <parselong+0xc3>
cmpl   $0x0,-0x3c(%rbp)
je     12ce <parselong+0x1ce>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
jne    12ce <parselong+0x1ce>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1292 <parselong+0x192>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3d,%eax
jne    12ce <parselong+0x1ce>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3d,%eax
jne    12b6 <parselong+0x1b6>
mov    -0x38(%rbp),%rcx
add    $0x1,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
jmp    12c1 <parselong+0x1c1>
mov    -0x20(%rbp),%rax
movq   $0x0,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    136d <parselong+0x26d>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x29,%eax
jne    12ff <parselong+0x1ff>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movsbl 0x1(%rax),%eax
cmp    $0x0,%eax
jne    12ff <parselong+0x1ff>
jmp    1304 <parselong+0x204>
jmp    1183 <parselong+0x83>
mov    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rcx
xor    %eax,%eax
cmp    -0x10(%rbp),%rcx
mov    %al,-0x3f(%rbp)
jbe    132f <parselong+0x22f>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
sete   %al
mov    %al,-0x3f(%rbp)
mov    -0x3f(%rbp),%al
test   $0x1,%al
jne    133f <parselong+0x23f>
jmp    1350 <parselong+0x250>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    130c <parselong+0x20c>
jmp    1355 <parselong+0x255>
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    111c <parselong+0x1c>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<parselong>:
push   %r14
push   %rbx
mov    (%rdi),%r9b
add    $0x1,%rsi
mov    %rdi,%rax
mov    %rdi,%r8
cmp    $0x28,%r9b
je     115a <parselong+0x5a>
mov    0x1(%r8),%r9b
cmp    $0x3a,%r9b
je     1130 <parselong+0x30>
test   %r9b,%r9b
je     123e <parselong+0x13e>
add    $0x1,%r8
jmp    1150 <parselong+0x50>
nop
mov    0x2(%r8),%r9b
test   %r9b,%r9b
je     123e <parselong+0x13e>
add    $0x2,%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x28,%r9b
jne    1210 <parselong+0x110>
mov    0x1(%r8),%r9b
test   %r9b,%r9b
je     1200 <parselong+0x100>
add    $0x2,%r8
mov    $0x1,%r11d
mov    %rsi,%r14
mov    %r8,%r10
test   %r9b,%r9b
je     11b2 <parselong+0xb2>
nopl   0x0(%rax)
cmp    $0x29,%r9b
je     11b2 <parselong+0xb2>
movzbl -0x1(%r14),%ecx
test   %cl,%cl
je     11b2 <parselong+0xb2>
cmp    %cl,%r9b
sete   %cl
test   %r11d,%r11d
setne  %bl
and    %cl,%bl
movzbl %bl,%r11d
movzbl (%r10),%r9d
add    $0x1,%r10
add    $0x1,%r14
test   %r9b,%r9b
jne    1180 <parselong+0x80>
lea    -0x1(%r10),%r8
test   %r11d,%r11d
je     11e0 <parselong+0xe0>
cmp    $0x29,%r9b
jne    1150 <parselong+0x50>
mov    -0x1(%r14),%r8b
cmp    $0x3d,%r8b
je     1242 <parselong+0x142>
test   %r8b,%r8b
jne    11ea <parselong+0xea>
jmp    1242 <parselong+0x142>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x29,%r9b
jne    1150 <parselong+0x50>
mov    (%r10),%r9b
test   %r9b,%r9b
je     1209 <parselong+0x109>
mov    %r10,%r8
jmp    1150 <parselong+0x50>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
xor    %r9d,%r9d
jmp    1210 <parselong+0x110>
xor    %r9d,%r9d
mov    %r10,%r8
nop
mov    %r8,%rax
cmp    %rdi,%r8
jbe    1234 <parselong+0x134>
mov    %r8,%rax
nopl   0x0(%rax,%rax,1)
movzbl (%rax),%ecx
cmp    $0x3a,%cl
jne    1236 <parselong+0x136>
add    $0xffffffffffffffff,%rax
cmp    %rdi,%rax
ja     1220 <parselong+0x120>
mov    %rdi,%rax
mov    (%rax),%cl
test   %cl,%cl
jne    1110 <parselong+0x10>
xor    %eax,%eax
jmp    124f <parselong+0x14f>
xor    %ecx,%ecx
cmp    $0x3d,%r8b
cmove  %r14,%rcx
mov    %rcx,(%rdx)
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define i8* @parselong(i8* %0, i8* %1, i8** %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8**
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8** %2, i8*** %7
%12 = load i8*, i8** %5
store i8* %12, i8** %9
store i8* %12, i8** %8
br label %13
13: ; preds = %146, %3
%14 = load i8*, i8** %9
%15 = load i8, i8* %14
%16 = sext i8 %15 to i32
%17 = icmp ne i32 %16, 40
br i1 %17, label %18, label %25
18: ; preds = %13
%19 = load i8*, i8** %9
%20 = getelementptr inbounds i8, i8* %19, i32 1
store i8* %20, i8** %9
%21 = load i8, i8* %20
%22 = sext i8 %21 to i32
%23 = icmp eq i32 %22, 0
br i1 %23, label %24, label %25
24: ; preds = %18
br label %151
25: ; preds = %18, %13
%26 = load i8*, i8** %9
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp eq i32 %28, 58
br i1 %29, label %30, label %37
30: ; preds = %25
%31 = load i8*, i8** %9
%32 = getelementptr inbounds i8, i8* %31, i32 1
store i8* %32, i8** %9
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = icmp eq i32 %34, 0
br i1 %35, label %36, label %37
36: ; preds = %30
br label %151
37: ; preds = %30, %25
br label %38
38: ; preds = %128, %37
%39 = load i8*, i8** %9
%40 = load i8, i8* %39
%41 = sext i8 %40 to i32
%42 = icmp eq i32 %41, 40
br i1 %42, label %43, label %129
43: ; preds = %38
%44 = load i8*, i8** %9
%45 = getelementptr inbounds i8, i8* %44, i32 1
store i8* %45, i8** %9
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = icmp eq i32 %47, 0
br i1 %48, label %49, label %50
49: ; preds = %43
br label %129
50: ; preds = %43
%51 = load i8*, i8** %6
store i8* %51, i8** %10
store i32 1, i32* %11
br label %52
52: ; preds = %82, %50
%53 = load i8*, i8** %9
%54 = load i8, i8* %53
%55 = sext i8 %54 to i32
%56 = icmp ne i32 %55, 41
br i1 %56, label %57, label %67
57: ; preds = %52
%58 = load i8*, i8** %9
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = icmp ne i32 %60, 0
br i1 %61, label %62, label %67
62: ; preds = %57
%63 = load i8*, i8** %10
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = icmp ne i32 %65, 0
br label %67
67: ; preds = %62, %57, %52
%68 = phi i1 [ false, %57 ], [ false, %52 ], [ %66, %62 ]
br i1 %68, label %69, label %85
69: ; preds = %67
%70 = load i8*, i8** %9
%71 = getelementptr inbounds i8, i8* %70, i32 1
store i8* %71, i8** %9
%72 = load i8, i8* %70
%73 = sext i8 %72 to i32
%74 = load i8*, i8** %10
%75 = getelementptr inbounds i8, i8* %74, i32 1
store i8* %75, i8** %10
%76 = load i8, i8* %74
%77 = sext i8 %76 to i32
%78 = icmp eq i32 %73, %77
br i1 %78, label %79, label %82
79: ; preds = %69
%80 = load i32, i32* %11
%81 = icmp ne i32 %80, 0
br label %82
82: ; preds = %79, %69
%83 = phi i1 [ false, %69 ], [ %81, %79 ]
%84 = zext i1 %83 to i32
store i32 %84, i32* %11
br label %52
85: ; preds = %67
%86 = load i32, i32* %11
%87 = icmp ne i32 %86, 0
br i1 %87, label %88, label %116
88: ; preds = %85
%89 = load i8*, i8** %9
%90 = load i8, i8* %89
%91 = sext i8 %90 to i32
%92 = icmp eq i32 %91, 41
br i1 %92, label %93, label %116
93: ; preds = %88
%94 = load i8*, i8** %10
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
%97 = icmp eq i32 %96, 0
br i1 %97, label %103, label %98
98: ; preds = %93
%99 = load i8*, i8** %10
%100 = load i8, i8* %99
%101 = sext i8 %100 to i32
%102 = icmp eq i32 %101, 61
br i1 %102, label %103, label %116
103: ; preds = %98, %93
%104 = load i8*, i8** %10
%105 = load i8, i8* %104
%106 = sext i8 %105 to i32
%107 = icmp eq i32 %106, 61
br i1 %107, label %108, label %112
108: ; preds = %103
%109 = load i8*, i8** %10
%110 = getelementptr inbounds i8, i8* %109, i64 1
%111 = load i8**, i8*** %7
store i8* %110, i8** %111
br label %114
112: ; preds = %103
%113 = load i8**, i8*** %7
store i8* null, i8** %113
br label %114
114: ; preds = %112, %108
%115 = load i8*, i8** %8
store i8* %115, i8** %4
br label %152
116: ; preds = %98, %88, %85
%117 = load i8*, i8** %9
%118 = load i8, i8* %117
%119 = sext i8 %118 to i32
%120 = icmp eq i32 %119, 41
br i1 %120, label %121, label %128
121: ; preds = %116
%122 = load i8*, i8** %9
%123 = getelementptr inbounds i8, i8* %122, i32 1
store i8* %123, i8** %9
%124 = load i8, i8* %123
%125 = sext i8 %124 to i32
%126 = icmp eq i32 %125, 0
br i1 %126, label %127, label %128
127: ; preds = %121
br label %129
128: ; preds = %121, %116
br label %38
129: ; preds = %127, %49, %38
%130 = load i8*, i8** %9
store i8* %130, i8** %8
br label %131
131: ; preds = %142, %129
%132 = load i8*, i8** %8
%133 = load i8*, i8** %5
%134 = icmp ugt i8* %132, %133
br i1 %134, label %135, label %140
135: ; preds = %131
%136 = load i8*, i8** %8
%137 = load i8, i8* %136
%138 = sext i8 %137 to i32
%139 = icmp eq i32 %138, 58
br label %140
140: ; preds = %135, %131
%141 = phi i1 [ false, %131 ], [ %139, %135 ]
br i1 %141, label %142, label %145
142: ; preds = %140
%143 = load i8*, i8** %8
%144 = getelementptr inbounds i8, i8* %143, i32 -1
store i8* %144, i8** %8
br label %131
145: ; preds = %140
br label %146
146: ; preds = %145
%147 = load i8*, i8** %8
%148 = load i8, i8* %147
%149 = sext i8 %148 to i32
%150 = icmp ne i32 %149, 0
br i1 %150, label %13, label %151
151: ; preds = %146, %36, %24
store i8* null, i8** %4
br label %152
152: ; preds = %151, %114
%153 = load i8*, i8** %4
ret i8* %153
}

LLVM IR (-O2):
define i8* @parselong(i8* %0, i8* %1, i8** nocapture writeonly %2) {
%4 = ptrtoint i8* %0 to i64
%5 = load i8, i8* %0
br label %6
6: ; preds = %83, %3
%7 = phi i8 [ %5, %3 ], [ %65, %83 ]
%8 = phi i8* [ %0, %3 ], [ %84, %83 ]
%9 = phi i8* [ %0, %3 ], [ %66, %83 ]
%10 = icmp eq i8 %7, 40
br i1 %10, label %22, label %11
11: ; preds = %6
%12 = getelementptr inbounds i8, i8* %9, i64 1
%13 = load i8, i8* %12
switch i8 %13, label %18 [
i8 0, label %87
i8 58, label %14
]
14: ; preds = %11
%15 = getelementptr inbounds i8, i8* %9, i64 2
%16 = load i8, i8* %15
%17 = icmp eq i8 %16, 0
br i1 %17, label %87, label %18
18: ; preds = %11, %14
%19 = phi i8 [ %16, %14 ], [ %13, %11 ]
%20 = phi i8* [ %15, %14 ], [ %12, %11 ]
%21 = icmp eq i8 %19, 40
br i1 %21, label %22, label %64
22: ; preds = %6, %18
%23 = phi i8* [ %9, %6 ], [ %20, %18 ]
br label %24
24: ; preds = %22, %60
%25 = phi i8* [ %62, %60 ], [ %23, %22 ]
%26 = getelementptr inbounds i8, i8* %25, i64 1
%27 = load i8, i8* %26
%28 = icmp eq i8 %27, 0
br i1 %28, label %64, label %29
29: ; preds = %24, %37
%30 = phi i8 [ %44, %37 ], [ %27, %24 ]
%31 = phi i8* [ %38, %37 ], [ %26, %24 ]
%32 = phi i8* [ %39, %37 ], [ %1, %24 ]
%33 = phi i32 [ %43, %37 ], [ 1, %24 ]
switch i8 %30, label %34 [
i8 41, label %45
i8 0, label %45
]
34: ; preds = %29
%35 = load i8, i8* %32
%36 = icmp eq i8 %35, 0
br i1 %36, label %45, label %37
37: ; preds = %34
%38 = getelementptr inbounds i8, i8* %31, i64 1
%39 = getelementptr inbounds i8, i8* %32, i64 1
%40 = icmp eq i8 %30, %35
%41 = icmp ne i32 %33, 0
%42 = select i1 %40, i1 %41, i1 false
%43 = zext i1 %42 to i32
%44 = load i8, i8* %38
br label %29
45: ; preds = %29, %29, %34
%46 = icmp eq i32 %33, 0
%47 = icmp eq i8 %30, 41
br i1 %46, label %55, label %48
48: ; preds = %45
br i1 %47, label %49, label %60
49: ; preds = %48
%50 = load i8, i8* %32
switch i8 %50, label %56 [
i8 0, label %51
i8 61, label %51
]
51: ; preds = %49, %49
%52 = icmp eq i8 %50, 61
%53 = getelementptr inbounds i8, i8* %32, i64 1
%54 = select i1 %52, i8* %53, i8* null
store i8* %54, i8** %2
br label %87
55: ; preds = %45
br i1 %47, label %56, label %60
56: ; preds = %49, %55
%57 = getelementptr inbounds i8, i8* %31, i64 1
%58 = load i8, i8* %57
%59 = icmp eq i8 %58, 0
br i1 %59, label %64, label %60
60: ; preds = %48, %56, %55
%61 = phi i8 [ %58, %56 ], [ %30, %55 ], [ %30, %48 ]
%62 = phi i8* [ %57, %56 ], [ %31, %55 ], [ %31, %48 ]
%63 = icmp eq i8 %61, 40
br i1 %63, label %24, label %64
64: ; preds = %60, %24, %56, %18
%65 = phi i8 [ %19, %18 ], [ 0, %56 ], [ 0, %24 ], [ %61, %60 ]
%66 = phi i8* [ %20, %18 ], [ %57, %56 ], [ %26, %24 ], [ %62, %60 ]
%67 = icmp ugt i8* %66, %0
br i1 %67, label %68, label %80
68: ; preds = %64
%69 = ptrtoint i8* %66 to i64
%70 = getelementptr i8, i8* %66, i64 %4
%71 = sub i64 0, %69
%72 = getelementptr i8, i8* %70, i64 %71
br label %73
73: ; preds = %68, %77
%74 = phi i8* [ %78, %77 ], [ %66, %68 ]
%75 = load i8, i8* %74
%76 = icmp eq i8 %75, 58
br i1 %76, label %77, label %83
77: ; preds = %73
%78 = getelementptr inbounds i8, i8* %74, i64 -1
%79 = icmp ugt i8* %78, %0
br i1 %79, label %73, label %80
80: ; preds = %77, %64
%81 = phi i8* [ %66, %64 ], [ %72, %77 ]
%82 = load i8, i8* %81
br label %83
83: ; preds = %73, %80
%84 = phi i8* [ %81, %80 ], [ %74, %73 ]
%85 = phi i8 [ %82, %80 ], [ %75, %73 ]
%86 = icmp eq i8 %85, 0
br i1 %86, label %87, label %6
87: ; preds = %11, %83, %14, %51
%88 = phi i8* [ %8, %51 ], [ null, %14 ], [ null, %83 ], [ null, %11 ]
ret i8* %88
}