#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 *);
scalar_t__ MALLOC(int);
int floor(int);
float *deltas(float *x, int nframes, int ncep, int w) {
  float *d = (float *)MALLOC(ncep * nframes * sizeof(float));
  float *xpad = (float *)MALLOC(ncep * (nframes + w - 1) * sizeof(float));
  int hlen = floor(w / 2);
  for (int fr = 0; fr < (nframes + w - 1); fr++) {
    for (int cep = 0; cep < ncep; cep++) {
      if (fr < hlen) {
        xpad[fr * ncep + cep] = x[cep];
      } else if (fr >= (nframes + w - 1) - hlen) {
        xpad[fr * ncep + cep] = x[(nframes - 1) * ncep + cep];
      } else {
        xpad[fr * ncep + cep] = x[(fr - hlen) * ncep + cep];
      }
    }
  }
  for (int fr = w - 1; fr < (nframes + w - 1); fr++) {
    for (int cep = 0; cep < ncep; cep++) {
      float temp = 0;
      for (int i = 0; i < w; i++) {
        temp += xpad[(fr - i) * ncep + cep] * (hlen - i);
      }
      d[(fr - w + 1) * ncep + cep] = temp;
    }
  }
  FREE(xpad);
  return (d);
}


x86 assembly (clang, -O0):
<deltas>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <MALLOC@plt>
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <MALLOC@plt>
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%edi
call   1050 <floor@plt>
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1299 <deltas+0x169>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1286 <deltas+0x156>
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11f4 <deltas+0xc4>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1273 <deltas+0x143>
mov    -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x2c(%rbp),%ecx
cmp    %ecx,%eax
jl     123f <deltas+0x10f>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    126e <deltas+0x13e>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1273 <deltas+0x143>
jmp    1278 <deltas+0x148>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11b4 <deltas+0x84>
jmp    128b <deltas+0x15b>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1199 <deltas+0x69>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1369 <deltas+0x239>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1356 <deltas+0x226>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1327 <deltas+0x1f7>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x44(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x2c(%rbp),%eax
sub    -0x44(%rbp),%eax
cvtsi2ss %eax,%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12d8 <deltas+0x1a8>
movss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
imul   -0x10(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12bd <deltas+0x18d>
jmp    135b <deltas+0x22b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12a2 <deltas+0x172>
mov    -0x28(%rbp),%rdi
call   1030 <FREE@plt>
mov    -0x20(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<deltas>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %ecx,%r12d
mov    %edx,%ebx
mov    %esi,%r13d
mov    %rdi,%rbp
mov    %esi,%edi
imul   %edx,%edi
shl    $0x2,%edi
call   1040 <MALLOC@plt>
mov    %rax,0x30(%rsp)
lea    (%r12,%r13,1),%r14d
add    $0xffffffff,%r14d
mov    %ebx,%edi
imul   %r14d,%edi
shl    $0x2,%edi
call   1040 <MALLOC@plt>
mov    %rax,0x18(%rsp)
mov    %r12d,%edi
shr    $0x1f,%edi
add    %r12d,%edi
sar    %edi
call   1050 <floor@plt>
mov    %eax,0x14(%rsp)
movslq %ebx,%rax
mov    %rax,0x20(%rsp)
mov    %ebx,0xc(%rsp)
mov    %ebx,%r8d
mov    %r14d,0x10(%rsp)
test   %r14d,%r14d
jle    12c7 <deltas+0x197>
add    $0xffffffff,%r13d
mov    0x10(%rsp),%ecx
mov    %ecx,%eax
mov    0x14(%rsp),%edx
sub    %edx,%eax
imul   0xc(%rsp),%r13d
movslq %r13d,%r11
movslq %edx,%rsi
movslq %eax,%r14
mov    %ecx,%r9d
mov    %r8d,%r15d
and    $0xfffffffe,%r15d
lea    0x1(%r11),%r13
mov    0x18(%rsp),%rax
lea    0x4(%rax),%rcx
mov    0x20(%rsp),%rax
lea    0x0(,%rax,4),%rax
mov    %rax,0x28(%rsp)
xor    %r10d,%r10d
jmp    121f <deltas+0xef>
add    %rdx,%rdi
mov    %rdi,%rbx
movss  0x0(%rbp,%rbx,4),%xmm0
add    %rax,%rdx
mov    0x18(%rsp),%rax
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%r10
add    0x28(%rsp),%rcx
cmp    %r9,%r10
je     12c7 <deltas+0x197>
cmpl   $0x0,0xc(%rsp)
jle    120d <deltas+0xdd>
mov    %r10,%rdi
sub    %rsi,%rdi
imul   0x20(%rsp),%rdi
cmpl   $0x1,0xc(%rsp)
jne    1260 <deltas+0x130>
xor    %edx,%edx
test   $0x1,%r8b
je     120d <deltas+0xdd>
mov    %r10,%rax
imul   0x20(%rsp),%rax
mov    %rdx,%rbx
cmp    %rsi,%r10
jl     11fa <deltas+0xca>
cmp    %r14,%r10
jl     11f4 <deltas+0xc4>
lea    (%rdx,%r11,1),%rbx
jmp    11fa <deltas+0xca>
nopl   (%rax)
xor    %edx,%edx
jmp    1287 <deltas+0x157>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %rdi,%rax
movss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,(%rcx,%rdx,4)
add    $0x2,%rdx
cmp    %rdx,%r15
je     123b <deltas+0x10b>
mov    %rdx,%rbx
cmp    %rsi,%r10
jl     12a4 <deltas+0x174>
cmp    %r14,%r10
jge    12a0 <deltas+0x170>
lea    (%rdx,%rdi,1),%rbx
jmp    12a4 <deltas+0x174>
nopw   0x0(%rax,%rax,1)
lea    (%rdx,%r11,1),%rbx
mov    %rdx,%rax
or     $0x1,%rax
movss  0x0(%rbp,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rcx,%rdx,4)
cmp    %rsi,%r10
jl     1273 <deltas+0x143>
cmp    %r14,%r10
jl     1270 <deltas+0x140>
lea    (%rdx,%r13,1),%rax
jmp    1273 <deltas+0x143>
cmp    %r12d,0x10(%rsp)
jge    12ec <deltas+0x1bc>
mov    0x18(%rsp),%rdi
call   1030 <FREE@plt>
mov    0x30(%rsp),%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r12),%eax
mov    $0x1,%ecx
sub    %r12d,%ecx
mov    %rcx,0x38(%rsp)
movslq %eax,%rdi
mov    %r12d,%esi
mov    %esi,%ebp
and    $0xfffffffe,%ebp
lea    -0x1(%rdi),%rax
mov    0x20(%rsp),%rbx
imul   %rbx,%rax
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,4),%rax
mov    %rax,0x28(%rsp)
lea    0x0(,%rbx,4),%rax
mov    %rax,0x40(%rsp)
lea    0x0(,%rbx,8),%rcx
mov    %rbx,%rax
imul   %rdi,%rax
lea    (%rdx,%rax,4),%r14
jmp    136b <deltas+0x23b>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdi
mov    0x40(%rsp),%rax
add    %rax,0x28(%rsp)
add    %rax,%r14
cmp    %edi,0x10(%rsp)
je     12ce <deltas+0x19e>
cmpl   $0x0,0xc(%rsp)
jle    1350 <deltas+0x220>
mov    0x38(%rsp),%rax
add    %edi,%eax
imul   0xc(%rsp),%eax
movslq %eax,%rdx
mov    %r14,%r13
mov    0x28(%rsp),%r11
xor    %r15d,%r15d
jmp    13af <deltas+0x27f>
xchg   %ax,%ax
lea    (%r15,%rdx,1),%rax
mov    0x30(%rsp),%rbx
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%r15
add    $0x4,%r11
add    $0x4,%r13
cmp    %r8,%r15
je     1350 <deltas+0x220>
xorps  %xmm0,%xmm0
test   %r12d,%r12d
jle    1390 <deltas+0x260>
cmp    $0x1,%r12d
jne    13d0 <deltas+0x2a0>
xor    %r9d,%r9d
jmp    1418 <deltas+0x2e8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x14(%rsp),%eax
mov    %eax,%r10d
xor    %eax,%eax
xor    %r9d,%r9d
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
cvtsi2ss %r10d,%xmm1
mulss  0x0(%r13,%rax,1),%xmm1
addss  %xmm0,%xmm1
lea    -0x1(%r10),%ebx
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  (%r11,%rax,1),%xmm0
addss  %xmm1,%xmm0
add    $0x2,%r9
sub    %rcx,%rax
add    $0xfffffffe,%r10d
cmp    %r9,%rbp
jne    13e0 <deltas+0x2b0>
test   $0x1,%sil
je     1390 <deltas+0x260>
mov    %rdi,%rax
sub    %r9,%rax
imul   0x20(%rsp),%rax
mov    0x14(%rsp),%ebx
sub    %r9d,%ebx
xorps  %xmm1,%xmm1
cvtsi2ss %ebx,%xmm1
add    %r15,%rax
mov    0x18(%rsp),%rbx
mulss  (%rbx,%rax,4),%xmm1
addss  %xmm1,%xmm0
jmp    1390 <deltas+0x260>

LLVM IR (-O0):
define float* @deltas(float* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca float*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca float*
%10 = alloca float*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca float
%17 = alloca i32
store float* %0, float** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%18 = load i32, i32* %7
%19 = load i32, i32* %6
%20 = mul nsw i32 %18, %19
%21 = sext i32 %20 to i64
%22 = mul i64 %21, 4
%23 = trunc i64 %22 to i32
%24 = call i64 @MALLOC(i32 %23)
%25 = inttoptr i64 %24 to float*
store float* %25, float** %9
%26 = load i32, i32* %7
%27 = load i32, i32* %6
%28 = load i32, i32* %8
%29 = add nsw i32 %27, %28
%30 = sub nsw i32 %29, 1
%31 = mul nsw i32 %26, %30
%32 = sext i32 %31 to i64
%33 = mul i64 %32, 4
%34 = trunc i64 %33 to i32
%35 = call i64 @MALLOC(i32 %34)
%36 = inttoptr i64 %35 to float*
store float* %36, float** %10
%37 = load i32, i32* %8
%38 = sdiv i32 %37, 2
%39 = call i32 @floor(i32 %38)
store i32 %39, i32* %11
store i32 0, i32* %12
br label %40
40: ; preds = %124, %4
%41 = load i32, i32* %12
%42 = load i32, i32* %6
%43 = load i32, i32* %8
%44 = add nsw i32 %42, %43
%45 = sub nsw i32 %44, 1
%46 = icmp slt i32 %41, %45
br i1 %46, label %47, label %127
47: ; preds = %40
store i32 0, i32* %13
br label %48
48: ; preds = %120, %47
%49 = load i32, i32* %13
%50 = load i32, i32* %7
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %123
52: ; preds = %48
%53 = load i32, i32* %12
%54 = load i32, i32* %11
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %70
56: ; preds = %52
%57 = load float*, float** %5
%58 = load i32, i32* %13
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %57, i64 %59
%61 = load float, float* %60
%62 = load float*, float** %10
%63 = load i32, i32* %12
%64 = load i32, i32* %7
%65 = mul nsw i32 %63, %64
%66 = load i32, i32* %13
%67 = add nsw i32 %65, %66
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds float, float* %62, i64 %68
store float %61, float* %69
br label %119
70: ; preds = %52
%71 = load i32, i32* %12
%72 = load i32, i32* %6
%73 = load i32, i32* %8
%74 = add nsw i32 %72, %73
%75 = sub nsw i32 %74, 1
%76 = load i32, i32* %11
%77 = sub nsw i32 %75, %76
%78 = icmp sge i32 %71, %77
br i1 %78, label %79, label %98
79: ; preds = %70
%80 = load float*, float** %5
%81 = load i32, i32* %6
%82 = sub nsw i32 %81, 1
%83 = load i32, i32* %7
%84 = mul nsw i32 %82, %83
%85 = load i32, i32* %13
%86 = add nsw i32 %84, %85
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float, float* %80, i64 %87
%89 = load float, float* %88
%90 = load float*, float** %10
%91 = load i32, i32* %12
%92 = load i32, i32* %7
%93 = mul nsw i32 %91, %92
%94 = load i32, i32* %13
%95 = add nsw i32 %93, %94
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %90, i64 %96
store float %89, float* %97
br label %118
98: ; preds = %70
%99 = load float*, float** %5
%100 = load i32, i32* %12
%101 = load i32, i32* %11
%102 = sub nsw i32 %100, %101
%103 = load i32, i32* %7
%104 = mul nsw i32 %102, %103
%105 = load i32, i32* %13
%106 = add nsw i32 %104, %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %99, i64 %107
%109 = load float, float* %108
%110 = load float*, float** %10
%111 = load i32, i32* %12
%112 = load i32, i32* %7
%113 = mul nsw i32 %111, %112
%114 = load i32, i32* %13
%115 = add nsw i32 %113, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %110, i64 %116
store float %109, float* %117
br label %118
118: ; preds = %98, %79
br label %119
119: ; preds = %118, %56
br label %120
120: ; preds = %119
%121 = load i32, i32* %13
%122 = add nsw i32 %121, 1
store i32 %122, i32* %13
br label %48
123: ; preds = %48
br label %124
124: ; preds = %123
%125 = load i32, i32* %12
%126 = add nsw i32 %125, 1
store i32 %126, i32* %12
br label %40
127: ; preds = %40
%128 = load i32, i32* %8
%129 = sub nsw i32 %128, 1
store i32 %129, i32* %14
br label %130
130: ; preds = %185, %127
%131 = load i32, i32* %14
%132 = load i32, i32* %6
%133 = load i32, i32* %8
%134 = add nsw i32 %132, %133
%135 = sub nsw i32 %134, 1
%136 = icmp slt i32 %131, %135
br i1 %136, label %137, label %188
137: ; preds = %130
store i32 0, i32* %15
br label %138
138: ; preds = %181, %137
%139 = load i32, i32* %15
%140 = load i32, i32* %7
%141 = icmp slt i32 %139, %140
br i1 %141, label %142, label %184
142: ; preds = %138
store float 0.000000e+00, float* %16
store i32 0, i32* %17
br label %143
143: ; preds = %165, %142
%144 = load i32, i32* %17
%145 = load i32, i32* %8
%146 = icmp slt i32 %144, %145
br i1 %146, label %147, label %168
147: ; preds = %143
%148 = load float*, float** %10
%149 = load i32, i32* %14
%150 = load i32, i32* %17
%151 = sub nsw i32 %149, %150
%152 = load i32, i32* %7
%153 = mul nsw i32 %151, %152
%154 = load i32, i32* %15
%155 = add nsw i32 %153, %154
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds float, float* %148, i64 %156
%158 = load float, float* %157
%159 = load i32, i32* %11
%160 = load i32, i32* %17
%161 = sub nsw i32 %159, %160
%162 = sitofp i32 %161 to float
%163 = load float, float* %16
%164 = call float @llvm.fmuladd.f32(float %158, float %162, float %163)
store float %164, float* %16
br label %165
165: ; preds = %147
%166 = load i32, i32* %17
%167 = add nsw i32 %166, 1
store i32 %167, i32* %17
br label %143
168: ; preds = %143
%169 = load float, float* %16
%170 = load float*, float** %9
%171 = load i32, i32* %14
%172 = load i32, i32* %8
%173 = sub nsw i32 %171, %172
%174 = add nsw i32 %173, 1
%175 = load i32, i32* %7
%176 = mul nsw i32 %174, %175
%177 = load i32, i32* %15
%178 = add nsw i32 %176, %177
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float, float* %170, i64 %179
store float %169, float* %180
br label %181
181: ; preds = %168
%182 = load i32, i32* %15
%183 = add nsw i32 %182, 1
store i32 %183, i32* %15
br label %138
184: ; preds = %138
br label %185
185: ; preds = %184
%186 = load i32, i32* %14
%187 = add nsw i32 %186, 1
store i32 %187, i32* %14
br label %130
188: ; preds = %130
%189 = load float*, float** %10
%190 = call i32 @FREE(float* %189)
%191 = load float*, float** %9
ret float* %191
}

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