#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*/ odp_scan_multi_line_comment(char **, char **, int);
int /*<<< orphan*/ odp_scan_until_char(char, char **, char **, int);
int odp_scan_until_marker(char **sql_ptr, char **dest_ptr, long len) {
  char *end = *sql_ptr + len;
  char c;
  for (; *sql_ptr < end; ++(*sql_ptr)) {
    c = **sql_ptr;
    *((*dest_ptr)++) = c;
    switch (c) {
    case '\\':
      if (*sql_ptr < end) {
        *((*dest_ptr)++) = *(++(*sql_ptr));
      }
      break;
    case '\'':
      ++(*sql_ptr);
      odp_scan_until_char('\'', sql_ptr, dest_ptr, end - *sql_ptr);
      break;
    case '"':
      ++(*sql_ptr);
      odp_scan_until_char('"', sql_ptr, dest_ptr, end - *sql_ptr);
      break;
    case '/':
      if ((*sql_ptr < end) && *(*sql_ptr + 1) == '*') {
        *((*dest_ptr)++) = *(++(*sql_ptr));
        ++(*sql_ptr);
        odp_scan_multi_line_comment(sql_ptr, dest_ptr, end - *sql_ptr);
      }
      break;
    case '#':
      ++(*sql_ptr);
      odp_scan_until_char('\n', sql_ptr, dest_ptr, end - *sql_ptr);
      break;
    case '-':
      if (((*sql_ptr + 1) < end) && *(*sql_ptr + 1) == '-' &&
          *(*sql_ptr + 2) == ' ') {
        ++(*sql_ptr);
        odp_scan_until_char('\n', sql_ptr, dest_ptr, end - *sql_ptr);
      }
      break;
    case '?':
      ++(*sql_ptr);
      --(*dest_ptr);
      return 1;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<odp_scan_until_marker>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmp    -0x28(%rbp),%rax
jae    13aa <odp_scan_until_marker+0x28a>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%cl
mov    -0x18(%rbp),%rdx
mov    (%rdx),%rax
mov    %rax,%rsi
add    $0x1,%rsi
mov    %rsi,(%rdx)
mov    %cl,(%rax)
movsbl -0x29(%rbp),%eax
add    $0xffffffde,%eax
mov    %eax,%ecx
mov    %rcx,-0x38(%rbp)
sub    $0x3a,%eax
ja     1392 <odp_scan_until_marker+0x272>
mov    -0x38(%rbp),%rax
lea    0xe69(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmp    -0x28(%rbp),%rax
jae    11d8 <odp_scan_until_marker+0xb8>
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,(%rcx)
mov    0x1(%rax),%cl
mov    -0x18(%rbp),%rdx
mov    (%rdx),%rax
mov    %rax,%rsi
add    $0x1,%rsi
mov    %rsi,(%rdx)
mov    %cl,(%rax)
jmp    1392 <odp_scan_until_marker+0x272>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0x27,%edi
call   1040 <odp_scan_until_char@plt>
jmp    1392 <odp_scan_until_marker+0x272>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0x22,%edi
call   1040 <odp_scan_until_char@plt>
jmp    1392 <odp_scan_until_marker+0x272>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
cmp    -0x28(%rbp),%rax
jae    12be <odp_scan_until_marker+0x19e>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2a,%eax
jne    12be <odp_scan_until_marker+0x19e>
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,(%rcx)
mov    0x1(%rax),%cl
mov    -0x18(%rbp),%rdx
mov    (%rdx),%rax
mov    %rax,%rsi
add    $0x1,%rsi
mov    %rsi,(%rdx)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
mov    %eax,%edx
call   1030 <odp_scan_multi_line_comment@plt>
jmp    1392 <odp_scan_until_marker+0x272>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0xa,%edi
call   1040 <odp_scan_until_char@plt>
jmp    1392 <odp_scan_until_marker+0x272>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
add    $0x1,%rax
cmp    -0x28(%rbp),%rax
jae    1365 <odp_scan_until_marker+0x245>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x1(%rax),%eax
cmp    $0x2d,%eax
jne    1365 <odp_scan_until_marker+0x245>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movsbl 0x2(%rax),%eax
cmp    $0x20,%eax
jne    1365 <odp_scan_until_marker+0x245>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%rcx
sub    %rcx,%rax
mov    %eax,%ecx
mov    $0xa,%edi
call   1040 <odp_scan_until_char@plt>
jmp    1392 <odp_scan_until_marker+0x272>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,(%rax)
movl   $0x1,-0x4(%rbp)
jmp    13b1 <odp_scan_until_marker+0x291>
jmp    1397 <odp_scan_until_marker+0x277>
mov    -0x10(%rbp),%rax
mov    (%rax),%rcx
add    $0x1,%rcx
mov    %rcx,(%rax)
jmp    1143 <odp_scan_until_marker+0x23>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<odp_scan_until_marker>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
xor    %r14d,%r14d
test   %rdx,%rdx
jle    1274 <odp_scan_until_marker+0x154>
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%rbp
mov    (%rdi),%rax
add    %rax,%r15
lea    0xeb6(%rip),%r12
jmp    1182 <odp_scan_until_marker+0x62>
mov    0x0(%rbp),%rax
add    $0x1,%rax
mov    %rax,0x0(%rbp)
mov    %r15d,%ecx
sub    %eax,%ecx
mov    $0x22,%edi
mov    %rbp,%rsi
mov    %rbx,%rdx
call   1040 <odp_scan_until_char@plt>
mov    0x0(%rbp),%rax
add    $0x1,%rax
mov    %rax,0x0(%rbp)
cmp    %r15,%rax
jae    1274 <odp_scan_until_marker+0x154>
movsbl (%rax),%eax
mov    (%rbx),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,(%rbx)
mov    %al,(%rcx)
add    $0xffffffde,%eax
cmp    $0x3a,%eax
ja     116d <odp_scan_until_marker+0x4d>
movslq (%r12,%rax,4),%rax
add    %r12,%rax
jmp    *%rax
mov    0x0(%rbp),%rax
add    $0x1,%rax
mov    %rax,0x0(%rbp)
mov    %r15d,%ecx
sub    %eax,%ecx
mov    $0xa,%edi
jmp    1162 <odp_scan_until_marker+0x42>
mov    0x0(%rbp),%rax
add    $0x1,%rax
mov    %rax,0x0(%rbp)
mov    %r15d,%ecx
sub    %eax,%ecx
mov    $0x27,%edi
jmp    1162 <odp_scan_until_marker+0x42>
mov    0x0(%rbp),%rcx
lea    0x1(%rcx),%rax
cmp    %r15,%rax
jae    116d <odp_scan_until_marker+0x4d>
cmpb   $0x2d,(%rax)
jne    116d <odp_scan_until_marker+0x4d>
cmpb   $0x20,0x2(%rcx)
jne    116d <odp_scan_until_marker+0x4d>
jmp    11aa <odp_scan_until_marker+0x8a>
mov    0x0(%rbp),%rax
cmp    %r15,%rax
jae    116d <odp_scan_until_marker+0x4d>
cmpb   $0x2a,0x1(%rax)
jne    116d <odp_scan_until_marker+0x4d>
add    $0x1,%rax
mov    %rax,0x0(%rbp)
movzbl (%rax),%eax
mov    (%rbx),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,(%rbx)
mov    %al,(%rcx)
mov    0x0(%rbp),%rax
add    $0x1,%rax
mov    %rax,0x0(%rbp)
mov    %r15d,%edx
sub    %eax,%edx
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1030 <odp_scan_multi_line_comment@plt>
jmp    116d <odp_scan_until_marker+0x4d>
mov    0x0(%rbp),%rax
cmp    %r15,%rax
jae    116d <odp_scan_until_marker+0x4d>
lea    0x1(%rax),%rcx
mov    %rcx,0x0(%rbp)
movzbl 0x1(%rax),%eax
mov    (%rbx),%rcx
lea    0x1(%rcx),%rdx
mov    %rdx,(%rbx)
mov    %al,(%rcx)
jmp    116d <odp_scan_until_marker+0x4d>
addq   $0x1,0x0(%rbp)
addq   $0xffffffffffffffff,(%rbx)
mov    $0x1,%r14d
mov    %r14d,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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