#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 */
struct timeval {
  long tv_sec;
  long tv_usec;
};

/* Variables and functions */
int /*<<< orphan*/ free(unsigned int *);
int /*<<< orphan*/ gettimeofday(struct timeval *, int /*<<< orphan*/ *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memcpy(void *, unsigned int *, int);
int /*<<< orphan*/ memset(void *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, ...);
void performSpeedTest(void *fb, int fbSize) {
  int i, j, run;
  struct timeval startTime, endTime;
  unsigned long long results[5];
  unsigned long long average;
  unsigned int *testImage;
  unsigned int randData[17] = {
      0x3A428472, 0x724B84D3, 0x26B898AB, 0x7D980E3C, 0x5345A084, 0x6779B66B,
      0x791EE4B4, 0x6E8EE3CC, 0x63AF504A, 0x18A21B33, 0x0E26EB73, 0x022F708E,
      0x1740F3B0, 0x7E2C699D, 0x0E8A570B, 0x5F2C22FB, 0x6A742130};
  printf("Frame Buffer Performance test...\n");
  for (run = 0; run < 5; ++run) {
    testImage = (unsigned int *)malloc(fbSize);
    j = run;
    for (i = 0; i < (int)(fbSize / sizeof(int)); ++i) {
      testImage[i] = randData[j];
      j++;
      if (j >= 17)
        j = 0;
    }
    gettimeofday(&startTime, NULL);
    memcpy(fb, testImage, fbSize);
    gettimeofday(&endTime, NULL);
    long secsDiff = endTime.tv_sec - startTime.tv_sec;
    results[run] = secsDiff * 1000000 + (endTime.tv_usec - startTime.tv_usec);
    free(testImage);
  }
  average = 0;
  for (i = 0; i < 5; ++i)
    average += results[i];
  average = average / 5;
  printf("        Average:   %llu usecs\n", average);
  printf("        Bandwidth: %.03f MByte/Sec\n",
         (fbSize / 1048576.0) / ((double)average / 1000000.0));
  printf("        Max. FPS:  %.03f fps\n\n", 1000000.0 / (double)average);
  memset(fb, 0, fbSize);
}


x86 assembly (clang, -O0):
<performSpeedTest>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
lea    -0xc0(%rbp),%rdi
lea    0xeb0(%rip),%rsi
mov    $0x44,%edx
call   1070 <memcpy@plt>
lea    0xee3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x18(%rbp)
cmpl   $0x5,-0x18(%rbp)
jge    1287 <performSpeedTest+0x127>
mov    -0xc(%rbp),%edi
call   1080 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
movslq -0xc(%rbp),%rcx
shr    $0x2,%rcx
cmp    %ecx,%eax
jge    1218 <performSpeedTest+0xb8>
movslq -0x14(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%edx
mov    -0x70(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x11,-0x14(%rbp)
jl     1205 <performSpeedTest+0xa5>
movl   $0x0,-0x14(%rbp)
jmp    120a <performSpeedTest+0xaa>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11c2 <performSpeedTest+0x62>
lea    -0x28(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1050 <gettimeofday@plt>
mov    -0x8(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   1070 <memcpy@plt>
lea    -0x38(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1050 <gettimeofday@plt>
mov    -0x38(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0xc8(%rbp)
imul   $0xf4240,-0xc8(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
add    %rax,%rcx
movslq -0x18(%rbp),%rax
mov    %rcx,-0x60(%rbp,%rax,8)
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    119f <performSpeedTest+0x3f>
movq   $0x0,-0x68(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0x5,-0x10(%rbp)
jge    12bf <performSpeedTest+0x15f>
movslq -0x10(%rbp),%rax
mov    -0x60(%rbp,%rax,8),%rax
add    -0x68(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1296 <performSpeedTest+0x136>
mov    -0x68(%rbp),%rax
movabs $0xcccccccccccccccd,%rcx
cc cc cc
mul    %rcx
shr    $0x2,%rdx
mov    %rdx,-0x68(%rbp)
mov    -0x68(%rbp),%rsi
lea    0xdb3(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0xd11(%rip),%xmm1
divsd  %xmm1,%xmm0
movq   -0x68(%rbp),%xmm1
movaps 0xd09(%rip),%xmm2
movaps %xmm2,-0xf0(%rbp)
punpckldq %xmm2,%xmm1
movapd 0xd06(%rip),%xmm2
movaps %xmm2,-0xe0(%rbp)
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
movsd  0xcc8(%rip),%xmm2
divsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
lea    0xd6e(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
movaps -0xf0(%rbp),%xmm2
movaps -0xe0(%rbp),%xmm0
movq   -0x68(%rbp),%xmm1
punpckldq %xmm2,%xmm1
subpd  %xmm0,%xmm1
movaps %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0xc84(%rip),%xmm0
divsd  %xmm1,%xmm0
lea    0xd52(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%edx
xor    %esi,%esi
call   1060 <memset@plt>
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<performSpeedTest>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %esi,%ebp
mov    %rdi,0x8(%rsp)
lea    0xf2a(%rip),%rdi
call   1040 <puts@plt>
mov    %ebp,%eax
sar    $0x2,%eax
cmp    $0x2,%eax
mov    $0x1,%r13d
cmovge %eax,%r13d
mov    %r13,(%rsp)
and    $0x7ffffffe,%r13d
xor    %r12d,%r12d
lea    0xe58(%rip),%r15
xor    %r14d,%r14d
jmp    121c <performSpeedTest+0xac>
nopl   (%rax)
lea    0x20(%rsp),%rdi
xor    %esi,%esi
call   1060 <gettimeofday@plt>
mov    0x8(%rsp),%rdi
mov    %rbx,%rsi
mov    %ebp,%edx
call   1080 <memcpy@plt>
lea    0x10(%rsp),%rdi
xor    %esi,%esi
call   1060 <gettimeofday@plt>
mov    0x10(%rsp),%rax
mov    0x18(%rsp),%rcx
sub    0x20(%rsp),%rax
imul   $0xf4240,%rax,%rax
sub    0x28(%rsp),%rcx
add    %rax,%rcx
mov    %rcx,0x30(%rsp,%r14,8)
mov    %rbx,%rdi
call   1030 <free@plt>
add    $0x1,%r14
cmp    $0x5,%r14
je     128b <performSpeedTest+0x11b>
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,%rbx
cmp    $0x4,%ebp
jl     11c0 <performSpeedTest+0x50>
xor    %eax,%eax
mov    %r14d,%ecx
cmp    $0x8,%ebp
jl     1272 <performSpeedTest+0x102>
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ecx,%rcx
mov    (%r15,%rcx,4),%edx
mov    %edx,(%rbx,%rax,4)
lea    0x1(%rcx),%edx
cmp    $0x10,%ecx
cmovge %r12d,%edx
movslq %edx,%rdx
mov    (%r15,%rdx,4),%ecx
mov    %ecx,0x4(%rbx,%rax,4)
lea    0x1(%rdx),%ecx
cmp    $0x10,%edx
cmovge %r12d,%ecx
add    $0x2,%rax
cmp    %rax,%r13
jne    1240 <performSpeedTest+0xd0>
testb  $0x1,(%rsp)
je     11c0 <performSpeedTest+0x50>
movslq %ecx,%rcx
mov    (%r15,%rcx,4),%ecx
mov    %ecx,(%rbx,%rax,4)
jmp    11c0 <performSpeedTest+0x50>
movdqu 0x38(%rsp),%xmm0
movdqu 0x48(%rsp),%xmm1
paddq  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddq  %xmm1,%xmm0
movq   %xmm0,%rax
add    0x30(%rsp),%rax
movabs $0xcccccccccccccccd,%rcx
cc cc cc
mul    %rcx
mov    %rdx,%rbx
shr    $0x2,%rbx
lea    0xd8b(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %ebp,%xmm0
mulsd  0xd1e(%rip),%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %rbx,%xmm1
movsd  %xmm1,(%rsp)
divsd  0xd11(%rip),%xmm1
divsd  %xmm1,%xmm0
lea    0xd71(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
movsd  0xcf7(%rip),%xmm0
divsd  (%rsp),%xmm0
lea    0xd7a(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    0x8(%rsp),%rdi
xor    %esi,%esi
mov    %ebp,%edx
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1070 <memset@plt>

LLVM IR (-O0):
%struct.timeval = type { i64, i64 }
@__const.performSpeedTest.randData = [17 x i32] [i32 977437810, i32 1917551827, i32 649631915, i32 2107117116, i32 1397072004, i32 1736029803, i32 2032067764, i32 1854858188, i32 1672433738, i32 413276979, i32 237431667, i32 36663438, i32 390132656, i32 2116839837, i32 243947275, i32 1596728059, i32 1785995568]
@.str = [34 x i8] c"Frame Buffer Performance test...\0A\00"
@.str.1 = [31 x i8] c" Average: %llu usecs\0A\00"
@.str.2 = [36 x i8] c" Bandwidth: %.03f MByte/Sec\0A\00"
@.str.3 = [31 x i8] c" Max. FPS: %.03f fps\0A\0A\00"
define void @performSpeedTest(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca %struct.timeval
%9 = alloca %struct.timeval
%10 = alloca [5 x i64]
%11 = alloca i64
%12 = alloca i32*
%13 = alloca [17 x i32]
%14 = alloca i64
store i8* %0, i8** %3
store i32 %1, i32* %4
%15 = bitcast [17 x i32]* %13 to i8*
%16 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %7
br label %17
17: ; preds = %75, %2
%18 = load i32, i32* %7
%19 = icmp slt i32 %18, 5
br i1 %19, label %20, label %78
20: ; preds = %17
%21 = load i32, i32* %4
%22 = call i64 @malloc(i32 %21)
%23 = inttoptr i64 %22 to i32*
store i32* %23, i32** %12
%24 = load i32, i32* %7
store i32 %24, i32* %6
store i32 0, i32* %5
br label %25
25: ; preds = %47, %20
%26 = load i32, i32* %5
%27 = load i32, i32* %4
%28 = sext i32 %27 to i64
%29 = udiv i64 %28, 4
%30 = trunc i64 %29 to i32
%31 = icmp slt i32 %26, %30
br i1 %31, label %32, label %50
32: ; preds = %25
%33 = load i32, i32* %6
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [17 x i32], [17 x i32]* %13, i64 0, i64 %34
%36 = load i32, i32* %35
%37 = load i32*, i32** %12
%38 = load i32, i32* %5
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %37, i64 %39
store i32 %36, i32* %40
%41 = load i32, i32* %6
%42 = add nsw i32 %41, 1
store i32 %42, i32* %6
%43 = load i32, i32* %6
%44 = icmp sge i32 %43, 17
br i1 %44, label %45, label %46
45: ; preds = %32
store i32 0, i32* %6
br label %46
46: ; preds = %45, %32
br label %47
47: ; preds = %46
%48 = load i32, i32* %5
%49 = add nsw i32 %48, 1
store i32 %49, i32* %5
br label %25
50: ; preds = %25
%51 = call i32 @gettimeofday(%struct.timeval* %8, i32* null)
%52 = load i8*, i8** %3
%53 = load i32*, i32** %12
%54 = load i32, i32* %4
%55 = call i32 @memcpy(i8* %52, i32* %53, i32 %54)
%56 = call i32 @gettimeofday(%struct.timeval* %9, i32* null)
%57 = getelementptr inbounds %struct.timeval, %struct.timeval* %9, i32 0, i32 0
%58 = load i64, i64* %57
%59 = getelementptr inbounds %struct.timeval, %struct.timeval* %8, i32 0, i32 0
%60 = load i64, i64* %59
%61 = sub nsw i64 %58, %60
store i64 %61, i64* %14
%62 = load i64, i64* %14
%63 = mul nsw i64 %62, 1000000
%64 = getelementptr inbounds %struct.timeval, %struct.timeval* %9, i32 0, i32 1
%65 = load i64, i64* %64
%66 = getelementptr inbounds %struct.timeval, %struct.timeval* %8, i32 0, i32 1
%67 = load i64, i64* %66
%68 = sub nsw i64 %65, %67
%69 = add nsw i64 %63, %68
%70 = load i32, i32* %7
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [5 x i64], [5 x i64]* %10, i64 0, i64 %71
store i64 %69, i64* %72
%73 = load i32*, i32** %12
%74 = call i32 @free(i32* %73)
br label %75
75: ; preds = %50
%76 = load i32, i32* %7
%77 = add nsw i32 %76, 1
store i32 %77, i32* %7
br label %17
78: ; preds = %17
store i64 0, i64* %11
store i32 0, i32* %5
br label %79
79: ; preds = %89, %78
%80 = load i32, i32* %5
%81 = icmp slt i32 %80, 5
br i1 %81, label %82, label %92
82: ; preds = %79
%83 = load i32, i32* %5
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [5 x i64], [5 x i64]* %10, i64 0, i64 %84
%86 = load i64, i64* %85
%87 = load i64, i64* %11
%88 = add i64 %87, %86
store i64 %88, i64* %11
br label %89
89: ; preds = %82
%90 = load i32, i32* %5
%91 = add nsw i32 %90, 1
store i32 %91, i32* %5
br label %79
92: ; preds = %79
%93 = load i64, i64* %11
%94 = udiv i64 %93, 5
store i64 %94, i64* %11
%95 = load i64, i64* %11
%96 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0), i64 %95)
%97 = load i32, i32* %4
%98 = sitofp i32 %97 to double
%99 = fdiv double %98, 0x4130000000000000
%100 = load i64, i64* %11
%101 = uitofp i64 %100 to double
%102 = fdiv double %101, 1.000000e+06
%103 = fdiv double %99, %102
%104 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0), double %103)
%105 = load i64, i64* %11
%106 = uitofp i64 %105 to double
%107 = fdiv double 1.000000e+06, %106
%108 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.3, i64 0, i64 0), double %107)
%109 = load i8*, i8** %3
%110 = load i32, i32* %4
%111 = call i32 @memset(i8* %109, i32 0, i32 %110)
ret void
}

LLVM IR (-O2):
%struct.timeval = type { i64, i64 }
@__const.performSpeedTest.randData = [17 x i32] [i32 977437810, i32 1917551827, i32 649631915, i32 2107117116, i32 1397072004, i32 1736029803, i32 2032067764, i32 1854858188, i32 1672433738, i32 413276979, i32 237431667, i32 36663438, i32 390132656, i32 2116839837, i32 243947275, i32 1596728059, i32 1785995568]
@.str.1 = [31 x i8] c" Average: %llu usecs\0A\00"
@.str.2 = [36 x i8] c" Bandwidth: %.03f MByte/Sec\0A\00"
@.str.3 = [31 x i8] c" Max. FPS: %.03f fps\0A\0A\00"
@str = [33 x i8] c"Frame Buffer Performance test...\00"
define void @performSpeedTest(i8* %0, i32 %1) {
%3 = alloca %struct.timeval
%4 = alloca %struct.timeval
%5 = alloca [5 x i64]
%6 = bitcast %struct.timeval* %3 to i8*
%7 = bitcast %struct.timeval* %4 to i8*
%8 = bitcast [5 x i64]* %5 to i8*
%9 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @str, i64 0, i64 0))
%10 = ashr i32 %1, 2
%11 = icmp sgt i32 %1, 3
%12 = getelementptr inbounds %struct.timeval, %struct.timeval* %4, i64 0, i32 0
%13 = getelementptr inbounds %struct.timeval, %struct.timeval* %3, i64 0, i32 0
%14 = getelementptr inbounds %struct.timeval, %struct.timeval* %4, i64 0, i32 1
%15 = getelementptr inbounds %struct.timeval, %struct.timeval* %3, i64 0, i32 1
%16 = call i32 @llvm.smax.i32(i32 %10, i32 1)
%17 = zext i32 %16 to i64
%18 = and i64 %17, 1
%19 = icmp slt i32 %1, 8
%20 = and i64 %17, 2147483646
%21 = icmp eq i64 %18, 0
br label %22
22: ; preds = %2, %58
%23 = phi i64 [ 0, %2 ], [ %72, %58 ]
%24 = tail call i64 @malloc(i32 %1)
%25 = inttoptr i64 %24 to i32*
br i1 %11, label %26, label %58
26: ; preds = %22
%27 = trunc i64 %23 to i32
br i1 %19, label %50, label %28
28: ; preds = %26, %28
%29 = phi i64 [ %47, %28 ], [ 0, %26 ]
%30 = phi i32 [ %46, %28 ], [ %27, %26 ]
%31 = phi i64 [ %48, %28 ], [ 0, %26 ]
%32 = sext i32 %30 to i64
%33 = getelementptr inbounds [17 x i32], [17 x i32]* @__const.performSpeedTest.randData, i64 0, i64 %32
%34 = load i32, i32* %33
%35 = getelementptr inbounds i32, i32* %25, i64 %29
store i32 %34, i32* %35
%36 = add nsw i32 %30, 1
%37 = icmp sgt i32 %30, 15
%38 = select i1 %37, i32 0, i32 %36
%39 = or i64 %29, 1
%40 = sext i32 %38 to i64
%41 = getelementptr inbounds [17 x i32], [17 x i32]* @__const.performSpeedTest.randData, i64 0, i64 %40
%42 = load i32, i32* %41
%43 = getelementptr inbounds i32, i32* %25, i64 %39
store i32 %42, i32* %43
%44 = add nsw i32 %38, 1
%45 = icmp sgt i32 %38, 15
%46 = select i1 %45, i32 0, i32 %44
%47 = add nuw nsw i64 %29, 2
%48 = add i64 %31, 2
%49 = icmp eq i64 %48, %20
br i1 %49, label %50, label %28
50: ; preds = %28, %26
%51 = phi i64 [ 0, %26 ], [ %47, %28 ]
%52 = phi i32 [ %27, %26 ], [ %46, %28 ]
br i1 %21, label %58, label %53
53: ; preds = %50
%54 = sext i32 %52 to i64
%55 = getelementptr inbounds [17 x i32], [17 x i32]* @__const.performSpeedTest.randData, i64 0, i64 %54
%56 = load i32, i32* %55
%57 = getelementptr inbounds i32, i32* %25, i64 %51
store i32 %56, i32* %57
br label %58
58: ; preds = %53, %50, %22
%59 = call i32 @gettimeofday(%struct.timeval* %3, i32* null)
%60 = tail call i32 @memcpy(i8* %0, i32* %25, i32 %1)
%61 = call i32 @gettimeofday(%struct.timeval* %4, i32* null)
%62 = load i64, i64* %12
%63 = load i64, i64* %13
%64 = sub nsw i64 %62, %63
%65 = mul nsw i64 %64, 1000000
%66 = load i64, i64* %14
%67 = load i64, i64* %15
%68 = sub i64 %66, %67
%69 = add nsw i64 %68, %65
%70 = getelementptr inbounds [5 x i64], [5 x i64]* %5, i64 0, i64 %23
store i64 %69, i64* %70
%71 = tail call i32 @free(i32* %25)
%72 = add nuw nsw i64 %23, 1
%73 = icmp eq i64 %72, 5
br i1 %73, label %74, label %22
74: ; preds = %58
%75 = getelementptr inbounds [5 x i64], [5 x i64]* %5, i64 0, i64 0
%76 = load i64, i64* %75
%77 = getelementptr inbounds [5 x i64], [5 x i64]* %5, i64 0, i64 1
%78 = bitcast i64* %77 to <4 x i64>*
%79 = load <4 x i64>, <4 x i64>* %78
%80 = call i64 @llvm.vector.reduce.add.v4i64(<4 x i64> %79)
%81 = add i64 %80, %76
%82 = udiv i64 %81, 5
%83 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.1, i64 0, i64 0), i64 %82)
%84 = sitofp i32 %1 to double
%85 = fmul double %84, 0x3EB0000000000000
%86 = uitofp i64 %82 to double
%87 = fdiv double %86, 1.000000e+06
%88 = fdiv double %85, %87
%89 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.2, i64 0, i64 0), double %88)
%90 = fdiv double 1.000000e+06, %86
%91 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.3, i64 0, i64 0), double %90)
%92 = tail call i32 @memset(i8* %0, i32 0, i32 %1)
ret void
}