void interpolate_array(float *scale, int old_size, int new_size) {
  int i, j, jincr, k;
  float v;
  if (new_size > old_size) {
    jincr = new_size / old_size;
    j = new_size;
    for (i = old_size - 1; i >= 0; i--) {
      v = scale[i];
      k = jincr;
      do {
        scale[--j] = v;
      } while (--k);
    }
  } else if (new_size < old_size) {
    j = 0;
    jincr = old_size / new_size;
    for (i = 0; i < new_size; i++) {
      scale[i] = scale[j];
      j += jincr;
    }
  }
}


x86 assembly (clang, -O0):
<interpolate_array>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    1199 <interpolate_array+0x99>
mov    -0x10(%rbp),%eax
cltd
idivl  -0xc(%rbp)
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     1194 <interpolate_array+0x94>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
jne    1155 <interpolate_array+0x55>
jmp    1186 <interpolate_array+0x86>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1133 <interpolate_array+0x33>
jmp    1204 <interpolate_array+0x104>
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11ff <interpolate_array+0xff>
movl   $0x0,-0x18(%rbp)
mov    -0xc(%rbp),%eax
cltd
idivl  -0x10(%rbp)
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11fa <interpolate_array+0xfa>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11bd <interpolate_array+0xbd>
jmp    11ff <interpolate_array+0xff>
jmp    1204 <interpolate_array+0x104>
pop    %rbp
ret

