int arrayMerge(const float arrayOne[], const float arrayTwo[], float merged[],
               int sOne, int sTwo) {
  int i, j, sMerged;
  for (i = 0, sMerged = 0, j = 0; i < sOne && j < sTwo;) {
    if (arrayOne[i] == arrayTwo[j]) {
      merged[sMerged++] = arrayOne[i++];
      j++;
    } else if (arrayOne[i] < arrayTwo[j]) {
      merged[sMerged++] = arrayOne[i++];
    } else {
      merged[sMerged++] = arrayTwo[j++];
    }
  }
  while (i < sOne)
    merged[sMerged++] = arrayOne[i++];
  while (j < sTwo)
    merged[sMerged++] = arrayTwo[j++];
  return sMerged;
}


x86 assembly (clang, -O0):
<arrayMerge>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x24(%rbp),%ecx
xor    %eax,%eax
cmp    -0x1c(%rbp),%ecx
mov    %al,-0x2d(%rbp)
jge    1149 <arrayMerge+0x49>
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
setl   %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    1159 <arrayMerge+0x59>
jmp    1248 <arrayMerge+0x148>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jne    11ba <arrayMerge+0xba>
jp     11ba <arrayMerge+0xba>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1243 <arrayMerge+0x143>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1210 <arrayMerge+0x110>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    123e <arrayMerge+0x13e>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1243 <arrayMerge+0x143>
jmp    112c <arrayMerge+0x2c>
jmp    124d <arrayMerge+0x14d>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    128c <arrayMerge+0x18c>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    124d <arrayMerge+0x14d>
jmp    1291 <arrayMerge+0x191>
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12d0 <arrayMerge+0x1d0>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1291 <arrayMerge+0x191>
mov    -0x2c(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<arrayMerge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
xor    %r10d,%r10d
test   %ecx,%ecx
jle    131d <arrayMerge+0x21d>
mov    $0x0,%r9d
mov    $0x0,%eax
test   %r8d,%r8d
jle    118e <arrayMerge+0x8e>
xor    %eax,%eax
xor    %r9d,%r9d
xor    %r10d,%r10d
nopl   (%rax)
movslq %r10d,%rbp
movss  (%rdi,%rbp,4),%xmm0
movslq %r9d,%rbp
movss  (%rsi,%rbp,4),%xmm1
ucomiss %xmm1,%xmm0
jne    1160 <arrayMerge+0x60>
jp     1160 <arrayMerge+0x60>
add    $0x1,%r10d
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%r9d
jmp    1180 <arrayMerge+0x80>
cs nopw 0x0(%rax,%rax,1)
ucomiss %xmm0,%xmm1
jbe    1170 <arrayMerge+0x70>
add    $0x1,%r10d
movss  %xmm0,(%rdx,%rax,4)
jmp    1180 <arrayMerge+0x80>
add    $0x1,%r9d
movss  %xmm1,(%rdx,%rax,4)
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %ecx,%r10d
jge    118e <arrayMerge+0x8e>
cmp    %r8d,%r9d
jl     1130 <arrayMerge+0x30>
cmp    %ecx,%r10d
jge    132b <arrayMerge+0x22b>
mov    %eax,%eax
movslq %r10d,%r11
movslq %ecx,%r10
mov    %r10,%r12
sub    %r11,%r12
cmp    $0x8,%r12
jb     1288 <arrayMerge+0x188>
lea    (%rdx,%rax,4),%rbx
lea    (%rdi,%r10,4),%rbp
cmp    %rbp,%rbx
jae    11d4 <arrayMerge+0xd4>
lea    (%r10,%rax,1),%rbx
sub    %r11,%rbx
lea    (%rdx,%rbx,4),%rbx
lea    (%rdi,%r11,4),%rbp
cmp    %rbx,%rbp
jb     1288 <arrayMerge+0x188>
mov    %r12,%rbp
and    $0xfffffffffffffff8,%rbp
lea    -0x8(%rbp),%rbx
mov    %rbx,%r15
shr    $0x3,%r15
add    $0x1,%r15
test   %rbx,%rbx
mov    %rbp,-0x8(%rsp)
je     14b5 <arrayMerge+0x3b5>
mov    %r15,%r13
and    $0xfffffffffffffffe,%r13
lea    (%rdi,%r11,4),%rbp
add    $0x30,%rbp
lea    (%rdx,%rax,4),%r14
add    $0x30,%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rbp,%rbx,4),%xmm0
movups -0x20(%rbp,%rbx,4),%xmm1
movups %xmm0,-0x30(%r14,%rbx,4)
movups %xmm1,-0x20(%r14,%rbx,4)
movups -0x10(%rbp,%rbx,4),%xmm0
movups 0x0(%rbp,%rbx,4),%xmm1
movups %xmm0,-0x10(%r14,%rbx,4)
movups %xmm1,(%r14,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%r13
jne    1220 <arrayMerge+0x120>
test   $0x1,%r15b
je     1274 <arrayMerge+0x174>
lea    (%rbx,%r11,1),%rbp
add    %rax,%rbx
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups %xmm0,(%rdx,%rbx,4)
movups %xmm1,0x10(%rdx,%rbx,4)
mov    -0x8(%rsp),%rbx
add    %rbx,%rax
cmp    %rbx,%r12
je     132b <arrayMerge+0x22b>
add    %rbx,%r11
sub    %r11d,%ecx
mov    %r11,%rbx
not    %rbx
add    %r10,%rbx
and    $0x3,%rcx
je     12b9 <arrayMerge+0x1b9>
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%r11,4),%xmm0
add    $0x1,%r11
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
jne    12a0 <arrayMerge+0x1a0>
cmp    $0x3,%rbx
jb     132b <arrayMerge+0x22b>
sub    %r11,%r10
lea    (%rdi,%r11,4),%rdi
add    $0xc,%rdi
lea    (%rdx,%rax,4),%rbp
add    $0xc,%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0xc(%rdi,%rcx,4),%xmm0
movss  %xmm0,-0xc(%rbp,%rcx,4)
movss  -0x8(%rdi,%rcx,4),%xmm0
movss  %xmm0,-0x8(%rbp,%rcx,4)
movss  -0x4(%rdi,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rbp,%rcx,4)
movss  (%rdi,%rcx,4),%xmm0
movss  %xmm0,0x0(%rbp,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    12e0 <arrayMerge+0x1e0>
add    %rcx,%rax
jmp    132b <arrayMerge+0x22b>
xor    %r9d,%r9d
xor    %eax,%eax
cmp    %ecx,%r10d
jl     1197 <arrayMerge+0x97>
cmp    %r8d,%r9d
jge    14aa <arrayMerge+0x3aa>
mov    %eax,%eax
movslq %r9d,%rdi
movslq %r8d,%r14
mov    %r14,%r11
sub    %rdi,%r11
cmp    $0x8,%r11
jb     1413 <arrayMerge+0x313>
lea    (%rdx,%rax,4),%rcx
lea    (%rsi,%r14,4),%rbp
cmp    %rbp,%rcx
jae    1371 <arrayMerge+0x271>
lea    (%r14,%rax,1),%rcx
sub    %rdi,%rcx
lea    (%rdx,%rcx,4),%rcx
lea    (%rsi,%rdi,4),%rbp
cmp    %rcx,%rbp
jb     1413 <arrayMerge+0x313>
mov    %r11,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     14c6 <arrayMerge+0x3c6>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%rsi,%rdi,4),%r15
add    $0x30,%r15
lea    (%rdx,%rax,4),%rbp
add    $0x30,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x30(%r15,%rbx,4),%xmm0
movups -0x20(%r15,%rbx,4),%xmm1
movups %xmm0,-0x30(%rbp,%rbx,4)
movups %xmm1,-0x20(%rbp,%rbx,4)
movups -0x10(%r15,%rbx,4),%xmm0
movups (%r15,%rbx,4),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,4)
movups %xmm1,0x0(%rbp,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rcx
jne    13b0 <arrayMerge+0x2b0>
test   $0x1,%r10b
je     1404 <arrayMerge+0x304>
lea    (%rbx,%rdi,1),%rcx
add    %rax,%rbx
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
movups %xmm0,(%rdx,%rbx,4)
movups %xmm1,0x10(%rdx,%rbx,4)
add    %r9,%rax
cmp    %r9,%r11
je     14aa <arrayMerge+0x3aa>
add    %r9,%rdi
sub    %edi,%r8d
mov    %rdi,%rbx
not    %rbx
add    %r14,%rbx
and    $0x3,%r8
je     1448 <arrayMerge+0x348>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rsi,%rdi,4),%xmm0
add    $0x1,%rdi
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%r8
jne    1430 <arrayMerge+0x330>
cmp    $0x3,%rbx
jb     14aa <arrayMerge+0x3aa>
sub    %rdi,%r14
lea    (%rsi,%rdi,4),%rsi
add    $0xc,%rsi
lea    (%rdx,%rax,4),%rdx
add    $0xc,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0xc(%rsi,%rcx,4),%xmm0
movss  %xmm0,-0xc(%rdx,%rcx,4)
movss  -0x8(%rsi,%rcx,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rcx,4)
movss  -0x4(%rsi,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rcx,4)
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r14
jne    1470 <arrayMerge+0x370>
add    %rcx,%rax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
test   $0x1,%r15b
jne    125b <arrayMerge+0x15b>
jmp    1274 <arrayMerge+0x174>
xor    %ebx,%ebx
test   $0x1,%r10b
jne    13eb <arrayMerge+0x2eb>
jmp    1404 <arrayMerge+0x304>

