void d(float **A, float **B, int n, int m, int is, int js) {
  int t4;
  int t2;
  int chill_t6;
  int chill_t5;
  int chill_t4;
  int chill_t3;
  int over1;
  int chill_t2;
  int chill_t1;
  int i;
  int j;
  over1 = 0;
  for (t2 = 0; t2 <= 2 * n - 1; t2 += 1) {
    over1 = m % 4;
    for (t4 = 0; t4 <= m - over1 - 1; t4 += 4) {
      A[t2 - 8][t4 + 3] = (A[t2][t4] + B[t2][t4]);
      A[t2 - 8][t4 + 1 + 3] = (A[t2][t4 + 1] + B[t2][t4 + 1]);
      A[t2 - 8][t4 + 2 + 3] = (A[t2][t4 + 2] + B[t2][t4 + 2]);
      A[t2 - 8][t4 + 3 + 3] = (A[t2][t4 + 3] + B[t2][t4 + 3]);
    }
    for (t4 = ((m - over1) > (0) ? (m - over1) : (0)); t4 <= m - 1; t4 += 1)
      A[t2 - 8][t4 + 3] = (A[t2][t4] + B[t2][t4]);
  }
}


x86 assembly (clang, -O0):
<d>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x14(%rbp),%ecx
shl    $0x1,%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1366 <d+0x266>
mov    -0x18(%rbp),%eax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x3c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12be <d+0x1be>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x8,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x8,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x8,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x8,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
jmp    1151 <d+0x51>
mov    -0x18(%rbp),%eax
sub    -0x3c(%rbp),%eax
cmp    $0x0,%eax
jle    12db <d+0x1db>
mov    -0x18(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
jmp    12e5 <d+0x1e5>
xor    %eax,%eax
mov    %eax,-0x50(%rbp)
jmp    12e5 <d+0x1e5>
mov    -0x50(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1353 <d+0x253>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x8,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12eb <d+0x1eb>
jmp    1358 <d+0x258>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1128 <d+0x28>
pop    %rbp
ret

x86 assembly (clang, -O2):
<d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
test   %edx,%edx
jle    1462 <d+0x362>
add    %edx,%edx
lea    0x3(%rcx),%r12d
test   %ecx,%ecx
cmovns %ecx,%r12d
xor    %r10d,%r10d
and    $0xfffffffc,%r12d
mov    $0x0,%r13d
cmovns %r12d,%r13d
movslq %r12d,%r9
cmp    $0x2,%edx
mov    $0x1,%eax
cmovge %edx,%eax
mov    %rax,(%rsp)
mov    %ecx,%r8d
lea    0x3(%r13),%rax
mov    %rax,-0x10(%rsp)
lea    0x3(%r8),%rax
mov    %rax,-0x18(%rsp)
mov    %r8,%rax
sub    %r13,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,-0x20(%rsp)
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rax,-0x58(%rsp)
and    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rsp)
add    %r13,%rax
mov    %rax,-0x38(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x28(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,-0x40(%rsp)
mov    %r8,%rax
neg    %rax
mov    %rax,-0x8(%rsp)
lea    0xf(%r13),%rax
mov    %rax,-0x48(%rsp)
lea    0xc(%r13),%rax
mov    %rax,-0x50(%rsp)
mov    %rcx,-0x60(%rsp)
mov    %rsi,-0x68(%rsp)
mov    %rdi,-0x70(%rsp)
mov    %r12d,-0x7c(%rsp)
mov    %r13,-0x78(%rsp)
jmp    11de <d+0xde>
nopl   (%rax)
add    $0x1,%r10
cmp    (%rsp),%r10
je     1462 <d+0x362>
test   %r12d,%r12d
jle    1257 <d+0x157>
mov    -0x40(%rdi,%r10,8),%r11
mov    (%rdi,%r10,8),%rbp
mov    (%rsi,%r10,8),%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%rbp,%rdx,4),%xmm0
addss  (%rbx,%rdx,4),%xmm0
movss  %xmm0,0xc(%r11,%rdx,4)
movss  0x4(%rbp,%rdx,4),%xmm0
addss  0x4(%rbx,%rdx,4),%xmm0
movss  %xmm0,0x10(%r11,%rdx,4)
movss  0x8(%rbp,%rdx,4),%xmm0
addss  0x8(%rbx,%rdx,4),%xmm0
movss  %xmm0,0x14(%r11,%rdx,4)
movss  0xc(%rbp,%rdx,4),%xmm0
addss  0xc(%rbx,%rdx,4),%xmm0
movss  %xmm0,0x18(%r11,%rdx,4)
lea    0x4(%rdx),%rax
mov    %rax,%rdx
cmp    %r9,%rax
jl     1200 <d+0x100>
cmp    %ecx,%r13d
jge    11d0 <d+0xd0>
mov    -0x40(%rdi,%r10,8),%rbp
mov    (%rdi,%r10,8),%r14
mov    (%rsi,%r10,8),%r15
mov    %r13,%rbx
cmpq   $0x8,-0x58(%rsp)
jae    12f0 <d+0x1f0>
mov    %r8d,%edx
sub    %ebx,%edx
mov    %rbx,%rax
test   $0x1,%dl
je     129b <d+0x19b>
movss  (%r14,%rbx,4),%xmm0
addss  (%r15,%rbx,4),%xmm0
movss  %xmm0,0xc(%rbp,%rbx,4)
lea    0x1(%rbx),%rax
not    %rbx
cmp    -0x8(%rsp),%rbx
je     11d0 <d+0xd0>
nopl   0x0(%rax)
movss  (%r14,%rax,4),%xmm0
addss  (%r15,%rax,4),%xmm0
movss  %xmm0,0xc(%rbp,%rax,4)
movss  0x4(%r14,%rax,4),%xmm0
addss  0x4(%r15,%rax,4),%xmm0
movss  %xmm0,0x10(%rbp,%rax,4)
add    $0x2,%rax
cmp    %rax,%r8
jne    12b0 <d+0x1b0>
jmp    11d0 <d+0xd0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x10(%rsp),%rax
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
mov    -0x18(%rsp),%rdx
lea    0x0(%rbp,%rdx,4),%rdx
lea    (%r14,%r13,4),%r12
lea    (%r14,%r8,4),%rbx
lea    (%r15,%r13,4),%r11
lea    (%r15,%r8,4),%rsi
cmp    %rbx,%rax
setb   %r13b
cmp    %rdx,%r12
setb   %r12b
cmp    %rsi,%rax
setb   %al
cmp    %rdx,%r11
mov    -0x70(%rsp),%rdi
mov    -0x68(%rsp),%rsi
mov    -0x60(%rsp),%rcx
setb   %dl
mov    -0x78(%rsp),%rbx
test   %r12b,%r13b
mov    -0x78(%rsp),%r13
mov    -0x7c(%rsp),%r12d
jne    1278 <d+0x178>
mov    %r13,%rbx
and    %dl,%al
jne    1278 <d+0x178>
cmpq   $0x8,-0x20(%rsp)
jae    1376 <d+0x276>
xor    %r13d,%r13d
jmp    13fb <d+0x2fb>
mov    -0x48(%rsp),%rax
lea    0x0(,%rax,4),%r12
add    %rbp,%r12
mov    -0x50(%rsp),%rax
lea    (%r15,%rax,4),%rbx
lea    (%r14,%rax,4),%r11
mov    -0x40(%rsp),%rcx
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
movups -0x30(%r11,%r13,4),%xmm0
movups -0x20(%r11,%r13,4),%xmm1
movups -0x30(%rbx,%r13,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rbx,%r13,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x30(%r12,%r13,4)
movups %xmm0,-0x20(%r12,%r13,4)
movups -0x10(%r11,%r13,4),%xmm0
movups (%r11,%r13,4),%xmm1
movups -0x10(%rbx,%r13,4),%xmm2
addps  %xmm0,%xmm2
movups (%rbx,%r13,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,-0x10(%r12,%r13,4)
movups %xmm0,(%r12,%r13,4)
add    $0x10,%r13
add    $0xfffffffffffffffe,%rcx
jne    13a0 <d+0x2a0>
testb  $0x1,-0x28(%rsp)
mov    -0x60(%rsp),%rcx
mov    -0x68(%rsp),%rsi
mov    -0x70(%rsp),%rdi
mov    -0x7c(%rsp),%r12d
je     1443 <d+0x343>
add    -0x78(%rsp),%r13
movups (%r14,%r13,4),%xmm0
movups 0x10(%r14,%r13,4),%xmm1
movups (%r15,%r13,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%r15,%r13,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,0xc(%rbp,%r13,4)
movups %xmm0,0x1c(%rbp,%r13,4)
mov    -0x38(%rsp),%rbx
mov    -0x30(%rsp),%rax
cmp    %rax,-0x58(%rsp)
mov    -0x78(%rsp),%r13
je     11d0 <d+0xd0>
jmp    1278 <d+0x178>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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