x86 assembly (clang, -O2):
<interpolate_array>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edx,%r14d
cmp    %esi,%edx
jle    1285 <interpolate_array+0x185>
mov    %r14d,%eax
cltd
idiv   %esi
test   %esi,%esi
jle    1459 <interpolate_array+0x359>
mov    %esi,%r10d
lea    -0x1(%rax),%r9d
lea    0x1(%r9),%r8
mov    %r8,%r13
and    $0xfffffffffffffff8,%r13
lea    -0x8(%r13),%r11
mov    %r11,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %eax,%edx
sub    %r13d,%edx
mov    %edx,-0xc(%rsp)
mov    %ecx,%r12d
and    $0x3,%r12d
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x8(%rsp)
lea    -0x10(%rdi),%r15
mov    %r12,%rbx
shl    $0x5,%rbx
jmp    117a <interpolate_array+0x7a>
nopw   0x0(%rax,%rax,1)
cmp    $0x2,%rdx
jl     1459 <interpolate_array+0x359>
mov    %r10,%rdx
add    $0xffffffffffffffff,%r10
mov    %r10d,%esi
movss  (%rdi,%rsi,4),%xmm0
movslq %r14d,%r14
cmp    $0x7,%r9d
jae    11a0 <interpolate_array+0xa0>
mov    %eax,%esi
jmp    1270 <interpolate_array+0x170>
nopl   0x0(%rax)
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmp    $0x18,%r11
jae    11c0 <interpolate_array+0xc0>
xor    %esi,%esi
test   %r12,%r12
jne    1227 <interpolate_array+0x127>
jmp    1255 <interpolate_array+0x155>
nopl   0x0(%rax)
mov    %r11,%rbp
mov    %r8,%rcx
lea    (%r15,%r14,4),%r11
mov    -0x8(%rsp),%r8
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups %xmm1,(%r11,%rsi,4)
movups %xmm1,-0x10(%r11,%rsi,4)
movups %xmm1,-0x20(%r11,%rsi,4)
movups %xmm1,-0x30(%r11,%rsi,4)
movups %xmm1,-0x40(%r11,%rsi,4)
movups %xmm1,-0x50(%r11,%rsi,4)
movups %xmm1,-0x60(%r11,%rsi,4)
movups %xmm1,-0x70(%r11,%rsi,4)
add    $0xffffffffffffffe0,%rsi
add    $0xfffffffffffffffc,%r8
jne    11e0 <interpolate_array+0xe0>
neg    %rsi
mov    %rcx,%r8
mov    %rbp,%r11
test   %r12,%r12
je     1255 <interpolate_array+0x155>
mov    %r14,%rcx
sub    %rsi,%rcx
lea    (%r15,%rcx,4),%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm1,(%rsi,%rbp,1)
movups %xmm1,-0x10(%rsi,%rbp,1)
add    $0xffffffffffffffe0,%rbp
mov    %rbx,%rcx
add    %rbp,%rcx
jne    1240 <interpolate_array+0x140>
sub    %r13,%r14
mov    -0xc(%rsp),%esi
cmp    %r13,%r8
je     1170 <interpolate_array+0x70>
cs nopw 0x0(%rax,%rax,1)
nop
movss  %xmm0,-0x4(%rdi,%r14,4)
add    $0xffffffffffffffff,%r14
add    $0xffffffff,%esi
jne    1270 <interpolate_array+0x170>
jmp    1170 <interpolate_array+0x70>
jge    1459 <interpolate_array+0x359>
test   %r14d,%r14d
jle    1459 <interpolate_array+0x359>
mov    %esi,%eax
cltd
idiv   %r14d
movslq %eax,%r9
mov    %r14d,%r8d
xor    %ebp,%ebp
cmp    $0x8,%r14d
jb     12df <interpolate_array+0x1df>
mov    $0x0,%ecx
cmp    $0x1,%eax
jne    13bc <interpolate_array+0x2bc>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%r14
shr    $0x3,%r14
add    $0x1,%r14
mov    %r14d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rdx
jae    12e6 <interpolate_array+0x1e6>
xor    %ebx,%ebx
jmp    1364 <interpolate_array+0x264>
xor    %ecx,%ecx
jmp    13bc <interpolate_array+0x2bc>
and    $0xfffffffffffffffc,%r14
mov    %r9,%r11
shl    $0x7,%r11
mov    %r9,%rdx
shl    $0x5,%rdx
xor    %ebp,%ebp
xor    %ebx,%ebx
nopl   0x0(%rax)
lea    (%rdi,%rbp,1),%rsi
movups (%rdi,%rbp,1),%xmm0
movups 0x10(%rdi,%rbp,1),%xmm1
movups %xmm0,(%rdi,%rbx,4)
movups %xmm1,0x10(%rdi,%rbx,4)
lea    (%rsi,%rdx,1),%rax
movups (%rdx,%rsi,1),%xmm0
movups 0x10(%rdx,%rsi,1),%xmm1
movups %xmm0,0x20(%rdi,%rbx,4)
movups %xmm1,0x30(%rdi,%rbx,4)
lea    (%rax,%rdx,1),%rsi
movups (%rdx,%rax,1),%xmm0
movups 0x10(%rdx,%rax,1),%xmm1
movups %xmm0,0x40(%rdi,%rbx,4)
movups %xmm1,0x50(%rdi,%rbx,4)
movups (%rdx,%rsi,1),%xmm0
movups 0x10(%rdx,%rsi,1),%xmm1
movups %xmm0,0x60(%rdi,%rbx,4)
movups %xmm1,0x70(%rdi,%rbx,4)
add    $0x20,%rbx
add    %r11,%rbp
add    $0xfffffffffffffffc,%r14
jne    1300 <interpolate_array+0x200>
test   %r10,%r10
je     13ac <interpolate_array+0x2ac>
lea    (%rdi,%rbx,4),%rax
add    $0x10,%rax
imul   %r9,%rbx
lea    (%rdi,%rbx,4),%rdx
add    $0x10,%rdx
mov    %r9,%rsi
shl    $0x5,%rsi
shl    $0x5,%r10
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdx),%xmm0
movups (%rdx),%xmm1
movups %xmm0,-0x10(%rax,%rbp,1)
movups %xmm1,(%rax,%rbp,1)
add    $0x20,%rbp
add    %rsi,%rdx
cmp    %rbp,%r10
jne    1390 <interpolate_array+0x290>
cmp    %r8,%rcx
je     1459 <interpolate_array+0x359>
mov    %rcx,%rbp
imul   %r9,%rbp
mov    %rcx,%rax
not    %rax
add    %r8,%rax
mov    %r8,%rdx
and    $0x3,%rdx
je     13e7 <interpolate_array+0x2e7>
xchg   %ax,%ax
movss  (%rdi,%rbp,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
add    %r9,%rbp
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    13d0 <interpolate_array+0x2d0>
cmp    $0x3,%rax
jb     1459 <interpolate_array+0x359>
lea    (%r9,%r9,2),%rax
add    %rbp,%rax
lea    0x0(,%r9,4),%rbx
lea    0x0(,%r9,2),%rsi
add    %rbp,%rsi
lea    (%r9,%rbp,1),%rdx
nopl   0x0(%rax,%rax,1)
movss  (%rdi,%rbp,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
add    %r9,%rbp
movss  (%rdi,%rdx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rcx,4)
add    %r9,%rbp
movss  (%rdi,%rsi,4),%xmm0
movss  %xmm0,0x8(%rdi,%rcx,4)
add    %r9,%rbp
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,0xc(%rdi,%rcx,4)
add    %r9,%rbp
add    $0x4,%rcx
add    %rbx,%rax
add    %rbx,%rsi
add    %rbx,%rdx
cmp    %rcx,%r8
jne    1410 <interpolate_array+0x310>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @interpolate_array(float* nocapture %0, i32 %1, i32 %2) {
%4 = icmp sgt i32 %2, %1
br i1 %4, label %5, label %109
5: ; preds = %3
%6 = sdiv i32 %2, %1
%7 = icmp sgt i32 %1, 0
br i1 %7, label %8, label %251
8: ; preds = %5
%9 = zext i32 %1 to i64
%10 = add i32 %6, -1
%11 = zext i32 %10 to i64
%12 = add nuw nsw i64 %11, 1
%13 = and i64 %12, 8589934584
%14 = add nsw i64 %13, -8
%15 = lshr exact i64 %14, 3
%16 = add nuw nsw i64 %15, 1
%17 = icmp ult i32 %10, 7
%18 = and i64 %12, 8589934584
%19 = trunc i64 %18 to i32
%20 = sub i32 %6, %19
%21 = and i64 %16, 3
%22 = icmp ult i64 %14, 24
%23 = and i64 %16, 4611686018427387900
%24 = icmp eq i64 %21, 0
%25 = icmp eq i64 %12, %18
br label %30
26: ; preds = %102, %98
%27 = phi i64 [ %39, %98 ], [ %105, %102 ]
%28 = trunc i64 %27 to i32
%29 = icmp sgt i64 %31, 1
br i1 %29, label %30, label %251
30: ; preds = %8, %26
%31 = phi i64 [ %9, %8 ], [ %33, %26 ]
%32 = phi i32 [ %2, %8 ], [ %28, %26 ]
%33 = add nsw i64 %31, -1
%34 = and i64 %33, 4294967295
%35 = getelementptr inbounds float, float* %0, i64 %34
%36 = load float, float* %35
%37 = sext i32 %32 to i64
br i1 %17, label %99, label %38
38: ; preds = %30
%39 = sub nsw i64 %37, %18
%40 = insertelement <4 x float> poison, float %36, i64 0
%41 = shufflevector <4 x float> %40, <4 x float> poison, <4 x i32> zeroinitializer
%42 = insertelement <4 x float> poison, float %36, i64 0
%43 = shufflevector <4 x float> %42, <4 x float> poison, <4 x i32> zeroinitializer
br i1 %22, label %82, label %44
44: ; preds = %38, %44
%45 = phi i64 [ %79, %44 ], [ 0, %38 ]
%46 = phi i64 [ %80, %44 ], [ 0, %38 ]
%47 = xor i64 %45, -1
%48 = add i64 %47, %37
%49 = getelementptr inbounds float, float* %0, i64 %48
%50 = getelementptr inbounds float, float* %49, i64 -3
%51 = bitcast float* %50 to <4 x float>*
store <4 x float> %41, <4 x float>* %51
%52 = getelementptr inbounds float, float* %49, i64 -4
%53 = getelementptr inbounds float, float* %52, i64 -3
%54 = bitcast float* %53 to <4 x float>*
store <4 x float> %43, <4 x float>* %54
%55 = sub nuw nsw i64 -9, %45
%56 = add i64 %55, %37
%57 = getelementptr inbounds float, float* %0, i64 %56
%58 = getelementptr inbounds float, float* %57, i64 -3
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %41, <4 x float>* %59
%60 = getelementptr inbounds float, float* %57, i64 -4
%61 = getelementptr inbounds float, float* %60, i64 -3
%62 = bitcast float* %61 to <4 x float>*
store <4 x float> %43, <4 x float>* %62
%63 = sub nuw nsw i64 -17, %45
%64 = add i64 %63, %37
%65 = getelementptr inbounds float, float* %0, i64 %64
%66 = getelementptr inbounds float, float* %65, i64 -3
%67 = bitcast float* %66 to <4 x float>*
store <4 x float> %41, <4 x float>* %67
%68 = getelementptr inbounds float, float* %65, i64 -4
%69 = getelementptr inbounds float, float* %68, i64 -3
%70 = bitcast float* %69 to <4 x float>*
store <4 x float> %43, <4 x float>* %70
%71 = sub nuw nsw i64 -25, %45
%72 = add i64 %71, %37
%73 = getelementptr inbounds float, float* %0, i64 %72
%74 = getelementptr inbounds float, float* %73, i64 -3
%75 = bitcast float* %74 to <4 x float>*
store <4 x float> %41, <4 x float>* %75
%76 = getelementptr inbounds float, float* %73, i64 -4
%77 = getelementptr inbounds float, float* %76, i64 -3
%78 = bitcast float* %77 to <4 x float>*
store <4 x float> %43, <4 x float>* %78
%79 = add nuw i64 %45, 32
%80 = add i64 %46, 4
%81 = icmp eq i64 %80, %23
br i1 %81, label %82, label %44
82: ; preds = %44, %38
%83 = phi i64 [ 0, %38 ], [ %79, %44 ]
br i1 %24, label %98, label %84
84: ; preds = %82, %84
%85 = phi i64 [ %95, %84 ], [ %83, %82 ]
%86 = phi i64 [ %96, %84 ], [ 0, %82 ]
%87 = xor i64 %85, -1
%88 = add i64 %87, %37
%89 = getelementptr inbounds float, float* %0, i64 %88
%90 = getelementptr inbounds float, float* %89, i64 -3
%91 = bitcast float* %90 to <4 x float>*
store <4 x float> %41, <4 x float>* %91
%92 = getelementptr inbounds float, float* %89, i64 -4
%93 = getelementptr inbounds float, float* %92, i64 -3
%94 = bitcast float* %93 to <4 x float>*
store <4 x float> %43, <4 x float>* %94
%95 = add nuw i64 %85, 8
%96 = add i64 %86, 1
%97 = icmp eq i64 %96, %21
br i1 %97, label %98, label %84
98: ; preds = %84, %82
br i1 %25, label %26, label %99
99: ; preds = %30, %98
%100 = phi i64 [ %37, %30 ], [ %39, %98 ]
%101 = phi i32 [ %6, %30 ], [ %20, %98 ]
br label %102
102: ; preds = %99, %102
%103 = phi i64 [ %105, %102 ], [ %100, %99 ]
%104 = phi i32 [ %107, %102 ], [ %101, %99 ]
%105 = add nsw i64 %103, -1
%106 = getelementptr inbounds float, float* %0, i64 %105
store float %36, float* %106
%107 = add nsw i32 %104, -1
%108 = icmp eq i32 %107, 0
br i1 %108, label %26, label %102
109: ; preds = %3
%110 = icmp slt i32 %2, %1
%111 = icmp sgt i32 %2, 0
%112 = and i1 %110, %111
br i1 %112, label %113, label %251
113: ; preds = %109
%114 = sdiv i32 %1, %2
%115 = sext i32 %114 to i64
%116 = zext i32 %2 to i64
%117 = icmp ugt i32 %2, 7
%118 = icmp eq i32 %114, 1
%119 = and i1 %117, %118
br i1 %119, label %120, label %205
120: ; preds = %113
%121 = and i64 %116, 4294967288
%122 = mul nsw i64 %121, %115
%123 = add nsw i64 %121, -8
%124 = lshr exact i64 %123, 3
%125 = add nuw nsw i64 %124, 1
%126 = and i64 %125, 3
%127 = icmp ult i64 %123, 24
br i1 %127, label %183, label %128
128: ; preds = %120
%129 = and i64 %125, 4611686018427387900
br label %130
130: ; preds = %130, %128
%131 = phi i64 [ 0, %128 ], [ %180, %130 ]
%132 = phi i64 [ 0, %128 ], [ %181, %130 ]
%133 = mul i64 %131, %115
%134 = getelementptr inbounds float, float* %0, i64 %133
%135 = bitcast float* %134 to <4 x float>*
%136 = load <4 x float>, <4 x float>* %135
%137 = getelementptr inbounds float, float* %134, i64 4
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = getelementptr inbounds float, float* %0, i64 %131
%141 = bitcast float* %140 to <4 x float>*
store <4 x float> %136, <4 x float>* %141
%142 = getelementptr inbounds float, float* %140, i64 4
%143 = bitcast float* %142 to <4 x float>*
store <4 x float> %139, <4 x float>* %143
%144 = or i64 %131, 8
%145 = mul i64 %144, %115
%146 = getelementptr inbounds float, float* %0, i64 %145
%147 = bitcast float* %146 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = getelementptr inbounds float, float* %146, i64 4
%150 = bitcast float* %149 to <4 x float>*
%151 = load <4 x float>, <4 x float>* %150
%152 = getelementptr inbounds float, float* %0, i64 %144
%153 = bitcast float* %152 to <4 x float>*
store <4 x float> %148, <4 x float>* %153
%154 = getelementptr inbounds float, float* %152, i64 4
%155 = bitcast float* %154 to <4 x float>*
store <4 x float> %151, <4 x float>* %155
%156 = or i64 %131, 16
%157 = mul i64 %156, %115
%158 = getelementptr inbounds float, float* %0, i64 %157
%159 = bitcast float* %158 to <4 x float>*
%160 = load <4 x float>, <4 x float>* %159
%161 = getelementptr inbounds float, float* %158, i64 4
%162 = bitcast float* %161 to <4 x float>*
%163 = load <4 x float>, <4 x float>* %162
%164 = getelementptr inbounds float, float* %0, i64 %156
%165 = bitcast float* %164 to <4 x float>*
store <4 x float> %160, <4 x float>* %165
%166 = getelementptr inbounds float, float* %164, i64 4
%167 = bitcast float* %166 to <4 x float>*
store <4 x float> %163, <4 x float>* %167
%168 = or i64 %131, 24
%169 = mul i64 %168, %115
%170 = getelementptr inbounds float, float* %0, i64 %169
%171 = bitcast float* %170 to <4 x float>*
%172 = load <4 x float>, <4 x float>* %171
%173 = getelementptr inbounds float, float* %170, i64 4
%174 = bitcast float* %173 to <4 x float>*
%175 = load <4 x float>, <4 x float>* %174
%176 = getelementptr inbounds float, float* %0, i64 %168
%177 = bitcast float* %176 to <4 x float>*
store <4 x float> %172, <4 x float>* %177
%178 = getelementptr inbounds float, float* %176, i64 4
%179 = bitcast float* %178 to <4 x float>*
store <4 x float> %175, <4 x float>* %179
%180 = add nuw i64 %131, 32
%181 = add i64 %132, 4
%182 = icmp eq i64 %181, %129
br i1 %182, label %183, label %130
183: ; preds = %130, %120
%184 = phi i64 [ 0, %120 ], [ %180, %130 ]
%185 = icmp eq i64 %126, 0
br i1 %185, label %203, label %186
186: ; preds = %183, %186
%187 = phi i64 [ %200, %186 ], [ %184, %183 ]
%188 = phi i64 [ %201, %186 ], [ 0, %183 ]
%189 = mul i64 %187, %115
%190 = getelementptr inbounds float, float* %0, i64 %189
%191 = bitcast float* %190 to <4 x float>*
%192 = load <4 x float>, <4 x float>* %191
%193 = getelementptr inbounds float, float* %190, i64 4
%194 = bitcast float* %193 to <4 x float>*
%195 = load <4 x float>, <4 x float>* %194
%196 = getelementptr inbounds float, float* %0, i64 %187
%197 = bitcast float* %196 to <4 x float>*
store <4 x float> %192, <4 x float>* %197
%198 = getelementptr inbounds float, float* %196, i64 4
%199 = bitcast float* %198 to <4 x float>*
store <4 x float> %195, <4 x float>* %199
%200 = add nuw i64 %187, 8
%201 = add i64 %188, 1
%202 = icmp eq i64 %201, %126
br i1 %202, label %203, label %186
203: ; preds = %186, %183
%204 = icmp eq i64 %121, %116
br i1 %204, label %251, label %205
205: ; preds = %113, %203
%206 = phi i64 [ 0, %113 ], [ %122, %203 ]
%207 = phi i64 [ 0, %113 ], [ %121, %203 ]
%208 = xor i64 %207, -1
%209 = add nsw i64 %208, %116
%210 = and i64 %116, 3
%211 = icmp eq i64 %210, 0
br i1 %211, label %223, label %212
212: ; preds = %205, %212
%213 = phi i64 [ %219, %212 ], [ %206, %205 ]
%214 = phi i64 [ %220, %212 ], [ %207, %205 ]
%215 = phi i64 [ %221, %212 ], [ 0, %205 ]
%216 = getelementptr inbounds float, float* %0, i64 %213
%217 = load float, float* %216
%218 = getelementptr inbounds float, float* %0, i64 %214
store float %217, float* %218
%219 = add nsw i64 %213, %115
%220 = add nuw nsw i64 %214, 1
%221 = add i64 %215, 1
%222 = icmp eq i64 %221, %210
br i1 %222, label %223, label %212
223: ; preds = %212, %205
%224 = phi i64 [ %206, %205 ], [ %219, %212 ]
%225 = phi i64 [ %207, %205 ], [ %220, %212 ]
%226 = icmp ult i64 %209, 3
br i1 %226, label %251, label %227
227: ; preds = %223, %227
%228 = phi i64 [ %248, %227 ], [ %224, %223 ]
%229 = phi i64 [ %249, %227 ], [ %225, %223 ]
%230 = getelementptr inbounds float, float* %0, i64 %228
%231 = load float, float* %230
%232 = getelementptr inbounds float, float* %0, i64 %229
store float %231, float* %232
%233 = add nsw i64 %228, %115
%234 = add nuw nsw i64 %229, 1
%235 = getelementptr inbounds float, float* %0, i64 %233
%236 = load float, float* %235
%237 = getelementptr inbounds float, float* %0, i64 %234
store float %236, float* %237
%238 = add nsw i64 %233, %115
%239 = add nuw nsw i64 %229, 2
%240 = getelementptr inbounds float, float* %0, i64 %238
%241 = load float, float* %240
%242 = getelementptr inbounds float, float* %0, i64 %239
store float %241, float* %242
%243 = add nsw i64 %238, %115
%244 = add nuw nsw i64 %229, 3
%245 = getelementptr inbounds float, float* %0, i64 %243
%246 = load float, float* %245
%247 = getelementptr inbounds float, float* %0, i64 %244
store float %246, float* %247
%248 = add nsw i64 %243, %115
%249 = add nuw nsw i64 %229, 4
%250 = icmp eq i64 %249, %116
br i1 %250, label %251, label %227
251: ; preds = %223, %227, %26, %203, %5, %109
ret void
}