#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 */
void alwayspred(bool *actual, bool *predict, size_t len, float *hit,
                float *miss, void *userdata) {
  size_t i, count;
  count = 0;
  for (i = 0; i < len; i++) {
    predict[i] = (uintptr_t)userdata;
    if (predict[i] == actual[i])
      count++;
  }
  *hit = count * 1.0 / len;
  *miss = 1 - *hit;
}


x86 assembly (clang, -O0):
<alwayspred>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1189 <alwayspred+0x89>
mov    -0x30(%rbp),%rax
mov    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1173 <alwayspred+0x73>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1178 <alwayspred+0x78>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    112c <alwayspred+0x2c>
movq   -0x40(%rbp),%xmm0
movaps 0xe7b(%rip),%xmm3
punpckldq %xmm3,%xmm0
movapd 0xe7f(%rip),%xmm2
subpd  %xmm2,%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm0
addsd  %xmm1,%xmm0
movq   -0x18(%rbp),%xmm1
punpckldq %xmm3,%xmm1
subpd  %xmm2,%xmm1
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
movss  0xe1c(%rip),%xmm0
subss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<alwayspred>:
push   %rbx
test   %rdx,%rdx
je     1180 <alwayspred+0x80>
cmp    $0x4,%rdx
jb     111e <alwayspred+0x1e>
lea    (%rdi,%rdx,4),%rax
cmp    %rsi,%rax
jbe    1189 <alwayspred+0x89>
lea    (%rsi,%rdx,4),%rax
cmp    %rdi,%rax
jbe    1189 <alwayspred+0x89>
xor    %eax,%eax
xor    %r11d,%r11d
mov    %r11,%rbx
not    %rbx
test   $0x1,%dl
je     1144 <alwayspred+0x44>
mov    %r9d,(%rsi,%r11,4)
xor    %r10d,%r10d
cmp    %r9d,(%rdi,%r11,4)
sete   %r10b
add    %r10,%rax
or     $0x1,%r11
add    %rdx,%rbx
je     12ab <alwayspred+0x1ab>
nopl   (%rax)
mov    %r9d,(%rsi,%r11,4)
xor    %ebx,%ebx
cmp    %r9d,(%rdi,%r11,4)
sete   %bl
add    %rax,%rbx
mov    %r9d,0x4(%rsi,%r11,4)
xor    %eax,%eax
cmp    %r9d,0x4(%rdi,%r11,4)
sete   %al
add    %rbx,%rax
add    $0x2,%r11
cmp    %r11,%rdx
jne    1150 <alwayspred+0x50>
jmp    12ab <alwayspred+0x1ab>
xorpd  %xmm0,%xmm0
jmp    12cc <alwayspred+0x1cc>
mov    %rdx,%r11
and    $0xfffffffffffffffc,%r11
movd   %r9d,%xmm0
pshufd $0x50,%xmm0,%xmm0
lea    -0x4(%r11),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
movdqa %xmm0,%xmm2
punpcklqdq %xmm0,%xmm2
test   %rax,%rax
je     130c <alwayspred+0x20c>
mov    %r10,%rbx
and    $0xfffffffffffffffe,%rbx
pxor   %xmm1,%xmm1
xor    %eax,%eax
movdqa 0xe31(%rip),%xmm4
pxor   %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu %xmm2,(%rsi,%rax,4)
movq   (%rdi,%rax,4),%xmm5
movq   0x8(%rdi,%rax,4),%xmm6
pcmpeqd %xmm0,%xmm5
pshufd $0xd4,%xmm5,%xmm5
pand   %xmm4,%xmm5
paddq  %xmm1,%xmm5
pcmpeqd %xmm0,%xmm6
pshufd $0xd4,%xmm6,%xmm6
pand   %xmm4,%xmm6
paddq  %xmm3,%xmm6
movdqu %xmm2,0x10(%rsi,%rax,4)
movq   0x10(%rdi,%rax,4),%xmm1
movq   0x18(%rdi,%rax,4),%xmm3
pcmpeqd %xmm0,%xmm1
pshufd $0xd4,%xmm1,%xmm1
pand   %xmm4,%xmm1
paddq  %xmm5,%xmm1
pcmpeqd %xmm0,%xmm3
pshufd $0xd4,%xmm3,%xmm3
pand   %xmm4,%xmm3
paddq  %xmm6,%xmm3
add    $0x8,%rax
add    $0xfffffffffffffffe,%rbx
jne    11e0 <alwayspred+0xe0>
test   $0x1,%r10b
je     1290 <alwayspred+0x190>
movdqu %xmm2,(%rsi,%rax,4)
movq   (%rdi,%rax,4),%xmm2
movq   0x8(%rdi,%rax,4),%xmm4
pcmpeqd %xmm0,%xmm2
pshufd $0xd4,%xmm2,%xmm2
movdqa 0xd89(%rip),%xmm5
pand   %xmm5,%xmm2
paddq  %xmm2,%xmm1
pcmpeqd %xmm0,%xmm4
pshufd $0xd4,%xmm4,%xmm0
pand   %xmm5,%xmm0
paddq  %xmm0,%xmm3
paddq  %xmm3,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddq  %xmm1,%xmm0
movq   %xmm0,%rax
cmp    %rdx,%r11
jne    1123 <alwayspred+0x23>
movq   %rax,%xmm1
punpckldq 0xd58(%rip),%xmm1
subpd  0xd60(%rip),%xmm1
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
addsd  %xmm1,%xmm0
movq   %rdx,%xmm1
punpckldq 0xd37(%rip),%xmm1
subpd  0xd3f(%rip),%xmm1
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
addsd  %xmm1,%xmm2
divsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rcx)
movss  0xd2f(%rip),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%r8)
pop    %rbx
ret
pxor   %xmm1,%xmm1
xor    %eax,%eax
pxor   %xmm3,%xmm3
test   $0x1,%r10b
jne    1256 <alwayspred+0x156>
jmp    1290 <alwayspred+0x190>

