#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 */
typedef int uint8_t;
typedef int uint32_t;
typedef int uint16_t;

/* Variables and functions */
scalar_t__ isdigit(unsigned char);
uint32_t GPS_coord_to_degrees(const char *coordinateString) {
  const char *fieldSeparator, *remainingString;
  uint8_t degress = 0, minutes = 0;
  uint16_t fractionalMinutes = 0;
  uint8_t digitIndex;
  for (fieldSeparator = coordinateString;
       isdigit((unsigned char)*fieldSeparator); fieldSeparator++) {
    if (fieldSeparator >= coordinateString + 15)
      return 0;
  }
  remainingString = coordinateString;
  while ((fieldSeparator - remainingString) > 2) {
    if (degress)
      degress *= 10;
    degress += (*remainingString++ - '0');
  }
  while (fieldSeparator > remainingString) {
    if (minutes)
      minutes *= 10;
    minutes += (*remainingString++ - '0');
  }
  if (*fieldSeparator == '.') {
    remainingString = fieldSeparator + 1;
    for (digitIndex = 0; digitIndex < 4; digitIndex++) {
      fractionalMinutes *= 10;
      if (isdigit((unsigned char)*remainingString))
        fractionalMinutes += *remainingString++ - '0';
    }
  }
  return degress * 10000000UL +
         (minutes * 1000000UL + fractionalMinutes * 100UL) / 6;
}


