#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 timespec {
  long tv_sec;
  scalar_t__ tv_nsec;
};

/* Variables and functions */
int /*<<< orphan*/ clock_gettime(int, struct timespec *);
char *ctime(int /*<<< orphan*/ *);
int /*<<< orphan*/ fflush(int /*<<< orphan*/);
int /*<<< orphan*/ in_order(struct timespec, struct timespec);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ time(int /*<<< orphan*/);
int consistency_test(int clock_type, unsigned long seconds) {
  struct timespec list[64];
  int i, inconsistent;
  long now, then;
  time_t t;
  char *start_str;
  clock_gettime(clock_type, &list[0]);
  now = then = list[0].tv_sec;
  t = time(0);
  start_str = ctime(&t);
  while (seconds == -1 || now - then < seconds) {
    inconsistent = -1;
    for (i = 0; i < 64; i++)
      clock_gettime(clock_type, &list[i]);
    for (i = 0; i < 64 - 1; i++)
      if (!in_order(list[i], list[i + 1]))
        inconsistent = i;
    if (inconsistent >= 0) {
      unsigned long long delta;
      printf("\%s\n", start_str);
      for (i = 0; i < 64; i++) {
        if (i == inconsistent)
          printf("--------------------\n");
        printf("%lu:%lu\n", list[i].tv_sec, list[i].tv_nsec);
        if (i == inconsistent + 1)
          printf("--------------------\n");
      }
      delta = list[inconsistent].tv_sec * 1000000000ULL;
      delta += list[inconsistent].tv_nsec;
      delta -= list[inconsistent + 1].tv_sec * 1000000000ULL;
      delta -= list[inconsistent + 1].tv_nsec;
      printf("Delta: %llu ns\n", delta);
      fflush(0);
      t = time(0);
      printf("%s\n", ctime(&t));
      printf("[FAILED]\n");
      return -1;
    }
    now = list[0].tv_sec;
  }
  printf("[OK]\n");
  return 0;
}