LLVM IR (-O0):
define void @alwayspred(i32* %0, i32* %1, i64 %2, float* %3, float* %4, i8* %5) {
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i64
%10 = alloca float*
%11 = alloca float*
%12 = alloca i8*
%13 = alloca i64
%14 = alloca i64
store i32* %0, i32** %7
store i32* %1, i32** %8
store i64 %2, i64* %9
store float* %3, float** %10
store float* %4, float** %11
store i8* %5, i8** %12
store i64 0, i64* %14
store i64 0, i64* %13
br label %15
15: ; preds = %39, %6
%16 = load i64, i64* %13
%17 = load i64, i64* %9
%18 = icmp ult i64 %16, %17
br i1 %18, label %19, label %42
19: ; preds = %15
%20 = load i8*, i8** %12
%21 = ptrtoint i8* %20 to i64
%22 = trunc i64 %21 to i32
%23 = load i32*, i32** %8
%24 = load i64, i64* %13
%25 = getelementptr inbounds i32, i32* %23, i64 %24
store i32 %22, i32* %25
%26 = load i32*, i32** %8
%27 = load i64, i64* %13
%28 = getelementptr inbounds i32, i32* %26, i64 %27
%29 = load i32, i32* %28
%30 = load i32*, i32** %7
%31 = load i64, i64* %13
%32 = getelementptr inbounds i32, i32* %30, i64 %31
%33 = load i32, i32* %32
%34 = icmp eq i32 %29, %33
br i1 %34, label %35, label %38
35: ; preds = %19
%36 = load i64, i64* %14
%37 = add i64 %36, 1
store i64 %37, i64* %14
br label %38
38: ; preds = %35, %19
br label %39
39: ; preds = %38
%40 = load i64, i64* %13
%41 = add i64 %40, 1
store i64 %41, i64* %13
br label %15
42: ; preds = %15
%43 = load i64, i64* %14
%44 = uitofp i64 %43 to double
%45 = fmul double %44, 1.000000e+00
%46 = load i64, i64* %9
%47 = uitofp i64 %46 to double
%48 = fdiv double %45, %47
%49 = fptrunc double %48 to float
%50 = load float*, float** %10
store float %49, float* %50
%51 = load float*, float** %10
%52 = load float, float* %51
%53 = fsub float 1.000000e+00, %52
%54 = load float*, float** %11
store float %53, float* %54
ret void
}

