#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*/ memcpy(float *, float *, int);
void src_shiftin(float *a, int a_length, float *b, int b_length) {
  if (b_length > a_length)
    memcpy(a, &b[b_length - a_length], a_length * sizeof(float));
  else {
    for (int i = 0; i < (a_length - b_length); i++)
      a[i] = a[i + b_length];
    for (int i = 0; i < b_length; i++)
      a[i + a_length - b_length] = b[i];
  }
}


x86 assembly (clang, -O0):
<src_shiftin>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    115d <src_shiftin+0x4d>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x1c(%rbp),%eax
sub    -0xc(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
call   1030 <memcpy@plt>
jmp    11ea <src_shiftin+0xda>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    11a2 <src_shiftin+0x92>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1164 <src_shiftin+0x54>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11e5 <src_shiftin+0xd5>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11a9 <src_shiftin+0x99>
jmp    11ea <src_shiftin+0xda>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<src_shiftin>:
mov    %esi,%r9d
mov    %esi,%r8d
sub    %ecx,%r8d
jge    1131 <src_shiftin+0x21>
sub    %r9d,%ecx
movslq %ecx,%rax
lea    (%rdx,%rax,4),%rsi
shl    $0x2,%r9d
mov    %r9d,%edx
jmp    1030 <memcpy@plt>
push   %rbp
push   %r15
push   %r14
push   %rbx
test   %r8d,%r8d
jle    12c6 <src_shiftin+0x1b6>
movslq %ecx,%r10
mov    %r8d,%r14d
cmp    $0x8,%r8d
jb     116e <src_shiftin+0x5e>
lea    (%r10,%r14,1),%rax
lea    (%rdi,%rax,4),%rax
cmp    %rdi,%rax
jbe    11fc <src_shiftin+0xec>
lea    (%rdi,%r14,4),%rax
lea    (%rdi,%r10,4),%rsi
cmp    %rax,%rsi
jae    11fc <src_shiftin+0xec>
xor    %eax,%eax
mov    %rax,%r11
not    %r11
add    %r14,%r11
mov    %r14,%rbx
and    $0x3,%rbx
je     11a4 <src_shiftin+0x94>
lea    (%rdi,%r10,4),%rsi
cs nopw 0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1190 <src_shiftin+0x80>
cmp    $0x3,%r11
jb     12c6 <src_shiftin+0x1b6>
lea    0xc(%rdi),%rsi
lea    (%rdi,%r10,4),%rbx
add    $0xc,%rbx
nopw   0x0(%rax,%rax,1)
movss  -0xc(%rbx,%rax,4),%xmm0
movss  %xmm0,-0xc(%rsi,%rax,4)
movss  -0x8(%rbx,%rax,4),%xmm0
movss  %xmm0,-0x8(%rsi,%rax,4)
movss  -0x4(%rbx,%rax,4),%xmm0
movss  %xmm0,-0x4(%rsi,%rax,4)
movss  (%rbx,%rax,4),%xmm0
movss  %xmm0,(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r14
jne    11c0 <src_shiftin+0xb0>
jmp    12c6 <src_shiftin+0x1b6>
mov    %r14d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%r15
shr    $0x3,%r15
add    $0x1,%r15
mov    %r15d,%r11d
and    $0x3,%r11d
cmp    $0x18,%rsi
jae    1222 <src_shiftin+0x112>
xor    %esi,%esi
jmp    1288 <src_shiftin+0x178>
and    $0xfffffffffffffffc,%r15
lea    (%rdi,%r10,4),%rbx
add    $0x70,%rbx
xor    %esi,%esi
movups -0x70(%rbx,%rsi,4),%xmm0
movups -0x60(%rbx,%rsi,4),%xmm1
movups %xmm0,(%rdi,%rsi,4)
movups %xmm1,0x10(%rdi,%rsi,4)
movups -0x50(%rbx,%rsi,4),%xmm0
movups -0x40(%rbx,%rsi,4),%xmm1
movups %xmm0,0x20(%rdi,%rsi,4)
movups %xmm1,0x30(%rdi,%rsi,4)
movups -0x30(%rbx,%rsi,4),%xmm0
movups -0x20(%rbx,%rsi,4),%xmm1
movups %xmm0,0x40(%rdi,%rsi,4)
movups %xmm1,0x50(%rdi,%rsi,4)
movups -0x10(%rbx,%rsi,4),%xmm0
movups (%rbx,%rsi,4),%xmm1
movups %xmm0,0x60(%rdi,%rsi,4)
movups %xmm1,0x70(%rdi,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%r15
jne    1230 <src_shiftin+0x120>
test   %r11,%r11
je     12bd <src_shiftin+0x1ad>
lea    (%rdi,%rsi,4),%r15
add    $0x10,%r15
lea    (%r15,%r10,4),%rbx
shl    $0x5,%r11
xor    %esi,%esi
nop
movups -0x10(%rbx,%rsi,1),%xmm0
movups (%rbx,%rsi,1),%xmm1
movups %xmm0,-0x10(%r15,%rsi,1)
movups %xmm1,(%r15,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r11
jne    12a0 <src_shiftin+0x190>
cmp    %r14,%rax
jne    1170 <src_shiftin+0x60>
test   %ecx,%ecx
jle    137b <src_shiftin+0x26b>
mov    %ecx,%r11d
cmp    $0x8,%ecx
jae    1382 <src_shiftin+0x272>
xor    %esi,%esi
mov    %rsi,%r10
not    %r10
add    %r11,%r10
mov    %r11,%rbx
and    $0x3,%rbx
je     131a <src_shiftin+0x20a>
mov    %r8d,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rsi,4),%xmm0
lea    (%rax,%rsi,1),%ebp
movslq %ebp,%rbp
movss  %xmm0,(%rdi,%rbp,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbx
jne    1300 <src_shiftin+0x1f0>
cmp    $0x3,%r10
jb     137b <src_shiftin+0x26b>
sub    %ecx,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rsi,4),%xmm0
lea    (%r9,%rsi,1),%rax
cltq
movss  %xmm0,(%rdi,%rax,4)
movss  0x4(%rdx,%rsi,4),%xmm0
lea    0x1(%rax),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rdi,%rcx,4)
movss  0x8(%rdx,%rsi,4),%xmm0
lea    0x2(%rax),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rdi,%rcx,4)
movss  0xc(%rdx,%rsi,4),%xmm0
add    $0x3,%eax
cltq
movss  %xmm0,(%rdi,%rax,4)
add    $0x4,%rsi
cmp    %rsi,%r11
jne    1330 <src_shiftin+0x220>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
lea    -0x1(%r11),%rax
lea    (%r8,%rax,1),%ebx
xor    %esi,%esi
cmp    %r8d,%ebx
jl     12dc <src_shiftin+0x1cc>
shr    $0x20,%rax
jne    12dc <src_shiftin+0x1cc>
movslq %r8d,%rax
lea    (%rax,%r11,1),%rsi
lea    (%rdi,%rsi,4),%rsi
cmp    %rdx,%rsi
jbe    13c0 <src_shiftin+0x2b0>
lea    (%rdx,%r11,4),%rsi
lea    (%rdi,%rax,4),%rax
cmp    %rsi,%rax
jb     12da <src_shiftin+0x1ca>
mov    %r11d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     142d <src_shiftin+0x31d>
movabs $0x3ffffffffffffffc,%r14
ff ff 3f
or     $0x2,%r14
and    %r10,%r14
xor    %eax,%eax
mov    %r8d,%ebx
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
movslq %ebx,%rbx
movups %xmm0,(%rdi,%rbx,4)
movups %xmm1,0x10(%rdi,%rbx,4)
movups 0x20(%rdx,%rax,4),%xmm0
movups 0x30(%rdx,%rax,4),%xmm1
lea    0x8(%rbx),%ebp
movslq %ebp,%rbp
movups %xmm0,(%rdi,%rbp,4)
movups %xmm1,0x10(%rdi,%rbp,4)
add    $0x10,%rax
add    $0x10,%ebx
add    $0xfffffffffffffffe,%r14
jne    13f0 <src_shiftin+0x2e0>
jmp    142f <src_shiftin+0x31f>
xor    %eax,%eax
test   $0x1,%r10b
je     144c <src_shiftin+0x33c>
movups (%rdx,%rax,4),%xmm0
movups 0x10(%rdx,%rax,4),%xmm1
add    %r8d,%eax
cltq
movups %xmm0,(%rdi,%rax,4)
movups %xmm1,0x10(%rdi,%rax,4)
cmp    %r11,%rsi
jne    12dc <src_shiftin+0x1cc>
jmp    137b <src_shiftin+0x26b>

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

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