#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 /*<<< orphan*/ time_t;
struct tm {
  int tm_hour;
  int tm_min;
  int tm_sec;
};
struct timeval {
  int tv_usec;
  int /*<<< orphan*/ tv_sec;
};

/* Variables and functions */
int atof(char *);
int atoi(char *);
int /*<<< orphan*/ mktime(struct tm *);
int pow(int, int);
int strlen(char *);
int /*<<< orphan*/ *strptime(char *, char *, struct tm *);
struct timeval makeTimevalStruct(char *hhmmss, char *datestr) {
  struct tm tm;
  time_t t;
  struct timeval timeStruct;
  char buf[11];
  buf[0] = datestr[0];
  buf[1] = datestr[1];
  buf[2] = '-';
  buf[3] = datestr[2];
  buf[4] = datestr[3];
  buf[5] = '-';
  if (datestr[4] == '9') {
    buf[6] = '1';
    buf[7] = '9';
  } else {
    buf[6] = '2';
    buf[7] = '0';
  }
  buf[8] = datestr[4];
  buf[9] = datestr[5];
  buf[10] = 0;
  char hourString[2];
  char minString[2];
  char secString[2];
  char fracSecString[6];
  int hour;
  int min;
  int sec;
  int fracSec;
  int fracSecIndex;
  int fracSecCopyIndex;
  if (strlen(hhmmss) > 5) {
    hourString[0] = hhmmss[0];
    hourString[1] = hhmmss[1];
    minString[0] = hhmmss[2];
    minString[1] = hhmmss[3];
    secString[0] = hhmmss[4];
    secString[1] = hhmmss[5];
    fracSecCopyIndex = 7;
  } else {
    hourString[0] = hhmmss[0];
    minString[0] = hhmmss[1];
    minString[1] = hhmmss[2];
    secString[0] = hhmmss[3];
    secString[1] = hhmmss[4];
    fracSecCopyIndex = 6;
  }
  hour = atoi(hourString);
  min = atoi(minString);
  sec = atoi(secString);
  tm.tm_hour = hour;
  tm.tm_min = min;
  tm.tm_sec = sec;
  if (strptime(buf, "%d-%m-%Y", &tm) != NULL) {
    t = mktime(&tm);
  }
  fracSecIndex = 0;
  while (hhmmss[fracSecCopyIndex] != 0) {
    fracSecString[fracSecIndex] = hhmmss[fracSecCopyIndex];
    fracSecCopyIndex++;
    fracSecIndex++;
  }
  fracSec = atof(fracSecString);
  fracSec = fracSec * pow(10, 6 - fracSecIndex);
  timeStruct.tv_sec = t;
  timeStruct.tv_usec = fracSec;
  return timeStruct;
}