x86 assembly (clang, -O0):
<consistency_test>:
push   %rbp
mov    %rsp,%rbp
sub    $0x450,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%edi
lea    -0x410(%rbp),%rsi
call   1030 <clock_gettime@plt>
mov    -0x410(%rbp),%rax
mov    %rax,-0x428(%rbp)
mov    %rax,-0x420(%rbp)
xor    %edi,%edi
call   1060 <time@plt>
mov    %eax,-0x42c(%rbp)
lea    -0x42c(%rbp),%rdi
call   1040 <ctime@plt>
mov    %rax,-0x438(%rbp)
mov    $0x1,%al
cmpq   $0xffffffffffffffff,-0x10(%rbp)
mov    %al,-0x441(%rbp)
je     11e4 <consistency_test+0x84>
mov    -0x420(%rbp),%rax
sub    -0x428(%rbp),%rax
cmp    -0x10(%rbp),%rax
setb   %al
mov    %al,-0x441(%rbp)
mov    -0x441(%rbp),%al
test   $0x1,%al
jne    11f7 <consistency_test+0x97>
jmp    14c4 <consistency_test+0x364>
movl   $0xffffffff,-0x418(%rbp)
ff ff ff
movl   $0x0,-0x414(%rbp)
cmpl   $0x40,-0x414(%rbp)
jge    1249 <consistency_test+0xe9>
mov    -0x8(%rbp),%edi
movslq -0x414(%rbp),%rax
lea    -0x410(%rbp),%rsi
shl    $0x4,%rax
add    %rax,%rsi
call   1030 <clock_gettime@plt>
mov    -0x414(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x414(%rbp)
jmp    120b <consistency_test+0xab>
movl   $0x0,-0x414(%rbp)
cmpl   $0x3f,-0x414(%rbp)
jge    12d0 <consistency_test+0x170>
movslq -0x414(%rbp),%rax
lea    -0x410(%rbp),%rcx
shl    $0x4,%rax
add    %rax,%rcx
mov    -0x414(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rdx
lea    -0x410(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    (%rcx),%rdi
mov    0x8(%rcx),%rsi
mov    (%rax),%rdx
mov    0x8(%rax),%rcx
call   1080 <in_order@plt>
cmp    $0x0,%eax
jne    12b7 <consistency_test+0x157>
mov    -0x414(%rbp),%eax
mov    %eax,-0x418(%rbp)
jmp    12bc <consistency_test+0x15c>
mov    -0x414(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x414(%rbp)
jmp    1253 <consistency_test+0xf3>
cmpl   $0x0,-0x418(%rbp)
jl     14b1 <consistency_test+0x351>
mov    -0x438(%rbp),%rsi
lea    0xd15(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x414(%rbp)
cmpl   $0x40,-0x414(%rbp)
jge    13a6 <consistency_test+0x246>
mov    -0x414(%rbp),%eax
cmp    -0x418(%rbp),%eax
jne    1329 <consistency_test+0x1c9>
lea    0xce2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movslq -0x414(%rbp),%rcx
lea    -0x410(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%rsi
movslq -0x414(%rbp),%rcx
lea    -0x410(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rdx
lea    0xcb9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x414(%rbp),%eax
mov    -0x418(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    138d <consistency_test+0x22d>
lea    0xc7e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1392 <consistency_test+0x232>
mov    -0x414(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x414(%rbp)
jmp    12fc <consistency_test+0x19c>
movslq -0x418(%rbp),%rcx
lea    -0x410(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
imul   $0x3b9aca00,(%rax),%rax
mov    %rax,-0x440(%rbp)
movslq -0x418(%rbp),%rcx
lea    -0x410(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rax
add    -0x440(%rbp),%rax
mov    %rax,-0x440(%rbp)
mov    -0x418(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x410(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
imul   $0x3b9aca00,(%rax),%rcx
mov    -0x440(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x440(%rbp)
mov    -0x418(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x410(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%rcx
mov    -0x440(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x440(%rbp)
mov    -0x440(%rbp),%rsi
lea    0xbc4(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
xor    %edi,%edi
call   1070 <fflush@plt>
xor    %edi,%edi
call   1060 <time@plt>
mov    %eax,-0x42c(%rbp)
lea    -0x42c(%rbp),%rdi
call   1040 <ctime@plt>
mov    %rax,%rsi
lea    0xb70(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xb95(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    14d9 <consistency_test+0x379>
mov    -0x410(%rbp),%rax
mov    %rax,-0x420(%rbp)
jmp    11b6 <consistency_test+0x56>
lea    0xb72(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x450,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<consistency_test>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x428,%rsp
mov    %rsi,%r12
mov    %edi,%ebp
lea    0x20(%rsp),%rsi
call   1040 <clock_gettime@plt>
mov    0x20(%rsp),%rax
mov    %rax,0x10(%rsp)
xor    %ebx,%ebx
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,0xc(%rsp)
lea    0xc(%rsp),%rdi
call   1050 <ctime@plt>
lea    0xe61(%rip),%rdi
test   %r12,%r12
je     1329 <consistency_test+0x1b9>
mov    %rax,0x18(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rax
shl    $0x4,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x20,%rsi
mov    %ebp,%edi
call   1040 <clock_gettime@plt>
add    $0x1,%rbx
cmp    $0x40,%rbx
jne    11d0 <consistency_test+0x60>
mov    $0xffffffff,%ebx
lea    0x38(%rsp),%r15
xor    %r13d,%r13d
nopl   (%rax)
lea    0x1(%r13),%r14
mov    -0x18(%r15),%rdi
mov    -0x10(%r15),%rsi
mov    -0x8(%r15),%rdx
mov    (%r15),%rcx
call   1090 <in_order@plt>
test   %eax,%eax
cmove  %r13d,%ebx
add    $0x10,%r15
mov    %r14,%r13
cmp    $0x3f,%r14
jne    1200 <consistency_test+0x90>
test   %ebx,%ebx
jns    1252 <consistency_test+0xe2>
xor    %ebx,%ebx
cmp    $0xffffffffffffffff,%r12
je     11d0 <consistency_test+0x60>
mov    0x20(%rsp),%rax
sub    0x10(%rsp),%rax
cmp    %r12,%rax
jb     11d0 <consistency_test+0x60>
lea    0xdcc(%rip),%rdi
jmp    1329 <consistency_test+0x1b9>
mov    0x18(%rsp),%rdi
call   1030 <puts@plt>
lea    0x1(%rbx),%eax
mov    %eax,0x10(%rsp)
mov    %ebx,%ebp
shl    $0x4,%rbp
lea    0x10(%rbp),%r13
lea    0xdb3(%rip),%r14
lea    0xd85(%rip),%r12
xor    %r15d,%r15d
jmp    128d <consistency_test+0x11d>
add    $0x10,%r15
cmp    $0x400,%r15
je     12bd <consistency_test+0x14d>
cmp    %r15,%rbp
jne    129a <consistency_test+0x12a>
mov    %r14,%rdi
call   1030 <puts@plt>
mov    0x20(%rsp,%r15,1),%rsi
mov    0x28(%rsp,%r15,1),%rdx
mov    %r12,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
cmp    %r15,%r13
jne    1280 <consistency_test+0x110>
mov    %r14,%rdi
call   1030 <puts@plt>
jmp    1280 <consistency_test+0x110>
movslq %ebx,%rax
shl    $0x4,%rax
mov    0x20(%rsp,%rax,1),%rcx
mov    0x28(%rsp,%rax,1),%rsi
movslq 0x10(%rsp),%rax
shl    $0x4,%rax
sub    0x20(%rsp,%rax,1),%rcx
imul   $0x3b9aca00,%rcx,%rcx
sub    0x28(%rsp,%rax,1),%rsi
add    %rcx,%rsi
lea    0xd17(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
xor    %edi,%edi
call   1080 <fflush@plt>
xor    %edi,%edi
call   1070 <time@plt>
mov    %eax,0xc(%rsp)
lea    0xc(%rsp),%rdi
call   1050 <ctime@plt>
mov    %rax,%rdi
call   1030 <puts@plt>
mov    $0xffffffff,%ebx
lea    0xcf5(%rip),%rdi
call   1030 <puts@plt>
mov    %ebx,%eax
add    $0x428,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
%struct.timespec = type { i64, i64 }
@.str.2 = [9 x i8] c"%lu:%lu\0A\00"
@.str.3 = [16 x i8] c"Delta: %llu ns\0A\00"
@str = [5 x i8] c"[OK]\00"
@str.6 = [9 x i8] c"[FAILED]\00"
@str.8 = [21 x i8] c"--------------------\00"
define i32 @consistency_test(i32 %0, i64 %1) {
%3 = alloca [64 x %struct.timespec]
%4 = alloca i32
%5 = bitcast [64 x %struct.timespec]* %3 to i8*
%6 = bitcast i32* %4 to i8*
%7 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 0
%8 = call i32 @clock_gettime(i32 %0, %struct.timespec* %7)
%9 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 0, i32 0
%10 = load i64, i64* %9
%11 = call i32 @time(i32 0)
store i32 %11, i32* %4
%12 = call i8* @ctime(i32* %4)
%13 = icmp eq i64 %1, -1
%14 = icmp eq i64 %1, 0
br i1 %14, label %89, label %15
15: ; preds = %2, %21
%16 = phi i64 [ %22, %21 ], [ 0, %2 ]
%17 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %16
%18 = call i32 @clock_gettime(i32 %0, %struct.timespec* %17)
%19 = add nuw nsw i64 %16, 1
%20 = icmp eq i64 %19, 64
br i1 %20, label %23, label %21
21: ; preds = %15, %84
%22 = phi i64 [ %19, %15 ], [ 0, %84 ]
br label %15
23: ; preds = %15, %23
%24 = phi i64 [ %26, %23 ], [ 0, %15 ]
%25 = phi i32 [ %38, %23 ], [ -1, %15 ]
%26 = add nuw nsw i64 %24, 1
%27 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %24, i32 0
%28 = load i64, i64* %27
%29 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %24, i32 1
%30 = load i64, i64* %29
%31 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %26, i32 0
%32 = load i64, i64* %31
%33 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %26, i32 1
%34 = load i64, i64* %33
%35 = call i32 @in_order(i64 %28, i64 %30, i64 %32, i64 %34)
%36 = icmp eq i32 %35, 0
%37 = trunc i64 %24 to i32
%38 = select i1 %36, i32 %37, i32 %25
%39 = icmp eq i64 %26, 63
br i1 %39, label %40, label %23
40: ; preds = %23
%41 = icmp sgt i32 %38, -1
br i1 %41, label %42, label %84
42: ; preds = %40
%43 = call i32 @puts(i8* dereferenceable(1) %12)
%44 = add nuw nsw i32 %38, 1
%45 = zext i32 %38 to i64
%46 = zext i32 %44 to i64
br label %47
47: ; preds = %42, %61
%48 = phi i64 [ 0, %42 ], [ %62, %61 ]
%49 = icmp eq i64 %48, %45
br i1 %49, label %50, label %52
50: ; preds = %47
%51 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.8, i64 0, i64 0))
br label %52
52: ; preds = %50, %47
%53 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %48, i32 0
%54 = load i64, i64* %53
%55 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %48, i32 1
%56 = load i64, i64* %55
%57 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.2, i64 0, i64 0), i64 %54, i64 %56)
%58 = icmp eq i64 %48, %46
br i1 %58, label %59, label %61
59: ; preds = %52
%60 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @str.8, i64 0, i64 0))
br label %61
61: ; preds = %52, %59
%62 = add nuw nsw i64 %48, 1
%63 = icmp eq i64 %62, 64
br i1 %63, label %64, label %47
64: ; preds = %61
%65 = sext i32 %38 to i64
%66 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %65, i32 0
%67 = load i64, i64* %66
%68 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %65, i32 1
%69 = load i64, i64* %68
%70 = sext i32 %44 to i64
%71 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %70, i32 0
%72 = load i64, i64* %71
%73 = getelementptr inbounds [64 x %struct.timespec], [64 x %struct.timespec]* %3, i64 0, i64 %70, i32 1
%74 = load i64, i64* %73
%75 = sub i64 %67, %72
%76 = mul i64 %75, 1000000000
%77 = sub i64 %69, %74
%78 = add i64 %77, %76
%79 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0), i64 %78)
%80 = call i32 @fflush(i32 0)
%81 = call i32 @time(i32 0)
store i32 %81, i32* %4
%82 = call i8* @ctime(i32* %4)
%83 = call i32 @puts(i8* dereferenceable(1) %82)
br label %89
84: ; preds = %40
%85 = load i64, i64* %9
%86 = sub nsw i64 %85, %10
%87 = icmp ult i64 %86, %1
%88 = select i1 %13, i1 true, i1 %87
br i1 %88, label %21, label %89
89: ; preds = %84, %2, %64
%90 = phi i8* [ getelementptr inbounds ([9 x i8], [9 x i8]* @str.6, i64 0, i64 0), %64 ], [ getelementptr inbounds ([5 x i8], [5 x i8]* @str, i64 0, i64 0), %2 ], [ getelementptr inbounds ([5 x i8], [5 x i8]* @str, i64 0, i64 0), %84 ]
%91 = phi i32 [ -1, %64 ], [ 0, %2 ], [ 0, %84 ]
%92 = call i32 @puts(i8* dereferenceable(1) %90)
ret i32 %91
}