apply_tsh(s, nt, dt, tsh) float *s, *dt, *tsh;
int nt;
{
  int it, itsh;
  itsh = (*tsh) / (*dt);
  if (itsh > 0) {
    for (it = nt - 1; it >= itsh; it--)
      s[it] = s[it - itsh];
    for (it = 0; it < itsh; it++)
      s[it] = 0.0;
  } else if (itsh < 0) {
    for (it = 0; it < nt + itsh; it++)
      s[it] = s[it - itsh];
  }
  *tsh = (*dt) * itsh;
}


x86 assembly (clang, -O0):
<apply_tsh>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
divss  (%rax),%xmm0
cvttss2si %xmm0,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    11ac <apply_tsh+0xac>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jl     1176 <apply_tsh+0x76>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    113d <apply_tsh+0x3d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    11a7 <apply_tsh+0xa7>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117d <apply_tsh+0x7d>
jmp    1205 <apply_tsh+0x105>
cmpl   $0x0,-0x30(%rbp)
jge    1200 <apply_tsh+0x100>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jge    11fb <apply_tsh+0xfb>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11bd <apply_tsh+0xbd>
jmp    1200 <apply_tsh+0x100>
jmp    1205 <apply_tsh+0x105>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
cvtsi2ssl -0x30(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<apply_tsh>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rcx,%r14
mov    %rdx,%r15
movss  (%rcx),%xmm0
divss  (%rdx),%xmm0
cvttss2si %xmm0,%r12d
test   %r12d,%r12d
jle    1196 <apply_tsh+0x86>
mov    %r12d,%r11d
cmp    %esi,%r12d
jge    1186 <apply_tsh+0x76>
movslq %esi,%rcx
lea    -0x1(%rcx),%rbx
cmp    %r11,%rbx
mov    %r11,%rax
cmovl  %rbx,%rax
mov    %rcx,%r8
sub    %rax,%r8
cmp    $0x8,%r8
jae    11b7 <apply_tsh+0xa7>
lea    -0x4(%rdi),%rax
lea    0x0(,%r11,4),%rbp
mov    %rax,%rdx
sub    %rbp,%rdx
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
lea    -0x1(%rcx),%rsi
mov    %rsi,%rcx
cmp    %r11,%rsi
jg     1170 <apply_tsh+0x60>
shl    $0x2,%r11
xor    %esi,%esi
mov    %r11,%rdx
call   1030 <memset@plt>
jmp    119c <apply_tsh+0x8c>
js     12c7 <apply_tsh+0x1b7>
xorps  %xmm0,%xmm0
cvtsi2ss %r12d,%xmm0
mulss  (%r15),%xmm0
movss  %xmm0,(%r14)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    %r11,%rbx
mov    %r11,%rax
cmovl  %rbx,%rax
not    %rax
add    %rcx,%rax
mov    $0x4,%edx
mul    %rdx
lea    -0x4(%rdi,%rcx,4),%rdx
seto   %r9b
mov    %rdx,%rbp
sub    %rax,%rbp
cmp    %rdx,%rbp
ja     1155 <apply_tsh+0x45>
test   %r9b,%r9b
jne    1155 <apply_tsh+0x45>
mov    %r11,%rdx
not    %rdx
add    %rcx,%rdx
lea    (%rdi,%rdx,4),%rbp
mov    %rbp,%rdx
sub    %rax,%rdx
cmp    %rbp,%rdx
ja     1155 <apply_tsh+0x45>
test   %r9b,%r9b
jne    1155 <apply_tsh+0x45>
cmp    %r11,%rbx
cmovge %r11,%rbx
lea    (%rdi,%rbx,4),%rax
mov    %rcx,%rdx
sub    %r11,%rdx
lea    (%rdi,%rdx,4),%rdx
cmp    %rdx,%rax
jae    1243 <apply_tsh+0x133>
lea    (%rdi,%rcx,4),%rax
sub    %r11,%rbx
lea    (%rdi,%rbx,4),%rdx
cmp    %rax,%rdx
jb     1155 <apply_tsh+0x45>
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     13e1 <apply_tsh+0x2d1>
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
or     $0x2,%rax
and    %r10,%rax
lea    (%rdi,%rcx,4),%rbp
add    $0xfffffffffffffff0,%rbp
lea    0x0(,%r11,4),%rdx
neg    %rdx
mov    $0xffffffffffffffff,%rbx
nopl   (%rax)
movups -0x10(%rbp,%rdx,1),%xmm0
movups 0x0(%rbp,%rdx,1),%xmm1
movups %xmm1,0x0(%rbp)
movups %xmm0,-0x10(%rbp)
movups -0x30(%rbp,%rdx,1),%xmm0
movups -0x20(%rbp,%rdx,1),%xmm1
movups %xmm1,-0x20(%rbp)
movups %xmm0,-0x30(%rbp)
add    $0xfffffffffffffff0,%rbx
add    $0xffffffffffffffc0,%rbp
add    $0xfffffffffffffffe,%rax
jne    1290 <apply_tsh+0x180>
jmp    13e8 <apply_tsh+0x2d8>
add    %r12d,%esi
test   %esi,%esi
jle    119c <apply_tsh+0x8c>
movslq %r12d,%rax
mov    %esi,%ecx
cmp    $0x8,%esi
jb     130a <apply_tsh+0x1fa>
lea    0x0(,%rax,4),%r9
mov    %rcx,%rdx
sub    %rax,%rdx
lea    (%rdi,%rdx,4),%rdx
cmp    %rdi,%rdx
jbe    13b9 <apply_tsh+0x2a9>
lea    (%rdi,%rcx,4),%rdx
mov    %rdi,%rsi
sub    %r9,%rsi
cmp    %rdx,%rsi
jae    13b9 <apply_tsh+0x2a9>
xor    %r8d,%r8d
mov    %r8,%r9
not    %r9
add    %rcx,%r9
mov    %rcx,%rsi
and    $0x3,%rsi
je     135b <apply_tsh+0x24b>
lea    (%rdi,%r8,4),%rbp
lea    0x0(,%rax,4),%rbx
neg    %rbx
neg    %rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  0x0(%rbp,%rbx,1),%xmm0
movss  %xmm0,0x0(%rbp)
add    $0xffffffffffffffff,%rdx
add    $0x4,%rbp
cmp    %rdx,%rsi
jne    1340 <apply_tsh+0x230>
sub    %rdx,%r8
cmp    $0x3,%r9
jb     119c <apply_tsh+0x8c>
sub    %r8,%rcx
lea    (%rdi,%r8,4),%rdx
add    $0xc,%rdx
shl    $0x2,%rax
neg    %rax
nopw   0x0(%rax,%rax,1)
movss  -0xc(%rdx,%rax,1),%xmm0
movss  %xmm0,-0xc(%rdx)
movss  -0x8(%rdx,%rax,1),%xmm0
movss  %xmm0,-0x8(%rdx)
movss  -0x4(%rdx,%rax,1),%xmm0
movss  %xmm0,-0x4(%rdx)
movss  (%rdx,%rax,1),%xmm0
movss  %xmm0,(%rdx)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1380 <apply_tsh+0x270>
jmp    119c <apply_tsh+0x8c>
mov    %ecx,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%rsi
mov    %rsi,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
mov    %ebx,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    141c <apply_tsh+0x30c>
xor    %esi,%esi
jmp    1489 <apply_tsh+0x379>
mov    $0xffffffffffffffff,%rbx
test   $0x1,%r10b
je     140b <apply_tsh+0x2fb>
add    %rcx,%rbx
mov    %rbx,%rax
sub    %r11,%rax
movups -0x1c(%rdi,%rax,4),%xmm0
movups -0xc(%rdi,%rax,4),%xmm1
movups %xmm1,-0xc(%rdi,%rbx,4)
movups %xmm0,-0x1c(%rdi,%rbx,4)
cmp    %r9,%r8
je     1186 <apply_tsh+0x76>
sub    %r9,%rcx
jmp    1155 <apply_tsh+0x45>
and    $0xfffffffffffffffc,%rbx
mov    $0x1c,%esi
sub    %rax,%rsi
lea    (%rdi,%rsi,4),%rbp
xor    %esi,%esi
xchg   %ax,%ax
movups -0x70(%rbp,%rsi,4),%xmm0
movups -0x60(%rbp,%rsi,4),%xmm1
movups %xmm0,(%rdi,%rsi,4)
movups %xmm1,0x10(%rdi,%rsi,4)
movups -0x50(%rbp,%rsi,4),%xmm0
movups -0x40(%rbp,%rsi,4),%xmm1
movups %xmm0,0x20(%rdi,%rsi,4)
movups %xmm1,0x30(%rdi,%rsi,4)
movups -0x30(%rbp,%rsi,4),%xmm0
movups -0x20(%rbp,%rsi,4),%xmm1
movups %xmm0,0x40(%rdi,%rsi,4)
movups %xmm1,0x50(%rdi,%rsi,4)
movups -0x10(%rbp,%rsi,4),%xmm0
movups 0x0(%rbp,%rsi,4),%xmm1
movups %xmm0,0x60(%rdi,%rsi,4)
movups %xmm1,0x70(%rdi,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rbx
jne    1430 <apply_tsh+0x320>
test   %rdx,%rdx
je     14bc <apply_tsh+0x3ac>
lea    (%rdi,%rsi,4),%rsi
add    $0x10,%rsi
neg    %r9
nopl   0x0(%rax)
movups -0x10(%rsi,%r9,1),%xmm0
movups (%rsi,%r9,1),%xmm1
movups %xmm0,-0x10(%rsi)
movups %xmm1,(%rsi)
add    $0x20,%rsi
add    $0xffffffffffffffff,%rdx
jne    14a0 <apply_tsh+0x390>
cmp    %rcx,%r8
je     119c <apply_tsh+0x8c>
jmp    130d <apply_tsh+0x1fd>

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

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