#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 */
double atof(char *);
scalar_t__ isdigit(char const);
size_t strlen(char *);
double UTL_ConvertTimetoFloat(const char *time) {
  size_t i;
  char hour[3], minute[3], second[3], fracsec[7];
  const char *p;
  double divisor, hh, mm, ss, fs;
  hh = mm = ss = fs = 0.0;
  hour[0] = minute[0] = second[0] = fracsec[0] = '\000';
  p = time;
  hour[0] = *p++;
  hour[1] = *p++;
  hour[2] = '\000';
  if (isdigit(*p)) {
    minute[0] = *p++;
    minute[1] = *p++;
    minute[2] = '\000';
    if (isdigit(*p)) {
      second[0] = *p++;
      second[1] = *p++;
      second[2] = '\000';
      if (*p == '.') {
        p++;
        fracsec[0] = *p++;
        if ((*p != '\000') && (isdigit(*p))) {
          fracsec[1] = *p++;
          if ((*p != '\000') && (isdigit(*p))) {
            fracsec[2] = *p++;
            if ((*p != '\000') && (isdigit(*p))) {
              fracsec[3] = *p++;
              if ((*p != '\000') && (isdigit(*p))) {
                fracsec[4] = *p++;
                if ((*p != '\000') && (isdigit(*p))) {
                  fracsec[5] = *p++;
                  fracsec[6] = '\000';
                } else
                  fracsec[5] = '\000';
              } else
                fracsec[4] = '\000';
            } else
              fracsec[3] = '\000';
          } else
            fracsec[2] = '\000';
        } else
          fracsec[1] = '\000';
      }
    }
  }
  hh = atof(hour);
  mm = atof(minute);
  ss = atof(second);
  divisor = 1;
  for (i = 0; i < strlen(fracsec); i++)
    divisor *= 10;
  fs = atof(fracsec) / divisor;
  return ((hh * 3600.0) + (mm * 60.0) + ss + fs);
}


