void meshgrid_float(float *x, float *y, float *z, float *outArr, int r, int c,
                    int d) {
  int i, j, k, offset;
  for (k = 0; k < d / 3; k++) {
    for (i = 0; i < r; i++) {
      for (j = 0; j < c; j++) {
        offset = (d * j) + (c * d * i) + k;
        *(outArr + offset) = *(x + j);
        *(outArr + offset + (3 * 2 + 1)) = *(y + i);
        *(outArr + offset + 2 * (3 * 2 + 1)) = *(z + k);
      }
    }
  }
}


x86 assembly (clang, -O0):
<meshgrid_float>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x10(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3c(%rbp),%eax
cmp    %ecx,%eax
jge    1208 <meshgrid_float+0x108>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11f5 <meshgrid_float+0xf5>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11e2 <meshgrid_float+0xe2>
mov    0x10(%rbp),%eax
imul   -0x30(%rbp),%eax
mov    -0x28(%rbp),%ecx
imul   0x10(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    %ecx,%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,0x1c(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,0x38(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    115e <meshgrid_float+0x5e>
jmp    11e7 <meshgrid_float+0xe7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114b <meshgrid_float+0x4b>
jmp    11fa <meshgrid_float+0xfa>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1126 <meshgrid_float+0x26>
pop    %rbp
ret

x86 assembly (clang, -O2):
<meshgrid_float>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8d,-0x78(%rsp)
mov    0x50(%rsp),%eax
cmp    $0x3,%eax
jl     14f7 <meshgrid_float+0x3f7>
mov    %r9d,%r8d
mov    0x50(%rsp),%ebp
mov    %ebp,%eax
mov    $0xaaaaaaab,%ebx
imul   %rax,%rbx
shr    $0x21,%rbx
mov    %rbx,-0x40(%rsp)
mov    -0x78(%rsp),%eax
mov    %rax,0x10(%rsp)
mov    %r9d,%r15d
lea    -0x1(%r15),%rax
mov    %rax,(%rsp)
lea    (%rdi,%r15,4),%rax
mov    %rax,-0x10(%rsp)
lea    (%rcx,%r15,4),%rax
add    $0x38,%rax
mov    %rax,-0x18(%rsp)
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x28(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rsp)
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rbx,%rax
mov    %rbx,-0x38(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,-0x48(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0x8(%rsp)
lea    0x0(,%rbp,4),%eax
mov    %rax,-0x50(%rsp)
mov    %ebp,%r14d
imul   %r9d,%r14d
lea    0x0(,%rbp,8),%eax
mov    %eax,-0x60(%rsp)
lea    0x0(%rbp,%rbp,1),%r12d
xor    %r13d,%r13d
mov    %r9d,-0x5c(%rsp)
mov    %r14d,-0x7c(%rsp)
jmp    11ef <meshgrid_float+0xef>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r13
cmp    -0x40(%rsp),%r13
je     14f7 <meshgrid_float+0x3f7>
cmpl   $0x0,-0x78(%rsp)
jle    11e0 <meshgrid_float+0xe0>
lea    (%rdx,%r13,4),%r11
lea    (%rdx,%r13,4),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rsp)
xor    %eax,%eax
mov    %rax,-0x68(%rsp)
mov    $0x1,%eax
mov    %rax,-0x70(%rsp)
mov    %r13d,%eax
mov    %r13d,-0x74(%rsp)
xor    %r9d,%r9d
mov    %r11,-0x20(%rsp)
jmp    125a <meshgrid_float+0x15a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r9
add    %r14d,-0x74(%rsp)
mov    -0x68(%rsp),%rax
add    %r8d,%eax
mov    %rax,-0x68(%rsp)
mov    -0x70(%rsp),%rax
add    %r8d,%eax
mov    %rax,-0x70(%rsp)
cmp    0x10(%rsp),%r9
je     11e0 <meshgrid_float+0xe0>
test   %r8d,%r8d
jle    1230 <meshgrid_float+0x130>
mov    %r9d,%eax
imul   %r8d,%eax
mov    %rax,-0x58(%rsp)
cmp    $0x4,%r8d
jb     13a0 <meshgrid_float+0x2a0>
mov    0x50(%rsp),%eax
cmp    $0x1,%eax
jne    13a0 <meshgrid_float+0x2a0>
mov    %r9,%rax
imul   %r15,%rax
add    %r13,%rax
mov    (%rsp),%rbx
lea    (%rax,%rbx,1),%ebp
cmp    %eax,%ebp
jl     13a0 <meshgrid_float+0x2a0>
mov    %rbx,%rbp
shr    $0x20,%rbp
mov    $0x0,%ebp
jne    13a2 <meshgrid_float+0x2a2>
cltq
lea    (%rcx,%rax,4),%rbp
mov    -0x18(%rsp),%rbx
lea    (%rbx,%rax,4),%rax
lea    (%rsi,%r9,4),%rbx
cmp    %rdi,%rax
seta   -0x7d(%rsp)
lea    (%rsi,%r9,4),%r10
add    $0x4,%r10
cmp    -0x10(%rsp),%rbp
setb   -0x7e(%rsp)
cmp    %rax,%rbx
setb   %bl
cmp    %r10,%rbp
setb   -0x7f(%rsp)
mov    %r11,%r14
cmp    %rax,%r11
setb   %r11b
cmp    -0x8(%rsp),%rbp
setb   %r10b
mov    -0x7e(%rsp),%al
test   %al,-0x7d(%rsp)
jne    1481 <meshgrid_float+0x381>
and    -0x7f(%rsp),%bl
jne    1481 <meshgrid_float+0x381>
mov    $0x0,%ebp
and    %r10b,%r11b
mov    %r14,%r11
mov    -0x7c(%rsp),%r14d
jne    13a2 <meshgrid_float+0x2a2>
cmpq   $0x0,-0x30(%rsp)
je     1490 <meshgrid_float+0x390>
movss  (%rsi,%r9,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  (%rdx,%r13,4),%xmm1
shufps $0x0,%xmm1,%xmm1
mov    -0x48(%rsp),%r8
mov    -0x74(%rsp),%eax
xor    %ebp,%ebp
mov    -0x50(%rsp),%r14
mov    -0x60(%rsp),%r11d
nopw   0x0(%rax,%rax,1)
movups (%rdi,%rbp,4),%xmm2
cltq
movups %xmm2,(%rcx,%rax,4)
movups %xmm0,0x1c(%rcx,%rax,4)
movups %xmm1,0x38(%rcx,%rax,4)
lea    (%r14,%rax,1),%r10d
movups 0x10(%rdi,%rbp,4),%xmm2
movslq %r10d,%rbx
movups %xmm2,(%rcx,%rbx,4)
movups %xmm0,0x1c(%rcx,%rbx,4)
movups %xmm1,0x38(%rcx,%rbx,4)
add    $0x8,%rbp
add    %r11d,%eax
add    $0xfffffffffffffffe,%r8
jne    1360 <meshgrid_float+0x260>
jmp    1492 <meshgrid_float+0x392>
xor    %ebp,%ebp
mov    %rbp,%r10
test   $0x1,%r15b
je     13e8 <meshgrid_float+0x2e8>
mov    -0x58(%rsp),%rbx
add    %ebp,%ebx
mov    0x50(%rsp),%eax
imul   %eax,%ebx
add    %r13d,%ebx
movss  (%rdi,%rbp,4),%xmm0
movslq %ebx,%rax
movss  %xmm0,(%rcx,%rax,4)
movss  (%rsi,%r9,4),%xmm0
movss  %xmm0,0x1c(%rcx,%rax,4)
movss  (%rdx,%r13,4),%xmm0
movss  %xmm0,0x38(%rcx,%rax,4)
mov    %rbp,%r10
or     $0x1,%r10
not    %rbp
cmp    0x8(%rsp),%rbp
je     1230 <meshgrid_float+0x130>
mov    -0x68(%rsp),%rax
lea    (%rax,%r10,1),%ebp
mov    0x50(%rsp),%eax
imul   %eax,%ebp
add    %r13d,%ebp
mov    -0x70(%rsp),%rbx
add    %r10d,%ebx
imul   %eax,%ebx
add    %r13d,%ebx
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%r10,4),%xmm0
movslq %ebp,%rbp
movss  %xmm0,(%rcx,%rbp,4)
movss  (%rsi,%r9,4),%xmm0
movss  %xmm0,0x1c(%rcx,%rbp,4)
movss  (%rdx,%r13,4),%xmm0
movss  %xmm0,0x38(%rcx,%rbp,4)
movss  0x4(%rdi,%r10,4),%xmm0
movslq %ebx,%rbx
movss  %xmm0,(%rcx,%rbx,4)
movss  (%rsi,%r9,4),%xmm0
movss  %xmm0,0x1c(%rcx,%rbx,4)
movss  (%rdx,%r13,4),%xmm0
movss  %xmm0,0x38(%rcx,%rbx,4)
add    $0x2,%r10
add    %r12d,%ebp
add    %r12d,%ebx
cmp    %r10,%r15
jne    1420 <meshgrid_float+0x320>
jmp    1230 <meshgrid_float+0x130>
xor    %ebp,%ebp
mov    %r14,%r11
mov    -0x7c(%rsp),%r14d
jmp    13a2 <meshgrid_float+0x2a2>
xor    %ebp,%ebp
testb  $0x1,-0x38(%rsp)
mov    -0x5c(%rsp),%r8d
mov    -0x7c(%rsp),%r14d
mov    -0x20(%rsp),%r11
je     14e1 <meshgrid_float+0x3e1>
mov    -0x58(%rsp),%rax
add    %ebp,%eax
mov    0x50(%rsp),%ebx
imul   %ebx,%eax
add    %r13d,%eax
movups (%rdi,%rbp,4),%xmm0
cltq
movups %xmm0,(%rcx,%rax,4)
movss  (%rsi,%r9,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x1c(%rcx,%rax,4)
movss  (%rdx,%r13,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x38(%rcx,%rax,4)
mov    -0x28(%rsp),%rax
mov    %rax,%rbp
cmp    %r15,%rax
je     1230 <meshgrid_float+0x130>
jmp    13a2 <meshgrid_float+0x2a2>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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