x86 assembly (clang, -O0):
<GPS_coord_to_degrees>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1186 <GPS_coord_to_degrees+0x76>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    $0xf,%rcx
cmp    %rcx,%rax
jb     1170 <GPS_coord_to_degrees+0x60>
movl   $0x0,-0x4(%rbp)
jmp    12d1 <GPS_coord_to_degrees+0x1c1>
jmp    1175 <GPS_coord_to_degrees+0x65>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1139 <GPS_coord_to_degrees+0x29>
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
cmp    $0x2,%rax
jle    11d4 <GPS_coord_to_degrees+0xc4>
cmpl   $0x0,-0x24(%rbp)
je     11b4 <GPS_coord_to_degrees+0xa4>
imul   $0xa,-0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
sub    $0x30,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    118e <GPS_coord_to_degrees+0x7e>
jmp    11d9 <GPS_coord_to_degrees+0xc9>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1218 <GPS_coord_to_degrees+0x108>
cmpl   $0x0,-0x28(%rbp)
je     11f8 <GPS_coord_to_degrees+0xe8>
imul   $0xa,-0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
sub    $0x30,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    11d9 <GPS_coord_to_degrees+0xc9>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    1295 <GPS_coord_to_degrees+0x185>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x4,-0x30(%rbp)
jge    1290 <GPS_coord_to_degrees+0x180>
imul   $0xa,-0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     127d <GPS_coord_to_degrees+0x16d>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movsbl (%rax),%eax
sub    $0x30,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1282 <GPS_coord_to_degrees+0x172>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    123b <GPS_coord_to_degrees+0x12b>
jmp    1295 <GPS_coord_to_degrees+0x185>
movslq -0x24(%rbp),%rax
imul   $0x989680,%rax,%rax
mov    %rax,-0x38(%rbp)
movslq -0x28(%rbp),%rax
imul   $0xf4240,%rax,%rax
movslq -0x2c(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
mov    $0x6,%ecx
xor    %edx,%edx
div    %rcx
mov    %rax,%rcx
mov    -0x38(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<GPS_coord_to_degrees>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,%r13
movzbl (%rdi),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1258 <GPS_coord_to_degrees+0x148>
movzbl 0x1(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1266 <GPS_coord_to_degrees+0x156>
movzbl 0x2(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     126e <GPS_coord_to_degrees+0x15e>
movzbl 0x3(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     127f <GPS_coord_to_degrees+0x16f>
movzbl 0x4(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1287 <GPS_coord_to_degrees+0x177>
movzbl 0x5(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     128f <GPS_coord_to_degrees+0x17f>
movzbl 0x6(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1297 <GPS_coord_to_degrees+0x187>
movzbl 0x7(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     129f <GPS_coord_to_degrees+0x18f>
movzbl 0x8(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12a7 <GPS_coord_to_degrees+0x197>
movzbl 0x9(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12af <GPS_coord_to_degrees+0x19f>
movzbl 0xa(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12b7 <GPS_coord_to_degrees+0x1a7>
movzbl 0xb(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12bf <GPS_coord_to_degrees+0x1af>
movzbl 0xc(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12c7 <GPS_coord_to_degrees+0x1b7>
movzbl 0xd(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12cf <GPS_coord_to_degrees+0x1bf>
movzbl 0xe(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     12d7 <GPS_coord_to_degrees+0x1c7>
movzbl 0xf(%r13),%edi
call   1030 <isdigit@plt>
xor    %r14d,%r14d
test   %rax,%rax
jne    14c5 <GPS_coord_to_degrees+0x3b5>
mov    $0xf,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
xor    %r8d,%r8d
mov    %r13,%rax
xor    %r14d,%r14d
jmp    1372 <GPS_coord_to_degrees+0x262>
mov    $0x1,%r8d
jmp    1274 <GPS_coord_to_degrees+0x164>
mov    $0x2,%r8d
xor    %r14d,%r14d
mov    %r13,%rax
jmp    1372 <GPS_coord_to_degrees+0x262>
mov    $0x3,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0x4,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0x5,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0x6,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0x7,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0x8,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0x9,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0xa,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0xb,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0xc,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0xd,%r8d
jmp    12dd <GPS_coord_to_degrees+0x1cd>
mov    $0xe,%r8d
lea    -0x2(%r8),%rax
lea    -0x3(%r8),%rcx
mov    %eax,%edx
and    $0x3,%edx
cmp    $0x3,%rcx
jae    12f7 <GPS_coord_to_degrees+0x1e7>
xor    %edi,%edi
mov    %r13,%rsi
jmp    1347 <GPS_coord_to_degrees+0x237>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
xor    %edi,%edi
mov    %r13,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rdi,%rdi,4),%edi
movsbl (%rsi),%ebx
lea    (%rbx,%rdi,2),%edi
lea    (%rdi,%rdi,4),%edi
movsbl 0x1(%rsi),%ebx
lea    (%rbx,%rdi,2),%edi
lea    (%rdi,%rdi,4),%edi
movsbl 0x2(%rsi),%ebx
lea    (%rbx,%rdi,2),%edi
lea    (%rdi,%rdi,4),%edi
movsbl 0x3(%rsi),%ebx
add    $0x4,%rsi
lea    (%rbx,%rdi,2),%edi
add    $0xffff2fb0,%edi
add    $0xfffffffffffffffc,%rcx
jne    1310 <GPS_coord_to_degrees+0x200>
test   %rdx,%rdx
je     1366 <GPS_coord_to_degrees+0x256>
xor    %ecx,%ecx
xchg   %ax,%ax
lea    (%rdi,%rdi,4),%edi
movsbl (%rsi,%rcx,1),%ebx
lea    (%rbx,%rdi,2),%edi
add    $0xffffffd0,%edi
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1350 <GPS_coord_to_degrees+0x240>
add    %r13,%rax
mov    %edi,%ecx
imul   $0x989680,%rcx,%r14
add    %r8,%r13
xor    %r15d,%r15d
mov    %r13,%rdx
sub    %rax,%rdx
jbe    1398 <GPS_coord_to_degrees+0x288>
mov    %rax,%rsi
not    %rsi
add    %r13,%rsi
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x3,%rsi
jae    13a7 <GPS_coord_to_degrees+0x297>
xor    %esi,%esi
jmp    13e7 <GPS_coord_to_degrees+0x2d7>
xor    %r12d,%r12d
cmpb   $0x2e,0x0(%r13)
je     141b <GPS_coord_to_degrees+0x30b>
jmp    14a7 <GPS_coord_to_degrees+0x397>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopl   (%rax)
lea    (%rsi,%rsi,4),%esi
movsbl (%rax),%edi
lea    (%rdi,%rsi,2),%esi
lea    (%rsi,%rsi,4),%esi
movsbl 0x1(%rax),%edi
lea    (%rdi,%rsi,2),%esi
lea    (%rsi,%rsi,4),%esi
movsbl 0x2(%rax),%edi
lea    (%rdi,%rsi,2),%esi
lea    (%rsi,%rsi,4),%esi
movsbl 0x3(%rax),%edi
add    $0x4,%rax
lea    (%rdi,%rsi,2),%esi
add    $0xffff2fb0,%esi
add    $0xfffffffffffffffc,%rdx
jne    13b0 <GPS_coord_to_degrees+0x2a0>
test   %rcx,%rcx
je     1406 <GPS_coord_to_degrees+0x2f6>
xor    %edx,%edx
xchg   %ax,%ax
lea    (%rsi,%rsi,4),%esi
movsbl (%rax,%rdx,1),%edi
lea    (%rdi,%rsi,2),%esi
add    $0xffffffd0,%esi
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    13f0 <GPS_coord_to_degrees+0x2e0>
movslq %esi,%rax
imul   $0xf4240,%rax,%r12
cmpb   $0x2e,0x0(%r13)
jne    14a7 <GPS_coord_to_degrees+0x397>
movzbl 0x1(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1441 <GPS_coord_to_degrees+0x331>
movsbl 0x1(%r13),%eax
add    $0x2,%r13
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,1),%ebx
add    $0xfffffe20,%ebx
jmp    1447 <GPS_coord_to_degrees+0x337>
add    $0x1,%r13
xor    %ebx,%ebx
movzbl 0x0(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1464 <GPS_coord_to_degrees+0x354>
movsbl 0x0(%r13),%eax
add    $0x1,%r13
add    %eax,%ebx
add    $0xffffffd0,%ebx
add    %ebx,%ebx
lea    (%rbx,%rbx,4),%ebx
movzbl 0x0(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1486 <GPS_coord_to_degrees+0x376>
movsbl 0x0(%r13),%eax
add    $0x1,%r13
add    %eax,%ebx
add    $0xffffffd0,%ebx
add    %ebx,%ebx
lea    (%rbx,%rbx,4),%r15d
movzbl 0x0(%r13),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     14a7 <GPS_coord_to_degrees+0x397>
movsbl 0x0(%r13),%eax
add    %eax,%r15d
add    $0xffffffd0,%r15d
movslq %r15d,%rax
imul   $0x64,%rax,%rax
add    %r12,%rax
movabs $0xaaaaaaaaaaaaaaab,%rcx
aa aa aa
mul    %rcx
shr    $0x2,%rdx
add    %edx,%r14d
mov    %r14d,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define i32 @GPS_coord_to_degrees(i8* %0) {
%2 = alloca i32
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i8* %0, i8** %3
store i32 0, i32* %6
store i32 0, i32* %7
store i32 0, i32* %8
%10 = load i8*, i8** %3
store i8* %10, i8** %4
br label %11
11: ; preds = %23, %1
%12 = load i8*, i8** %4
%13 = load i8, i8* %12
%14 = call i64 @isdigit(i8 zeroext %13)
%15 = icmp ne i64 %14, 0
br i1 %15, label %16, label %26
16: ; preds = %11
%17 = load i8*, i8** %4
%18 = load i8*, i8** %3
%19 = getelementptr inbounds i8, i8* %18, i64 15
%20 = icmp uge i8* %17, %19
br i1 %20, label %21, label %22
21: ; preds = %16
store i32 0, i32* %2
br label %113
22: ; preds = %16
br label %23
23: ; preds = %22
%24 = load i8*, i8** %4
%25 = getelementptr inbounds i8, i8* %24, i32 1
store i8* %25, i8** %4
br label %11
26: ; preds = %11
%27 = load i8*, i8** %3
store i8* %27, i8** %5
br label %28
28: ; preds = %41, %26
%29 = load i8*, i8** %4
%30 = load i8*, i8** %5
%31 = ptrtoint i8* %29 to i64
%32 = ptrtoint i8* %30 to i64
%33 = sub i64 %31, %32
%34 = icmp sgt i64 %33, 2
br i1 %34, label %35, label %49
35: ; preds = %28
%36 = load i32, i32* %6
%37 = icmp ne i32 %36, 0
br i1 %37, label %38, label %41
38: ; preds = %35
%39 = load i32, i32* %6
%40 = mul nsw i32 %39, 10
store i32 %40, i32* %6
br label %41
41: ; preds = %38, %35
%42 = load i8*, i8** %5
%43 = getelementptr inbounds i8, i8* %42, i32 1
store i8* %43, i8** %5
%44 = load i8, i8* %42
%45 = sext i8 %44 to i32
%46 = sub nsw i32 %45, 48
%47 = load i32, i32* %6
%48 = add nsw i32 %47, %46
store i32 %48, i32* %6
br label %28
49: ; preds = %28
br label %50
50: ; preds = %60, %49
%51 = load i8*, i8** %4
%52 = load i8*, i8** %5
%53 = icmp ugt i8* %51, %52
br i1 %53, label %54, label %68
54: ; preds = %50
%55 = load i32, i32* %7
%56 = icmp ne i32 %55, 0
br i1 %56, label %57, label %60
57: ; preds = %54
%58 = load i32, i32* %7
%59 = mul nsw i32 %58, 10
store i32 %59, i32* %7
br label %60
60: ; preds = %57, %54
%61 = load i8*, i8** %5
%62 = getelementptr inbounds i8, i8* %61, i32 1
store i8* %62, i8** %5
%63 = load i8, i8* %61
%64 = sext i8 %63 to i32
%65 = sub nsw i32 %64, 48
%66 = load i32, i32* %7
%67 = add nsw i32 %66, %65
store i32 %67, i32* %7
br label %50
68: ; preds = %50
%69 = load i8*, i8** %4
%70 = load i8, i8* %69
%71 = sext i8 %70 to i32
%72 = icmp eq i32 %71, 46
br i1 %72, label %73, label %99
73: ; preds = %68
%74 = load i8*, i8** %4
%75 = getelementptr inbounds i8, i8* %74, i64 1
store i8* %75, i8** %5
store i32 0, i32* %9
br label %76
76: ; preds = %95, %73
%77 = load i32, i32* %9
%78 = icmp slt i32 %77, 4
br i1 %78, label %79, label %98
79: ; preds = %76
%80 = load i32, i32* %8
%81 = mul nsw i32 %80, 10
store i32 %81, i32* %8
%82 = load i8*, i8** %5
%83 = load i8, i8* %82
%84 = call i64 @isdigit(i8 zeroext %83)
%85 = icmp ne i64 %84, 0
br i1 %85, label %86, label %94
86: ; preds = %79
%87 = load i8*, i8** %5
%88 = getelementptr inbounds i8, i8* %87, i32 1
store i8* %88, i8** %5
%89 = load i8, i8* %87
%90 = sext i8 %89 to i32
%91 = sub nsw i32 %90, 48
%92 = load i32, i32* %8
%93 = add nsw i32 %92, %91
store i32 %93, i32* %8
br label %94
94: ; preds = %86, %79
br label %95
95: ; preds = %94
%96 = load i32, i32* %9
%97 = add nsw i32 %96, 1
store i32 %97, i32* %9
br label %76
98: ; preds = %76
br label %99
99: ; preds = %98, %68
%100 = load i32, i32* %6
%101 = sext i32 %100 to i64
%102 = mul i64 %101, 10000000
%103 = load i32, i32* %7
%104 = sext i32 %103 to i64
%105 = mul i64 %104, 1000000
%106 = load i32, i32* %8
%107 = sext i32 %106 to i64
%108 = mul i64 %107, 100
%109 = add i64 %105, %108
%110 = udiv i64 %109, 6
%111 = add i64 %102, %110
%112 = trunc i64 %111 to i32
store i32 %112, i32* %2
br label %113
113: ; preds = %99, %21
%114 = load i32, i32* %2
ret i32 %114
}

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