x86 assembly (clang, -O0):
<UTL_ConvertTimetoFloat>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movb   $0x0,-0x20(%rbp)
movb   $0x0,-0x19(%rbp)
movb   $0x0,-0x16(%rbp)
movb   $0x0,-0x13(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x13(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x12(%rbp)
movb   $0x0,-0x11(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     13b6 <UTL_ConvertTimetoFloat+0x286>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x16(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x15(%rbp)
movb   $0x0,-0x14(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     13b1 <UTL_ConvertTimetoFloat+0x281>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x19(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x18(%rbp)
movb   $0x0,-0x17(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    13ac <UTL_ConvertTimetoFloat+0x27c>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x20(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     13a3 <UTL_ConvertTimetoFloat+0x273>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     13a3 <UTL_ConvertTimetoFloat+0x273>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x1f(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     139a <UTL_ConvertTimetoFloat+0x26a>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     139a <UTL_ConvertTimetoFloat+0x26a>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x1e(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1391 <UTL_ConvertTimetoFloat+0x261>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1391 <UTL_ConvertTimetoFloat+0x261>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x1d(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1388 <UTL_ConvertTimetoFloat+0x258>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     1388 <UTL_ConvertTimetoFloat+0x258>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x1c(%rbp)
mov    -0x28(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     137f <UTL_ConvertTimetoFloat+0x24f>
mov    -0x28(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
je     137f <UTL_ConvertTimetoFloat+0x24f>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%al
mov    %al,-0x1b(%rbp)
movb   $0x0,-0x1a(%rbp)
jmp    1383 <UTL_ConvertTimetoFloat+0x253>
movb   $0x0,-0x1b(%rbp)
jmp    138c <UTL_ConvertTimetoFloat+0x25c>
movb   $0x0,-0x1c(%rbp)
jmp    1395 <UTL_ConvertTimetoFloat+0x265>
movb   $0x0,-0x1d(%rbp)
jmp    139e <UTL_ConvertTimetoFloat+0x26e>
movb   $0x0,-0x1e(%rbp)
jmp    13a7 <UTL_ConvertTimetoFloat+0x277>
movb   $0x0,-0x1f(%rbp)
jmp    13ac <UTL_ConvertTimetoFloat+0x27c>
jmp    13b1 <UTL_ConvertTimetoFloat+0x281>
jmp    13b6 <UTL_ConvertTimetoFloat+0x286>
lea    -0x13(%rbp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,-0x38(%rbp)
lea    -0x16(%rbp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,-0x40(%rbp)
lea    -0x19(%rbp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,-0x48(%rbp)
movsd  0xc18(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movq   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
lea    -0x20(%rbp),%rdi
call   1050 <strlen@plt>
mov    %rax,%rcx
mov    -0x58(%rbp),%rax
cmp    %rcx,%rax
jae    1439 <UTL_ConvertTimetoFloat+0x309>
movsd  0xbfa(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    13f5 <UTL_ConvertTimetoFloat+0x2c5>
lea    -0x20(%rbp),%rdi
call   1040 <atof@plt>
divsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  0xbb7(%rip),%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  0xba2(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x48(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<UTL_ConvertTimetoFloat>:
push   %r14
push   %rbx
sub    $0x38,%rsp
mov    %rdi,%rbx
movb   $0x0,0xe(%rsp)
movb   $0x0,0x8(%rsp)
movb   $0x0,0xb(%rsp)
mov    (%rdi),%al
mov    %al,0x15(%rsp)
mov    0x1(%rdi),%al
mov    %al,0x16(%rsp)
movb   $0x0,0x17(%rsp)
movsbl 0x2(%rdi),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     126f <UTL_ConvertTimetoFloat+0x13f>
mov    0x2(%rbx),%al
mov    %al,0xb(%rsp)
mov    0x3(%rbx),%al
mov    %al,0xc(%rsp)
movb   $0x0,0xd(%rsp)
movsbl 0x4(%rbx),%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     126f <UTL_ConvertTimetoFloat+0x13f>
mov    0x4(%rbx),%al
mov    %al,0x8(%rsp)
mov    0x5(%rbx),%al
mov    %al,0x9(%rsp)
movb   $0x0,0xa(%rsp)
cmpb   $0x2e,0x6(%rbx)
jne    126f <UTL_ConvertTimetoFloat+0x13f>
mov    0x7(%rbx),%al
mov    %al,0xe(%rsp)
mov    0x8(%rbx),%al
mov    $0x1,%r14d
test   %al,%al
je     1269 <UTL_ConvertTimetoFloat+0x139>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1269 <UTL_ConvertTimetoFloat+0x139>
mov    0x8(%rbx),%al
mov    %al,0xf(%rsp)
mov    0x9(%rbx),%al
mov    $0x2,%r14d
test   %al,%al
je     1269 <UTL_ConvertTimetoFloat+0x139>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1269 <UTL_ConvertTimetoFloat+0x139>
mov    0x9(%rbx),%al
mov    %al,0x10(%rsp)
mov    0xa(%rbx),%al
mov    $0x3,%r14d
test   %al,%al
je     1269 <UTL_ConvertTimetoFloat+0x139>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1269 <UTL_ConvertTimetoFloat+0x139>
mov    0xa(%rbx),%al
mov    %al,0x11(%rsp)
mov    0xb(%rbx),%al
mov    $0x4,%r14d
test   %al,%al
je     1269 <UTL_ConvertTimetoFloat+0x139>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1269 <UTL_ConvertTimetoFloat+0x139>
mov    0xb(%rbx),%al
mov    %al,0x12(%rsp)
mov    0xc(%rbx),%al
mov    $0x5,%r14d
test   %al,%al
je     1269 <UTL_ConvertTimetoFloat+0x139>
movsbl %al,%edi
call   1030 <isdigit@plt>
test   %rax,%rax
je     1269 <UTL_ConvertTimetoFloat+0x139>
mov    0xc(%rbx),%al
mov    %al,0x13(%rsp)
mov    $0x6,%r14d
movb   $0x0,0xe(%rsp,%r14,1)
lea    0x15(%rsp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,0x30(%rsp)
lea    0xb(%rsp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,0x28(%rsp)
lea    0x8(%rsp),%rdi
call   1040 <atof@plt>
movsd  %xmm0,0x20(%rsp)
lea    0xe(%rsp),%rdi
call   1050 <strlen@plt>
test   %rax,%rax
je     12c7 <UTL_ConvertTimetoFloat+0x197>
lea    -0x1(%rax),%rdx
mov    %eax,%ecx
and    $0x7,%ecx
cmp    $0x7,%rdx
jae    12d1 <UTL_ConvertTimetoFloat+0x1a1>
movsd  0xd3b(%rip),%xmm1
jmp    1316 <UTL_ConvertTimetoFloat+0x1e6>
movsd  0xd31(%rip),%xmm1
jmp    133a <UTL_ConvertTimetoFloat+0x20a>
and    $0xfffffffffffffff8,%rax
movsd  0xd23(%rip),%xmm1
movsd  0xd23(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
add    $0xfffffffffffffff8,%rax
jne    12f0 <UTL_ConvertTimetoFloat+0x1c0>
test   %rcx,%rcx
je     133a <UTL_ConvertTimetoFloat+0x20a>
movsd  0xce5(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulsd  %xmm0,%xmm1
add    $0xffffffffffffffff,%rcx
jne    1330 <UTL_ConvertTimetoFloat+0x200>
movsd  %xmm1,0x18(%rsp)
lea    0xe(%rsp),%rdi
call   1040 <atof@plt>
movsd  0x28(%rsp),%xmm2
mulsd  0xcb8(%rip),%xmm2
movsd  0x30(%rsp),%xmm1
mulsd  0xcb2(%rip),%xmm1
divsd  0x18(%rsp),%xmm0
addsd  %xmm2,%xmm1
movsd  0x20(%rsp),%xmm2
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x38,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define double @UTL_ConvertTimetoFloat(i8* nocapture %0) {
%2 = alloca [3 x i8]
%3 = alloca [3 x i8]
%4 = alloca [3 x i8]
%5 = alloca [7 x i8]
%6 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 0
%7 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 0
%8 = getelementptr inbounds [3 x i8], [3 x i8]* %4, i64 0, i64 0
%9 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 0
store i8 0, i8* %9
store i8 0, i8* %8
store i8 0, i8* %7
%10 = getelementptr inbounds i8, i8* %0, i64 1
%11 = load i8, i8* %0
store i8 %11, i8* %6
%12 = getelementptr inbounds i8, i8* %0, i64 2
%13 = load i8, i8* %10
%14 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 1
store i8 %13, i8* %14
%15 = getelementptr inbounds [3 x i8], [3 x i8]* %2, i64 0, i64 2
store i8 0, i8* %15
%16 = load i8, i8* %12
%17 = tail call i64 @isdigit(i8 signext %16)
%18 = icmp eq i64 %17, 0
br i1 %18, label %89, label %19
19: ; preds = %1
%20 = getelementptr inbounds i8, i8* %0, i64 3
%21 = load i8, i8* %12
store i8 %21, i8* %7
%22 = getelementptr inbounds i8, i8* %0, i64 4
%23 = load i8, i8* %20
%24 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 1
store i8 %23, i8* %24
%25 = getelementptr inbounds [3 x i8], [3 x i8]* %3, i64 0, i64 2
store i8 0, i8* %25
%26 = load i8, i8* %22
%27 = tail call i64 @isdigit(i8 signext %26)
%28 = icmp eq i64 %27, 0
br i1 %28, label %89, label %29
29: ; preds = %19
%30 = getelementptr inbounds i8, i8* %0, i64 5
%31 = load i8, i8* %22
store i8 %31, i8* %8
%32 = getelementptr inbounds i8, i8* %0, i64 6
%33 = load i8, i8* %30
%34 = getelementptr inbounds [3 x i8], [3 x i8]* %4, i64 0, i64 1
store i8 %33, i8* %34
%35 = getelementptr inbounds [3 x i8], [3 x i8]* %4, i64 0, i64 2
store i8 0, i8* %35
%36 = load i8, i8* %32
%37 = icmp eq i8 %36, 46
br i1 %37, label %38, label %89
38: ; preds = %29
%39 = getelementptr inbounds i8, i8* %0, i64 7
%40 = getelementptr inbounds i8, i8* %0, i64 8
%41 = load i8, i8* %39
store i8 %41, i8* %9
%42 = load i8, i8* %40
%43 = icmp eq i8 %42, 0
br i1 %43, label %86, label %44
44: ; preds = %38
%45 = tail call i64 @isdigit(i8 signext %42)
%46 = icmp eq i64 %45, 0
br i1 %46, label %86, label %47
47: ; preds = %44
%48 = getelementptr inbounds i8, i8* %0, i64 9
%49 = load i8, i8* %40
%50 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 1
store i8 %49, i8* %50
%51 = load i8, i8* %48
%52 = icmp eq i8 %51, 0
br i1 %52, label %86, label %53
53: ; preds = %47
%54 = tail call i64 @isdigit(i8 signext %51)
%55 = icmp eq i64 %54, 0
br i1 %55, label %86, label %56
56: ; preds = %53
%57 = getelementptr inbounds i8, i8* %0, i64 10
%58 = load i8, i8* %48
%59 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 2
store i8 %58, i8* %59
%60 = load i8, i8* %57
%61 = icmp eq i8 %60, 0
br i1 %61, label %86, label %62
62: ; preds = %56
%63 = tail call i64 @isdigit(i8 signext %60)
%64 = icmp eq i64 %63, 0
br i1 %64, label %86, label %65
65: ; preds = %62
%66 = getelementptr inbounds i8, i8* %0, i64 11
%67 = load i8, i8* %57
%68 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 3
store i8 %67, i8* %68
%69 = load i8, i8* %66
%70 = icmp eq i8 %69, 0
br i1 %70, label %86, label %71
71: ; preds = %65
%72 = tail call i64 @isdigit(i8 signext %69)
%73 = icmp eq i64 %72, 0
br i1 %73, label %86, label %74
74: ; preds = %71
%75 = getelementptr inbounds i8, i8* %0, i64 12
%76 = load i8, i8* %66
%77 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 4
store i8 %76, i8* %77
%78 = load i8, i8* %75
%79 = icmp eq i8 %78, 0
br i1 %79, label %86, label %80
80: ; preds = %74
%81 = tail call i64 @isdigit(i8 signext %78)
%82 = icmp eq i64 %81, 0
br i1 %82, label %86, label %83
83: ; preds = %80
%84 = load i8, i8* %75
%85 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 5
store i8 %84, i8* %85
br label %86
86: ; preds = %38, %44, %47, %53, %56, %62, %65, %71, %74, %80, %83
%87 = phi i64 [ 6, %83 ], [ 5, %80 ], [ 5, %74 ], [ 4, %71 ], [ 4, %65 ], [ 3, %62 ], [ 3, %56 ], [ 2, %53 ], [ 2, %47 ], [ 1, %44 ], [ 1, %38 ]
%88 = getelementptr inbounds [7 x i8], [7 x i8]* %5, i64 0, i64 %87
store i8 0, i8* %88
br label %89
89: ; preds = %86, %19, %29, %1
%90 = call double @atof(i8* %6)
%91 = call double @atof(i8* %7)
%92 = call double @atof(i8* %8)
%93 = call i64 @strlen(i8* %9)
%94 = icmp eq i64 %93, 0
br i1 %94, label %124, label %95
95: ; preds = %89
%96 = add i64 %93, -1
%97 = and i64 %93, 7
%98 = icmp ult i64 %96, 7
br i1 %98, label %114, label %99
99: ; preds = %95
%100 = and i64 %93, -8
br label %101
101: ; preds = %101, %99
%102 = phi double [ 1.000000e+00, %99 ], [ %111, %101 ]
%103 = phi i64 [ 0, %99 ], [ %112, %101 ]
%104 = fmul double %102, 1.000000e+01
%105 = fmul double %104, 1.000000e+01
%106 = fmul double %105, 1.000000e+01
%107 = fmul double %106, 1.000000e+01
%108 = fmul double %107, 1.000000e+01
%109 = fmul double %108, 1.000000e+01
%110 = fmul double %109, 1.000000e+01
%111 = fmul double %110, 1.000000e+01
%112 = add i64 %103, 8
%113 = icmp eq i64 %112, %100
br i1 %113, label %114, label %101
114: ; preds = %101, %95
%115 = phi double [ undef, %95 ], [ %111, %101 ]
%116 = phi double [ 1.000000e+00, %95 ], [ %111, %101 ]
%117 = icmp eq i64 %97, 0
br i1 %117, label %124, label %118
118: ; preds = %114, %118
%119 = phi double [ %121, %118 ], [ %116, %114 ]
%120 = phi i64 [ %122, %118 ], [ 0, %114 ]
%121 = fmul double %119, 1.000000e+01
%122 = add i64 %120, 1
%123 = icmp eq i64 %122, %97
br i1 %123, label %124, label %118
124: ; preds = %114, %118, %89
%125 = phi double [ 1.000000e+00, %89 ], [ %115, %114 ], [ %121, %118 ]
%126 = call double @atof(i8* %9)
%127 = fdiv double %126, %125
%128 = fmul double %91, 6.000000e+01
%129 = tail call double @llvm.fmuladd.f64(double %90, double 3.600000e+03, double %128)
%130 = fadd double %92, %129
%131 = fadd double %130, %127
ret double %131
}