LLVM IR (-O2):
define void @alwayspred(i32* nocapture %0, i32* nocapture writeonly %1, i64 %2, float* nocapture writeonly %3, float* nocapture writeonly %4, i8* %5) {
%7 = icmp eq i64 %2, 0
br i1 %7, label %143, label %8
8: ; preds = %6
%9 = ptrtoint i8* %5 to i64
%10 = trunc i64 %9 to i32
%11 = icmp ult i64 %2, 4
br i1 %11, label %102, label %12
12: ; preds = %8
%13 = getelementptr i32, i32* %1, i64 %2
%14 = getelementptr i32, i32* %0, i64 %2
%15 = icmp ugt i32* %14, %1
%16 = icmp ugt i32* %13, %0
%17 = and i1 %15, %16
br i1 %17, label %102, label %18
18: ; preds = %12
%19 = and i64 %2, -4
%20 = insertelement <2 x i32> poison, i32 %10, i64 0
%21 = shufflevector <2 x i32> %20, <2 x i32> poison, <2 x i32> zeroinitializer
%22 = insertelement <2 x i32> poison, i32 %10, i64 0
%23 = shufflevector <2 x i32> %22, <2 x i32> poison, <2 x i32> zeroinitializer
%24 = add i64 %19, -4
%25 = lshr exact i64 %24, 2
%26 = add nuw nsw i64 %25, 1
%27 = and i64 %26, 1
%28 = icmp eq i64 %24, 0
br i1 %28, label %72, label %29
29: ; preds = %18
%30 = and i64 %26, 9223372036854775806
br label %31
31: ; preds = %31, %29
%32 = phi i64 [ 0, %29 ], [ %69, %31 ]
%33 = phi <2 x i64> [ zeroinitializer, %29 ], [ %67, %31 ]
%34 = phi <2 x i64> [ zeroinitializer, %29 ], [ %68, %31 ]
%35 = phi i64 [ 0, %29 ], [ %70, %31 ]
%36 = getelementptr inbounds i32, i32* %1, i64 %32
%37 = bitcast i32* %36 to <2 x i32>*
store <2 x i32> %21, <2 x i32>* %37
%38 = getelementptr inbounds i32, i32* %36, i64 2
%39 = bitcast i32* %38 to <2 x i32>*
store <2 x i32> %23, <2 x i32>* %39
%40 = getelementptr inbounds i32, i32* %0, i64 %32
%41 = bitcast i32* %40 to <2 x i32>*
%42 = load <2 x i32>, <2 x i32>* %41
%43 = getelementptr inbounds i32, i32* %40, i64 2
%44 = bitcast i32* %43 to <2 x i32>*
%45 = load <2 x i32>, <2 x i32>* %44
%46 = icmp eq <2 x i32> %42, %21
%47 = icmp eq <2 x i32> %45, %23
%48 = zext <2 x i1> %46 to <2 x i64>
%49 = zext <2 x i1> %47 to <2 x i64>
%50 = add <2 x i64> %33, %48
%51 = add <2 x i64> %34, %49
%52 = or i64 %32, 4
%53 = getelementptr inbounds i32, i32* %1, i64 %52
%54 = bitcast i32* %53 to <2 x i32>*
store <2 x i32> %21, <2 x i32>* %54
%55 = getelementptr inbounds i32, i32* %53, i64 2
%56 = bitcast i32* %55 to <2 x i32>*
store <2 x i32> %23, <2 x i32>* %56
%57 = getelementptr inbounds i32, i32* %0, i64 %52
%58 = bitcast i32* %57 to <2 x i32>*
%59 = load <2 x i32>, <2 x i32>* %58
%60 = getelementptr inbounds i32, i32* %57, i64 2
%61 = bitcast i32* %60 to <2 x i32>*
%62 = load <2 x i32>, <2 x i32>* %61
%63 = icmp eq <2 x i32> %59, %21
%64 = icmp eq <2 x i32> %62, %23
%65 = zext <2 x i1> %63 to <2 x i64>
%66 = zext <2 x i1> %64 to <2 x i64>
%67 = add <2 x i64> %50, %65
%68 = add <2 x i64> %51, %66
%69 = add nuw i64 %32, 8
%70 = add i64 %35, 2
%71 = icmp eq i64 %70, %30
br i1 %71, label %72, label %31
72: ; preds = %31, %18
%73 = phi <2 x i64> [ undef, %18 ], [ %67, %31 ]
%74 = phi <2 x i64> [ undef, %18 ], [ %68, %31 ]
%75 = phi i64 [ 0, %18 ], [ %69, %31 ]
%76 = phi <2 x i64> [ zeroinitializer, %18 ], [ %67, %31 ]
%77 = phi <2 x i64> [ zeroinitializer, %18 ], [ %68, %31 ]
%78 = icmp eq i64 %27, 0
br i1 %78, label %96, label %79
79: ; preds = %72
%80 = getelementptr inbounds i32, i32* %1, i64 %75
%81 = bitcast i32* %80 to <2 x i32>*
store <2 x i32> %21, <2 x i32>* %81
%82 = getelementptr inbounds i32, i32* %80, i64 2
%83 = bitcast i32* %82 to <2 x i32>*
store <2 x i32> %23, <2 x i32>* %83
%84 = getelementptr inbounds i32, i32* %0, i64 %75
%85 = bitcast i32* %84 to <2 x i32>*
%86 = load <2 x i32>, <2 x i32>* %85
%87 = getelementptr inbounds i32, i32* %84, i64 2
%88 = bitcast i32* %87 to <2 x i32>*
%89 = load <2 x i32>, <2 x i32>* %88
%90 = icmp eq <2 x i32> %86, %21
%91 = icmp eq <2 x i32> %89, %23
%92 = zext <2 x i1> %90 to <2 x i64>
%93 = zext <2 x i1> %91 to <2 x i64>
%94 = add <2 x i64> %76, %92
%95 = add <2 x i64> %77, %93
br label %96
96: ; preds = %72, %79
%97 = phi <2 x i64> [ %73, %72 ], [ %94, %79 ]
%98 = phi <2 x i64> [ %74, %72 ], [ %95, %79 ]
%99 = add <2 x i64> %98, %97
%100 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %99)
%101 = icmp eq i64 %19, %2
br i1 %101, label %140, label %102
102: ; preds = %12, %8, %96
%103 = phi i64 [ 0, %12 ], [ 0, %8 ], [ %100, %96 ]
%104 = phi i64 [ 0, %12 ], [ 0, %8 ], [ %19, %96 ]
%105 = xor i64 %104, -1
%106 = and i64 %2, 1
%107 = icmp eq i64 %106, 0
br i1 %107, label %116, label %108
108: ; preds = %102
%109 = getelementptr inbounds i32, i32* %1, i64 %104
store i32 %10, i32* %109
%110 = getelementptr inbounds i32, i32* %0, i64 %104
%111 = load i32, i32* %110
%112 = icmp eq i32 %111, %10
%113 = zext i1 %112 to i64
%114 = add i64 %103, %113
%115 = or i64 %104, 1
br label %116
116: ; preds = %108, %102
%117 = phi i64 [ undef, %102 ], [ %114, %108 ]
%118 = phi i64 [ %103, %102 ], [ %114, %108 ]
%119 = phi i64 [ %104, %102 ], [ %115, %108 ]
%120 = sub i64 0, %2
%121 = icmp eq i64 %105, %120
br i1 %121, label %140, label %122
122: ; preds = %116, %122
%123 = phi i64 [ %137, %122 ], [ %118, %116 ]
%124 = phi i64 [ %138, %122 ], [ %119, %116 ]
%125 = getelementptr inbounds i32, i32* %1, i64 %124
store i32 %10, i32* %125
%126 = getelementptr inbounds i32, i32* %0, i64 %124
%127 = load i32, i32* %126
%128 = icmp eq i32 %127, %10
%129 = zext i1 %128 to i64
%130 = add i64 %123, %129
%131 = add nuw i64 %124, 1
%132 = getelementptr inbounds i32, i32* %1, i64 %131
store i32 %10, i32* %132
%133 = getelementptr inbounds i32, i32* %0, i64 %131
%134 = load i32, i32* %133
%135 = icmp eq i32 %134, %10
%136 = zext i1 %135 to i64
%137 = add i64 %130, %136
%138 = add nuw i64 %124, 2
%139 = icmp eq i64 %138, %2
br i1 %139, label %140, label %122
140: ; preds = %116, %122, %96
%141 = phi i64 [ %100, %96 ], [ %117, %116 ], [ %137, %122 ]
%142 = uitofp i64 %141 to double
br label %143
143: ; preds = %140, %6
%144 = phi double [ 0.000000e+00, %6 ], [ %142, %140 ]
%145 = uitofp i64 %2 to double
%146 = fdiv double %144, %145
%147 = fptrunc double %146 to float
store float %147, float* %3
%148 = fsub float 1.000000e+00, %147
store float %148, float* %4
ret void
}