x86 assembly (clang, -O0):
<makeTimevalStruct>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x37(%rbp)
mov    -0x18(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x36(%rbp)
movb   $0x2d,-0x35(%rbp)
mov    -0x18(%rbp),%rax
mov    0x2(%rax),%al
mov    %al,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    0x3(%rax),%al
mov    %al,-0x33(%rbp)
movb   $0x2d,-0x32(%rbp)
mov    -0x18(%rbp),%rax
movsbl 0x4(%rax),%eax
cmp    $0x39,%eax
jne    11bd <makeTimevalStruct+0x5d>
movb   $0x31,-0x31(%rbp)
movb   $0x39,-0x30(%rbp)
jmp    11c5 <makeTimevalStruct+0x65>
movb   $0x32,-0x31(%rbp)
movb   $0x30,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%al
mov    %al,-0x2f(%rbp)
mov    -0x18(%rbp),%rax
mov    0x5(%rax),%al
mov    %al,-0x2e(%rbp)
movb   $0x0,-0x2d(%rbp)
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
cmp    $0x5,%eax
jle    1236 <makeTimevalStruct+0xd6>
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x39(%rbp)
mov    -0x10(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2(%rax),%al
mov    %al,-0x3b(%rbp)
mov    -0x10(%rbp),%rax
mov    0x3(%rax),%al
mov    %al,-0x3a(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%al
mov    %al,-0x3d(%rbp)
mov    -0x10(%rbp),%rax
mov    0x5(%rax),%al
mov    %al,-0x3c(%rbp)
movl   $0x7,-0x5c(%rbp)
jmp    126e <makeTimevalStruct+0x10e>
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x39(%rbp)
mov    -0x10(%rbp),%rax
mov    0x1(%rax),%al
mov    %al,-0x3b(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2(%rax),%al
mov    %al,-0x3a(%rbp)
mov    -0x10(%rbp),%rax
mov    0x3(%rax),%al
mov    %al,-0x3d(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%al
mov    %al,-0x3c(%rbp)
movl   $0x6,-0x5c(%rbp)
lea    -0x39(%rbp),%rdi
call   1070 <atoi@plt>
mov    %eax,-0x48(%rbp)
lea    -0x3b(%rbp),%rdi
call   1070 <atoi@plt>
mov    %eax,-0x4c(%rbp)
lea    -0x3d(%rbp),%rdi
call   1070 <atoi@plt>
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x20(%rbp)
lea    -0x37(%rbp),%rdi
lea    0xd51(%rip),%rsi
lea    -0x28(%rbp),%rdx
call   1080 <strptime@plt>
cmp    $0x0,%rax
je     12ce <makeTimevalStruct+0x16e>
lea    -0x28(%rbp),%rdi
call   1050 <mktime@plt>
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1314 <makeTimevalStruct+0x1b4>
mov    -0x10(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x58(%rbp),%rax
mov    %cl,-0x43(%rbp,%rax,1)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12d5 <makeTimevalStruct+0x175>
lea    -0x43(%rbp),%rdi
call   1030 <atof@plt>
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    $0x6,%esi
sub    -0x58(%rbp),%esi
mov    $0xa,%edi
call   1060 <pow@plt>
mov    %eax,%ecx
mov    -0x60(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<makeTimevalStruct>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x38,%rsp
mov    %rdi,%rbx
mov    (%rsi),%al
mov    %al,0x15(%rsp)
mov    0x1(%rsi),%al
mov    %al,0x16(%rsp)
movb   $0x2d,0x17(%rsp)
mov    0x2(%rsi),%al
mov    %al,0x18(%rsp)
mov    0x3(%rsi),%al
mov    %al,0x19(%rsp)
movb   $0x2d,0x1a(%rsp)
mov    0x4(%rsi),%al
xor    %ecx,%ecx
cmp    $0x39,%al
sete   %cl
mov    $0x32,%dl
sub    %cl,%dl
lea    (%rcx,%rcx,8),%ecx
add    $0x30,%ecx
mov    %dl,0x1b(%rsp)
mov    %cl,0x1c(%rsp)
mov    %al,0x1d(%rsp)
mov    0x5(%rsi),%al
mov    %al,0x1e(%rsp)
movb   $0x0,0x1f(%rsp)
call   1040 <strlen@plt>
mov    (%rbx),%cl
mov    %cl,0x13(%rsp)
mov    0x1(%rbx),%cl
cmp    $0x6,%eax
jl     11ef <makeTimevalStruct+0x8f>
mov    %cl,0x14(%rsp)
mov    0x2(%rbx),%cl
mov    $0x7,%r15d
mov    $0x5,%eax
mov    $0x4,%edx
mov    $0x3,%esi
jmp    1204 <makeTimevalStruct+0xa4>
mov    $0x6,%r15d
mov    $0x4,%eax
mov    $0x3,%edx
mov    $0x2,%esi
mov    %cl,0x11(%rsp)
mov    (%rbx,%rsi,1),%cl
mov    %cl,0x12(%rsp)
mov    (%rbx,%rdx,1),%cl
mov    %cl,0xf(%rsp)
mov    (%rbx,%rax,1),%al
mov    %al,0x10(%rsp)
lea    0x13(%rsp),%rdi
call   1070 <atoi@plt>
mov    %eax,%r14d
lea    0x11(%rsp),%rdi
call   1070 <atoi@plt>
mov    %eax,%ebp
lea    0xf(%rsp),%rdi
call   1070 <atoi@plt>
mov    %r14d,0x20(%rsp)
mov    %ebp,0x24(%rsp)
mov    %eax,0x28(%rsp)
lea    0xdac(%rip),%rsi
lea    0x15(%rsp),%rdi
lea    0x20(%rsp),%rdx
call   1080 <strptime@plt>
test   %rax,%rax
je     127b <makeTimevalStruct+0x11b>
lea    0x20(%rsp),%rdi
call   1050 <mktime@plt>
mov    %eax,%r14d
shl    $0x20,%r14
jmp    127e <makeTimevalStruct+0x11e>
xor    %r14d,%r14d
mov    (%rbx,%r15,1),%cl
test   %cl,%cl
je     12a9 <makeTimevalStruct+0x149>
lea    (%r15,%rbx,1),%rdx
add    $0x1,%rdx
xor    %eax,%eax
mov    %cl,0x32(%rsp,%rax,1)
movzbl (%rdx,%rax,1),%ecx
add    $0x1,%rax
test   %cl,%cl
jne    1290 <makeTimevalStruct+0x130>
mov    $0x6,%ebx
sub    %eax,%ebx
jmp    12ae <makeTimevalStruct+0x14e>
mov    $0x6,%ebx
lea    0x32(%rsp),%rdi
call   1030 <atof@plt>
mov    %eax,%ebp
mov    $0xa,%edi
mov    %ebx,%esi
call   1060 <pow@plt>
imul   %ebp,%eax
or     %r14,%rax
add    $0x38,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.tm = type { i32, i32, i32 }
@.str = [9 x i8] c"%d-%m-%Y\00"
define i64 @makeTimevalStruct(i8* %0, i8* nocapture %1) {
%3 = alloca %struct.tm
%4 = alloca [11 x i8]
%5 = alloca [2 x i8]
%6 = alloca [2 x i8]
%7 = alloca [2 x i8]
%8 = alloca [6 x i8]
%9 = bitcast %struct.tm* %3 to i8*
%10 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 0
%11 = load i8, i8* %1
store i8 %11, i8* %10
%12 = getelementptr inbounds i8, i8* %1, i64 1
%13 = load i8, i8* %12
%14 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 1
store i8 %13, i8* %14
%15 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 2
store i8 45, i8* %15
%16 = getelementptr inbounds i8, i8* %1, i64 2
%17 = load i8, i8* %16
%18 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 3
store i8 %17, i8* %18
%19 = getelementptr inbounds i8, i8* %1, i64 3
%20 = load i8, i8* %19
%21 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 4
store i8 %20, i8* %21
%22 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 5
store i8 45, i8* %22
%23 = getelementptr inbounds i8, i8* %1, i64 4
%24 = load i8, i8* %23
%25 = icmp eq i8 %24, 57
%26 = select i1 %25, i8 49, i8 50
%27 = select i1 %25, i8 57, i8 48
%28 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 6
store i8 %26, i8* %28
%29 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 7
store i8 %27, i8* %29
%30 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 8
store i8 %24, i8* %30
%31 = getelementptr inbounds i8, i8* %1, i64 5
%32 = load i8, i8* %31
%33 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 9
store i8 %32, i8* %33
%34 = getelementptr inbounds [11 x i8], [11 x i8]* %4, i64 0, i64 10
store i8 0, i8* %34
%35 = getelementptr inbounds [2 x i8], [2 x i8]* %5, i64 0, i64 0
%36 = getelementptr inbounds [2 x i8], [2 x i8]* %6, i64 0, i64 0
%37 = getelementptr inbounds [2 x i8], [2 x i8]* %7, i64 0, i64 0
%38 = getelementptr inbounds [6 x i8], [6 x i8]* %8, i64 0, i64 0
%39 = tail call i32 @strlen(i8* %0)
%40 = icmp sgt i32 %39, 5
%41 = load i8, i8* %0
store i8 %41, i8* %35
%42 = getelementptr inbounds i8, i8* %0, i64 1
%43 = load i8, i8* %42
br i1 %40, label %44, label %48
44: ; preds = %2
%45 = getelementptr inbounds [2 x i8], [2 x i8]* %5, i64 0, i64 1
store i8 %43, i8* %45
%46 = getelementptr inbounds i8, i8* %0, i64 2
%47 = load i8, i8* %46
br label %48
48: ; preds = %2, %44
%49 = phi i8 [ %47, %44 ], [ %43, %2 ]
%50 = phi i64 [ 3, %44 ], [ 2, %2 ]
%51 = phi i64 [ 4, %44 ], [ 3, %2 ]
%52 = phi i64 [ 5, %44 ], [ 4, %2 ]
%53 = phi i64 [ 7, %44 ], [ 6, %2 ]
store i8 %49, i8* %36
%54 = getelementptr inbounds i8, i8* %0, i64 %50
%55 = load i8, i8* %54
%56 = getelementptr inbounds [2 x i8], [2 x i8]* %6, i64 0, i64 1
store i8 %55, i8* %56
%57 = getelementptr inbounds i8, i8* %0, i64 %51
%58 = load i8, i8* %57
store i8 %58, i8* %37
%59 = getelementptr inbounds i8, i8* %0, i64 %52
%60 = load i8, i8* %59
%61 = getelementptr inbounds [2 x i8], [2 x i8]* %7, i64 0, i64 1
store i8 %60, i8* %61
%62 = call i32 @atoi(i8* %35)
%63 = call i32 @atoi(i8* %36)
%64 = call i32 @atoi(i8* %37)
%65 = getelementptr inbounds %struct.tm, %struct.tm* %3, i64 0, i32 0
store i32 %62, i32* %65
%66 = getelementptr inbounds %struct.tm, %struct.tm* %3, i64 0, i32 1
store i32 %63, i32* %66
%67 = getelementptr inbounds %struct.tm, %struct.tm* %3, i64 0, i32 2
store i32 %64, i32* %67
%68 = call i32* @strptime(i8* %10, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0), %struct.tm* %3)
%69 = icmp eq i32* %68, null
br i1 %69, label %74, label %70
70: ; preds = %48
%71 = call i32 @mktime(%struct.tm* %3)
%72 = zext i32 %71 to i64
%73 = shl nuw i64 %72, 32
br label %74
74: ; preds = %70, %48
%75 = phi i64 [ %73, %70 ], [ 0, %48 ]
%76 = getelementptr inbounds i8, i8* %0, i64 %53
%77 = load i8, i8* %76
%78 = icmp eq i8 %77, 0
br i1 %78, label %92, label %79
79: ; preds = %74, %79
%80 = phi i64 [ %85, %79 ], [ 0, %74 ]
%81 = phi i64 [ %84, %79 ], [ %53, %74 ]
%82 = phi i8 [ %87, %79 ], [ %77, %74 ]
%83 = getelementptr inbounds [6 x i8], [6 x i8]* %8, i64 0, i64 %80
store i8 %82, i8* %83
%84 = add nuw nsw i64 %81, 1
%85 = add nuw i64 %80, 1
%86 = getelementptr inbounds i8, i8* %0, i64 %84
%87 = load i8, i8* %86
%88 = icmp eq i8 %87, 0
br i1 %88, label %89, label %79
89: ; preds = %79
%90 = trunc i64 %85 to i32
%91 = sub i32 6, %90
br label %92
92: ; preds = %89, %74
%93 = phi i32 [ 6, %74 ], [ %91, %89 ]
%94 = call i32 @atof(i8* %38)
%95 = call i32 @pow(i32 10, i32 %93)
%96 = mul nsw i32 %95, %94
%97 = zext i32 %96 to i64
%98 = or i64 %75, %97
ret i64 %98
}