#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 */
scalar_t__ malloc(int);
float **outer(float *v1, float *v2, int n) {
  int i, j;
  float **m;
  m = (float **)malloc(sizeof(float *) * n);
  for (i = 0; i < n; i++) {
    m[i] = (float *)malloc(sizeof(float) * n);
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      m[i][j] = v1[i] * v2[j];
    }
  }
  return m;
}


x86 assembly (clang, -O0):
<outer>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1175 <outer+0x65>
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    113d <outer+0x2d>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11eb <outer+0xdb>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d8 <outer+0xc8>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    118f <outer+0x7f>
jmp    11dd <outer+0xcd>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    117c <outer+0x6c>
mov    -0x28(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<outer>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %edx,%ebp
mov    %rsi,%rbx
mov    %rdi,%r15
lea    0x0(,%rbp,8),%edi
call   1030 <malloc@plt>
mov    %rax,%r12
test   %ebp,%ebp
jle    135b <outer+0x24b>
lea    0x0(,%rbp,4),%r13d
mov    %rbp,0x8(%rsp)
mov    %ebp,%ebp
xor    %r14d,%r14d
nop
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,(%r12,%r14,8)
add    $0x1,%r14
cmp    %r14,%rbp
jne    1150 <outer+0x40>
mov    0x8(%rsp),%r8
test   %r8d,%r8d
jle    135b <outer+0x24b>
lea    (%rbx,%rbp,4),%r11
mov    %ebp,%r9d
and    $0xfffffff8,%r9d
add    $0xfffffffffffffff8,%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %ebp,%r13d
and    $0xfffffff8,%r13d
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x10(%rsp)
mov    %ebp,%r14d
and    $0x3,%r14d
xor    %ecx,%ecx
jmp    11bd <outer+0xad>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rbp,%rcx
je     135b <outer+0x24b>
mov    (%r12,%rcx,8),%rdx
cmp    $0x8,%r8d
jae    1260 <outer+0x150>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
add    %rbp,%rax
test   %r14,%r14
je     11fa <outer+0xea>
mov    %r14,%rdi
xchg   %ax,%ax
movss  (%r15,%rcx,4),%xmm0
mulss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    11e0 <outer+0xd0>
cmp    $0x3,%rax
jb     11b0 <outer+0xa0>
movss  (%r15,%rcx,4),%xmm0
mulss  (%rbx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movss  (%r15,%rcx,4),%xmm0
mulss  0x4(%rbx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
movss  (%r15,%rcx,4),%xmm0
mulss  0x8(%rbx,%rsi,4),%xmm0
movss  %xmm0,0x8(%rdx,%rsi,4)
movss  (%r15,%rcx,4),%xmm0
mulss  0xc(%rbx,%rsi,4),%xmm0
movss  %xmm0,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rbp
jne    1200 <outer+0xf0>
jmp    11b0 <outer+0xa0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r15,%rcx,4),%rax
add    $0x4,%rax
lea    (%r15,%rcx,4),%rsi
lea    (%rdx,%rbp,4),%rdi
cmp    %rax,%rdx
setb   %r8b
cmp    %rdi,%rsi
setb   %sil
cmp    %r11,%rdx
setb   %al
cmp    %rbx,%rdi
seta   %dil
test   %sil,%r8b
jne    1345 <outer+0x235>
mov    $0x0,%esi
and    %dil,%al
mov    0x8(%rsp),%r8
jne    11cd <outer+0xbd>
test   %r9,%r9
je     1351 <outer+0x241>
movss  (%r15,%rcx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
mov    0x10(%rsp),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rsi,4),%xmm1
movups 0x10(%rbx,%rsi,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rdx,%rsi,4)
movups %xmm2,0x10(%rdx,%rsi,4)
movups 0x20(%rbx,%rsi,4),%xmm1
movups 0x30(%rbx,%rsi,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,0x20(%rdx,%rsi,4)
movups %xmm2,0x30(%rdx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rax
jne    12d0 <outer+0x1c0>
test   $0x1,%r10b
je     1334 <outer+0x224>
movss  (%r15,%rcx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups (%rbx,%rsi,4),%xmm1
movups 0x10(%rbx,%rsi,4),%xmm2
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm2
movups %xmm1,(%rdx,%rsi,4)
movups %xmm2,0x10(%rdx,%rsi,4)
mov    %r13,%rsi
cmp    %rbp,%r13
je     11b0 <outer+0xa0>
jmp    11cd <outer+0xbd>
xor    %esi,%esi
mov    0x8(%rsp),%r8
jmp    11cd <outer+0xbd>
xor    %esi,%esi
test   $0x1,%r10b
jne    1312 <outer+0x202>
jmp    1334 <outer+0x224>
mov    %r12,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define float** @outer(float* %0, float* %1, i32 %2) {
%4 = alloca float*
%5 = alloca float*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca float**
store float* %0, float** %4
store float* %1, float** %5
store i32 %2, i32* %6
%10 = load i32, i32* %6
%11 = sext i32 %10 to i64
%12 = mul i64 8, %11
%13 = trunc i64 %12 to i32
%14 = call i64 @malloc(i32 %13)
%15 = inttoptr i64 %14 to float**
store float** %15, float*** %9
store i32 0, i32* %7
br label %16
16: ; preds = %31, %3
%17 = load i32, i32* %7
%18 = load i32, i32* %6
%19 = icmp slt i32 %17, %18
br i1 %19, label %20, label %34
20: ; preds = %16
%21 = load i32, i32* %6
%22 = sext i32 %21 to i64
%23 = mul i64 4, %22
%24 = trunc i64 %23 to i32
%25 = call i64 @malloc(i32 %24)
%26 = inttoptr i64 %25 to float*
%27 = load float**, float*** %9
%28 = load i32, i32* %7
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds float*, float** %27, i64 %29
store float* %26, float** %30
br label %31
31: ; preds = %20
%32 = load i32, i32* %7
%33 = add nsw i32 %32, 1
store i32 %33, i32* %7
br label %16
34: ; preds = %16
store i32 0, i32* %7
br label %35
35: ; preds = %68, %34
%36 = load i32, i32* %7
%37 = load i32, i32* %6
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %71
39: ; preds = %35
store i32 0, i32* %8
br label %40
40: ; preds = %64, %39
%41 = load i32, i32* %8
%42 = load i32, i32* %6
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %67
44: ; preds = %40
%45 = load float*, float** %4
%46 = load i32, i32* %7
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds float, float* %45, i64 %47
%49 = load float, float* %48
%50 = load float*, float** %5
%51 = load i32, i32* %8
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %50, i64 %52
%54 = load float, float* %53
%55 = fmul float %49, %54
%56 = load float**, float*** %9
%57 = load i32, i32* %7
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float*, float** %56, i64 %58
%60 = load float*, float** %59
%61 = load i32, i32* %8
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %60, i64 %62
store float %55, float* %63
br label %64
64: ; preds = %44
%65 = load i32, i32* %8
%66 = add nsw i32 %65, 1
store i32 %66, i32* %8
br label %40
67: ; preds = %40
br label %68
68: ; preds = %67
%69 = load i32, i32* %7
%70 = add nsw i32 %69, 1
store i32 %70, i32* %7
br label %35
71: ; preds = %35
%72 = load float**, float*** %9
ret float** %72
}

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