LLVM IR (-O0):
define i32 @arrayMerge(float* %0, float* %1, float* %2, i32 %3, i32 %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store float* %0, float** %6
store float* %1, float** %7
store float* %2, float** %8
store i32 %3, i32* %9
store i32 %4, i32* %10
store i32 0, i32* %11
store i32 0, i32* %13
store i32 0, i32* %12
br label %14
14: ; preds = %87, %5
%15 = load i32, i32* %11
%16 = load i32, i32* %9
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %22
18: ; preds = %14
%19 = load i32, i32* %12
%20 = load i32, i32* %10
%21 = icmp slt i32 %19, %20
br label %22
22: ; preds = %18, %14
%23 = phi i1 [ false, %14 ], [ %21, %18 ]
br i1 %23, label %24, label %88
24: ; preds = %22
%25 = load float*, float** %6
%26 = load i32, i32* %11
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds float, float* %25, i64 %27
%29 = load float, float* %28
%30 = load float*, float** %7
%31 = load i32, i32* %12
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds float, float* %30, i64 %32
%34 = load float, float* %33
%35 = fcmp oeq float %29, %34
br i1 %35, label %36, label %50
36: ; preds = %24
%37 = load float*, float** %6
%38 = load i32, i32* %11
%39 = add nsw i32 %38, 1
store i32 %39, i32* %11
%40 = sext i32 %38 to i64
%41 = getelementptr inbounds float, float* %37, i64 %40
%42 = load float, float* %41
%43 = load float*, float** %8
%44 = load i32, i32* %13
%45 = add nsw i32 %44, 1
store i32 %45, i32* %13
%46 = sext i32 %44 to i64
%47 = getelementptr inbounds float, float* %43, i64 %46
store float %42, float* %47
%48 = load i32, i32* %12
%49 = add nsw i32 %48, 1
store i32 %49, i32* %12
br label %87
50: ; preds = %24
%51 = load float*, float** %6
%52 = load i32, i32* %11
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %51, i64 %53
%55 = load float, float* %54
%56 = load float*, float** %7
%57 = load i32, i32* %12
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %56, i64 %58
%60 = load float, float* %59
%61 = fcmp olt float %55, %60
br i1 %61, label %62, label %74
62: ; preds = %50
%63 = load float*, float** %6
%64 = load i32, i32* %11
%65 = add nsw i32 %64, 1
store i32 %65, i32* %11
%66 = sext i32 %64 to i64
%67 = getelementptr inbounds float, float* %63, i64 %66
%68 = load float, float* %67
%69 = load float*, float** %8
%70 = load i32, i32* %13
%71 = add nsw i32 %70, 1
store i32 %71, i32* %13
%72 = sext i32 %70 to i64
%73 = getelementptr inbounds float, float* %69, i64 %72
store float %68, float* %73
br label %86
74: ; preds = %50
%75 = load float*, float** %7
%76 = load i32, i32* %12
%77 = add nsw i32 %76, 1
store i32 %77, i32* %12
%78 = sext i32 %76 to i64
%79 = getelementptr inbounds float, float* %75, i64 %78
%80 = load float, float* %79
%81 = load float*, float** %8
%82 = load i32, i32* %13
%83 = add nsw i32 %82, 1
store i32 %83, i32* %13
%84 = sext i32 %82 to i64
%85 = getelementptr inbounds float, float* %81, i64 %84
store float %80, float* %85
br label %86
86: ; preds = %74, %62
br label %87
87: ; preds = %86, %36
br label %14
88: ; preds = %22
br label %89
89: ; preds = %93, %88
%90 = load i32, i32* %11
%91 = load i32, i32* %9
%92 = icmp slt i32 %90, %91
br i1 %92, label %93, label %105
93: ; preds = %89
%94 = load float*, float** %6
%95 = load i32, i32* %11
%96 = add nsw i32 %95, 1
store i32 %96, i32* %11
%97 = sext i32 %95 to i64
%98 = getelementptr inbounds float, float* %94, i64 %97
%99 = load float, float* %98
%100 = load float*, float** %8
%101 = load i32, i32* %13
%102 = add nsw i32 %101, 1
store i32 %102, i32* %13
%103 = sext i32 %101 to i64
%104 = getelementptr inbounds float, float* %100, i64 %103
store float %99, float* %104
br label %89
105: ; preds = %89
br label %106
106: ; preds = %110, %105
%107 = load i32, i32* %12
%108 = load i32, i32* %10
%109 = icmp slt i32 %107, %108
br i1 %109, label %110, label %122
110: ; preds = %106
%111 = load float*, float** %7
%112 = load i32, i32* %12
%113 = add nsw i32 %112, 1
store i32 %113, i32* %12
%114 = sext i32 %112 to i64
%115 = getelementptr inbounds float, float* %111, i64 %114
%116 = load float, float* %115
%117 = load float*, float** %8
%118 = load i32, i32* %13
%119 = add nsw i32 %118, 1
store i32 %119, i32* %13
%120 = sext i32 %118 to i64
%121 = getelementptr inbounds float, float* %117, i64 %120
store float %116, float* %121
br label %106
122: ; preds = %106
%123 = load i32, i32* %13
ret i32 %123
}

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