#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 */
int /*<<< orphan*/ free(float *);
int /*<<< orphan*/ init(float *, float *, int);
scalar_t__ malloc(int);
void vec_mult_ref(float *p, int n) {
  float *v1, *v2;
  int i;
  v1 = (float *)malloc(n * sizeof(float));
  v2 = (float *)malloc(n * sizeof(float));
  init(v1, v2, n);
  for (i = 0; i < n; i++)
    p[i] = v1[i] * v2[i];
  free(v1);
  free(v2);
}


x86 assembly (clang, -O0):
<vec_mult_ref>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0xc(%rbp),%edx
call   1040 <init@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11bd <vec_mult_ref+0x8d>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    117c <vec_mult_ref+0x4c>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vec_mult_ref>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %esi,%r12d
mov    %rdi,%r14
lea    0x0(,%r12,4),%ebx
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %ebx,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %r15,%rdi
mov    %rax,%rsi
mov    %r12d,%edx
call   1040 <init@plt>
test   %r12d,%r12d
jle    131b <vec_mult_ref+0x1eb>
mov    %r12d,%eax
cmp    $0x8,%r12d
jae    122b <vec_mult_ref+0xfb>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     11bb <vec_mult_ref+0x8b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r15,%rcx,4),%xmm0
mulss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11a0 <vec_mult_ref+0x70>
cmp    $0x3,%rdx
jb     131b <vec_mult_ref+0x1eb>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r15,%rcx,4),%xmm0
mulss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
movss  0x4(%r15,%rcx,4),%xmm0
mulss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%r14,%rcx,4)
movss  0x8(%r15,%rcx,4),%xmm0
mulss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%r14,%rcx,4)
movss  0xc(%r15,%rcx,4),%xmm0
mulss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%r14,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    11d0 <vec_mult_ref+0xa0>
jmp    131b <vec_mult_ref+0x1eb>
lea    (%r14,%rax,4),%rcx
lea    (%r15,%rax,4),%rdx
lea    (%rbx,%rax,4),%rsi
cmp    %r14,%rdx
seta   %dil
cmp    %rcx,%r15
setb   %r8b
cmp    %r14,%rsi
seta   %dl
cmp    %rcx,%rbx
setb   %sil
xor    %ecx,%ecx
test   %r8b,%dil
jne    1180 <vec_mult_ref+0x50>
and    %sil,%dl
jne    1180 <vec_mult_ref+0x50>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1336 <vec_mult_ref+0x206>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopl   0x0(%rax)
movups (%r15,%rdx,4),%xmm0
movups 0x10(%r15,%rdx,4),%xmm1
movups (%rbx,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
movups 0x10(%rbx,%rdx,4),%xmm0
mulps  %xmm1,%xmm0
movups %xmm2,(%r14,%rdx,4)
movups %xmm0,0x10(%r14,%rdx,4)
movups 0x20(%r15,%rdx,4),%xmm0
movups 0x30(%r15,%rdx,4),%xmm1
movups 0x20(%rbx,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
movups 0x30(%rbx,%rdx,4),%xmm0
mulps  %xmm1,%xmm0
movups %xmm2,0x20(%r14,%rdx,4)
movups %xmm0,0x30(%r14,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1290 <vec_mult_ref+0x160>
test   $0x1,%sil
je     1312 <vec_mult_ref+0x1e2>
movups (%r15,%rdx,4),%xmm0
movups 0x10(%r15,%rdx,4),%xmm1
movups (%rbx,%rdx,4),%xmm2
mulps  %xmm0,%xmm2
movups 0x10(%rbx,%rdx,4),%xmm0
mulps  %xmm1,%xmm0
movups %xmm2,(%r14,%rdx,4)
movups %xmm0,0x10(%r14,%rdx,4)
cmp    %rax,%rcx
jne    1180 <vec_mult_ref+0x50>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1030 <free@plt>
xor    %edx,%edx
test   $0x1,%sil
jne    12ed <vec_mult_ref+0x1bd>
jmp    1312 <vec_mult_ref+0x1e2>

LLVM IR (-O0):
define void @vec_mult_ref(float* %0, i32 %1) {
%3 = alloca float*
%4 = alloca i32
%5 = alloca float*
%6 = alloca float*
%7 = alloca i32
store float* %0, float** %3
store i32 %1, i32* %4
%8 = load i32, i32* %4
%9 = sext i32 %8 to i64
%10 = mul i64 %9, 4
%11 = trunc i64 %10 to i32
%12 = call i64 @malloc(i32 %11)
%13 = inttoptr i64 %12 to float*
store float* %13, float** %5
%14 = load i32, i32* %4
%15 = sext i32 %14 to i64
%16 = mul i64 %15, 4
%17 = trunc i64 %16 to i32
%18 = call i64 @malloc(i32 %17)
%19 = inttoptr i64 %18 to float*
store float* %19, float** %6
%20 = load float*, float** %5
%21 = load float*, float** %6
%22 = load i32, i32* %4
%23 = call i32 @init(float* %20, float* %21, i32 %22)
store i32 0, i32* %7
br label %24
24: ; preds = %44, %2
%25 = load i32, i32* %7
%26 = load i32, i32* %4
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %47
28: ; preds = %24
%29 = load float*, float** %5
%30 = load i32, i32* %7
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds float, float* %29, i64 %31
%33 = load float, float* %32
%34 = load float*, float** %6
%35 = load i32, i32* %7
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds float, float* %34, i64 %36
%38 = load float, float* %37
%39 = fmul float %33, %38
%40 = load float*, float** %3
%41 = load i32, i32* %7
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
store float %39, float* %43
br label %44
44: ; preds = %28
%45 = load i32, i32* %7
%46 = add nsw i32 %45, 1
store i32 %46, i32* %7
br label %24
47: ; preds = %24
%48 = load float*, float** %5
%49 = call i32 @free(float* %48)
%50 = load float*, float** %6
%51 = call i32 @free(float* %50)
ret void
}

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