void rgb2float(float *dst, const unsigned char *src, int width, int height,
               int srcstride, const float *mean, const float *std) {
  int c, i, j;
  for (c = 0; c < 3; c++)
    for (i = 0; i < height; i++)
      for (j = 0; j < width; j++)
        dst[j + (i + c * height) * width] =
            (src[c + 3 * j + srcstride * i] * 0.003921568f - mean[c]) / std[c];
}


x86 assembly (clang, -O0):
<rgb2float>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1202 <rgb2float+0x102>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11ef <rgb2float+0xef>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11dc <rgb2float+0xdc>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   $0x3,-0x34(%rbp),%edx
add    %edx,%ecx
mov    -0x1c(%rbp),%edx
imul   -0x30(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
cvtsi2ss %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0xe68(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x2c(%rbp),%esi
imul   -0x18(%rbp),%esi
add    %esi,%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1149 <rgb2float+0x49>
jmp    11e1 <rgb2float+0xe1>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1136 <rgb2float+0x36>
jmp    11f4 <rgb2float+0xf4>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1125 <rgb2float+0x25>
pop    %rbp
ret

x86 assembly (clang, -O2):
<rgb2float>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %edx,-0x78(%rsp)
mov    %rdi,-0x58(%rsp)
test   %ecx,%ecx
jle    185a <rgb2float+0x75a>
mov    0x60(%rsp),%rbx
mov    -0x78(%rsp),%r14d
movslq %r14d,%rdi
movslq %ecx,%rax
mov    %rax,-0x18(%rsp)
mov    %ecx,-0x1c(%rsp)
mov    %ecx,%eax
mov    %rax,0x10(%rsp)
mov    %edi,%r12d
lea    -0x1(%r12),%rax
lea    0x4(%r9),%rcx
mov    %rcx,-0x70(%rsp)
lea    0x4(%rbx),%rcx
mov    %rcx,-0x40(%rsp)
lea    (%r12,%r12,2),%rcx
lea    -0x2(%rsi,%rcx,1),%rcx
mov    %rcx,(%rsp)
mov    $0x3,%ecx
mov    %rax,-0x28(%rsp)
mul    %ecx
mov    %rax,-0x50(%rsp)
seto   -0x60(%rsp)
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x48(%rsp)
mov    %rdi,-0x10(%rsp)
lea    0x0(,%rdi,4),%rax
mov    %rax,0x8(%rsp)
mov    $0x9,%r15d
xor    %r13d,%r13d
movss  0xe76(%rip),%xmm0
movaps 0xe4f(%rip),%xmm1
movaps 0xe58(%rip),%xmm2
mov    -0x58(%rsp),%rdx
xor    %r11d,%r11d
mov    %rbx,0x18(%rsp)
jmp    11ea <rgb2float+0xea>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    0x8(%rsp),%rdx
add    %r8d,%r15d
add    %r8d,%r13d
cmp    0x10(%rsp),%r11
je     138a <rgb2float+0x28a>
test   %r14d,%r14d
jle    11d0 <rgb2float+0xd0>
cmp    $0x4,%r14d
jb     1340 <rgb2float+0x240>
mov    %r11d,%ecx
imul   %r8d,%ecx
mov    -0x50(%rsp),%rax
lea    (%rcx,%rax,1),%edi
cmp    %ecx,%edi
setl   %al
or     -0x60(%rsp),%al
jne    1340 <rgb2float+0x240>
mov    -0x28(%rsp),%rax
shr    $0x20,%rax
mov    $0x0,%edi
jne    1342 <rgb2float+0x242>
mov    %r11,%rax
imul   -0x10(%rsp),%rax
movslq %ecx,%rbp
lea    (%rsi,%rbp,1),%rcx
mov    %rcx,-0x68(%rsp)
add    (%rsp),%rbp
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rax,4),%rdi
add    %r12,%rax
lea    (%rcx,%rax,4),%rax
cmp    -0x70(%rsp),%rdi
setb   -0x30(%rsp)
cmp    %r9,%rax
seta   -0x38(%rsp)
cmp    -0x40(%rsp),%rdi
setb   %cl
cmp    %rbx,%rax
seta   %bl
cmp    %rdi,%rbp
seta   %r10b
cmp    %rax,-0x68(%rsp)
setb   %bpl
mov    -0x38(%rsp),%al
test   %al,-0x30(%rsp)
jne    1381 <rgb2float+0x281>
and    %bl,%cl
jne    1381 <rgb2float+0x281>
mov    $0x0,%edi
and    %bpl,%r10b
mov    0x60(%rsp),%rbx
jne    1342 <rgb2float+0x242>
movss  (%r9),%xmm3
shufps $0x0,%xmm3,%xmm3
xorps  %xmm1,%xmm3
movss  (%rbx),%xmm4
shufps $0x0,%xmm4,%xmm4
mov    %r15d,%edi
xor    %r10d,%r10d
mov    -0x48(%rsp),%rbx
nopl   0x0(%rax)
lea    -0x9(%rdi),%eax
lea    -0x6(%rdi),%ecx
lea    -0x3(%rdi),%ebp
cltq
movslq %ecx,%rcx
movslq %ebp,%rbp
movslq %edi,%rdi
movzbl (%rsi,%rax,1),%eax
movzbl (%rsi,%rcx,1),%ecx
movzbl (%rsi,%rbp,1),%ebp
movzbl (%rsi,%rdi,1),%r14d
movd   %eax,%xmm5
pinsrw $0x2,%ecx,%xmm5
pinsrw $0x4,%ebp,%xmm5
pinsrw $0x6,%r14d,%xmm5
cvtdq2ps %xmm5,%xmm5
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
divps  %xmm4,%xmm5
movups %xmm5,(%rdx,%r10,4)
add    $0x4,%r10
add    $0xc,%edi
cmp    %r10,%rbx
jne    12d0 <rgb2float+0x1d0>
mov    %rbx,%rdi
cmp    %r12,%rbx
mov    -0x78(%rsp),%r14d
mov    0x60(%rsp),%rbx
je     11d0 <rgb2float+0xd0>
jmp    1342 <rgb2float+0x242>
xchg   %ax,%ax
xor    %edi,%edi
lea    (%rdi,%rdi,2),%ebp
add    %r13d,%ebp
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rbp
movzbl (%rsi,%rbp,1),%eax
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
mulss  %xmm0,%xmm3
subss  (%r9),%xmm3
divss  (%rbx),%xmm3
movss  %xmm3,(%rdx,%rdi,4)
add    $0x1,%rdi
add    $0x3,%ebp
cmp    %rdi,%r12
jne    1350 <rgb2float+0x250>
jmp    11d0 <rgb2float+0xd0>
xor    %edi,%edi
mov    0x60(%rsp),%rbx
jmp    1342 <rgb2float+0x242>
cmpl   $0x0,-0x1c(%rsp)
mov    -0x18(%rsp),%rdi
jle    185a <rgb2float+0x75a>
imul   -0x10(%rsp),%rdi
lea    (%rdi,%r12,1),%rax
mov    %rax,0x20(%rsp)
mov    $0x3,%ecx
mov    -0x28(%rsp),%rax
mul    %ecx
mov    %rax,-0x30(%rsp)
lea    0x8(%r9),%rax
mov    %rax,-0x68(%rsp)
mov    0x60(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,-0x60(%rsp)
seto   -0x38(%rsp)
mov    %r12d,%ebx
and    $0xfffffffc,%ebx
mov    -0x58(%rsp),%rax
mov    %rdi,-0x18(%rsp)
lea    (%rax,%rdi,4),%r15
movl   $0xa,-0x50(%rsp)
mov    $0x1,%r10d
xor    %r11d,%r11d
mov    %r8d,-0x74(%rsp)
mov    -0x78(%rsp),%r14d
mov    -0x70(%rsp),%rbp
mov    -0x40(%rsp),%rdi
jmp    143c <rgb2float+0x33c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
add    0x8(%rsp),%r15
add    %r8d,-0x50(%rsp)
add    %r8d,%r10d
cmp    0x10(%rsp),%r11
je     15e9 <rgb2float+0x4e9>
test   %r14d,%r14d
jle    1420 <rgb2float+0x320>
cmp    $0x4,%r14d
jae    1480 <rgb2float+0x380>
xor    %edx,%edx
lea    (%rdx,%rdx,2),%eax
add    %r10d,%eax
nop
cltq
movzbl (%rsi,%rax,1),%ecx
xorps  %xmm3,%xmm3
cvtsi2ss %ecx,%xmm3
mulss  %xmm0,%xmm3
subss  0x0(%rbp),%xmm3
divss  (%rdi),%xmm3
movss  %xmm3,(%r15,%rdx,4)
add    $0x1,%rdx
add    $0x3,%eax
cmp    %rdx,%r12
jne    1450 <rgb2float+0x350>
jmp    1420 <rgb2float+0x320>
xchg   %ax,%ax
mov    %r11d,%eax
imul   %r8d,%eax
add    $0x1,%eax
mov    -0x30(%rsp),%rcx
lea    (%rax,%rcx,1),%edx
cmp    %eax,%edx
setl   %dl
or     -0x38(%rsp),%dl
jne    1447 <rgb2float+0x347>
mov    -0x28(%rsp),%rdx
shr    $0x20,%rdx
mov    $0x0,%edx
jne    1449 <rgb2float+0x349>
mov    %rbx,%r13
mov    %r11,%rdx
imul   -0x10(%rsp),%rdx
mov    -0x18(%rsp),%rcx
add    %rdx,%rcx
add    0x20(%rsp),%rdx
cltq
lea    (%rsi,%rax,1),%rbx
mov    %rbx,-0x48(%rsp)
add    (%rsp),%rax
mov    -0x58(%rsp),%rbx
lea    (%rbx,%rcx,4),%rcx
lea    (%rbx,%rdx,4),%rdx
cmp    -0x68(%rsp),%rcx
setb   -0x8(%rsp)
cmp    %rdx,%rbp
setb   -0x79(%rsp)
cmp    -0x60(%rsp),%rcx
setb   %bl
cmp    %rdx,%rdi
setb   -0x7a(%rsp)
cmp    %rcx,%rax
seta   %al
cmp    %rdx,-0x48(%rsp)
setb   %cl
mov    -0x79(%rsp),%dl
test   %dl,-0x8(%rsp)
jne    15df <rgb2float+0x4df>
and    -0x7a(%rsp),%bl
jne    15df <rgb2float+0x4df>
mov    $0x0,%edx
and    %cl,%al
mov    %r13,%rbx
jne    1449 <rgb2float+0x349>
movss  0x0(%rbp),%xmm3
shufps $0x0,%xmm3,%xmm3
xorps  %xmm1,%xmm3
movss  (%rdi),%xmm4
shufps $0x0,%xmm4,%xmm4
mov    -0x50(%rsp),%eax
mov    %eax,%edx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
lea    -0x9(%rdx),%ecx
lea    -0x6(%rdx),%r8d
lea    -0x3(%rdx),%r14d
movslq %ecx,%rcx
movslq %r8d,%rdi
movslq %r14d,%rbp
movslq %edx,%rdx
movzbl (%rsi,%rcx,1),%ecx
movzbl (%rsi,%rdi,1),%edi
movzbl (%rsi,%rbp,1),%ebp
movzbl (%rsi,%rdx,1),%ebx
movd   %ecx,%xmm5
pinsrw $0x2,%edi,%xmm5
pinsrw $0x4,%ebp,%xmm5
pinsrw $0x6,%ebx,%xmm5
cvtdq2ps %xmm5,%xmm5
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
divps  %xmm4,%xmm5
movups %xmm5,(%r15,%rax,4)
add    $0x4,%rax
add    $0xc,%edx
cmp    %rax,%r13
jne    1560 <rgb2float+0x460>
mov    %r13,%rbx
mov    %r13,%rdx
cmp    %r12,%r13
mov    -0x74(%rsp),%r8d
mov    -0x78(%rsp),%r14d
mov    -0x70(%rsp),%rbp
mov    -0x40(%rsp),%rdi
je     1420 <rgb2float+0x320>
jmp    1449 <rgb2float+0x349>
xor    %edx,%edx
mov    %r13,%rbx
jmp    1449 <rgb2float+0x349>
cmpl   $0x0,-0x1c(%rsp)
mov    -0x60(%rsp),%rbx
mov    -0x18(%rsp),%rdi
jle    185a <rgb2float+0x75a>
add    $0xc,%r9
addq   $0xc,0x18(%rsp)
mov    $0x3,%ecx
mov    -0x28(%rsp),%rax
mul    %ecx
mov    -0x68(%rsp),%rdx
mov    %rax,-0x50(%rsp)
lea    (%rdi,%rdi,1),%rax
mov    %rax,-0x40(%rsp)
lea    (%r12,%rdi,2),%rax
mov    %rax,-0x48(%rsp)
seto   -0x30(%rsp)
mov    %r12d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x8(%rsp)
mov    -0x58(%rsp),%rax
lea    (%rax,%rdi,8),%r10
mov    $0xb,%r14d
mov    $0x2,%r11d
xor    %r15d,%r15d
mov    %r9,-0x70(%rsp)
jmp    167a <rgb2float+0x57a>
nop
add    $0x1,%r15
add    0x8(%rsp),%r10
add    %r8d,%r14d
add    %r8d,%r11d
cmp    0x10(%rsp),%r15
je     185a <rgb2float+0x75a>
cmpl   $0x0,-0x78(%rsp)
jle    1660 <rgb2float+0x560>
cmpl   $0x4,-0x78(%rsp)
jb     1800 <rgb2float+0x700>
mov    %r15d,%edi
imul   %r8d,%edi
add    $0x2,%edi
mov    -0x50(%rsp),%rax
add    %edi,%eax
cmp    %edi,%eax
setl   %al
or     -0x30(%rsp),%al
jne    1800 <rgb2float+0x700>
mov    -0x28(%rsp),%rax
shr    $0x20,%rax
mov    $0x0,%r13d
jne    1803 <rgb2float+0x703>
mov    %r15,%rax
imul   -0x10(%rsp),%rax
mov    %rbx,%r8
mov    -0x40(%rsp),%rcx
lea    (%rcx,%rax,1),%rbp
add    -0x48(%rsp),%rax
movslq %edi,%rdi
lea    (%rsi,%rdi,1),%rcx
mov    %rcx,-0x38(%rsp)
add    (%rsp),%rdi
mov    -0x58(%rsp),%rcx
lea    (%rcx,%rbp,4),%rbx
lea    (%rcx,%rax,4),%rax
cmp    %r9,%rbx
setb   %r13b
cmp    %rax,%rdx
setb   %dl
cmp    0x18(%rsp),%rbx
setb   %bpl
cmp    %rax,%r8
setb   %cl
cmp    %rbx,%rdi
seta   %dil
cmp    %rax,-0x38(%rsp)
setb   %al
test   %dl,%r13b
jne    1841 <rgb2float+0x741>
and    %cl,%bpl
jne    1841 <rgb2float+0x741>
mov    $0x0,%r13d
and    %al,%dil
mov    -0x70(%rsp),%r9
mov    -0x74(%rsp),%r8d
mov    -0x68(%rsp),%rdx
mov    -0x60(%rsp),%rbx
jne    1803 <rgb2float+0x703>
movss  (%rdx),%xmm3
shufps $0x0,%xmm3,%xmm3
xorps  %xmm1,%xmm3
movss  (%rbx),%xmm4
shufps $0x0,%xmm4,%xmm4
mov    %r14d,%ebp
xor    %edi,%edi
mov    -0x8(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x9(%rbp),%eax
lea    -0x6(%rbp),%ebx
lea    -0x3(%rbp),%ecx
cltq
movslq %ebx,%rbx
movslq %ecx,%rcx
movslq %ebp,%rbp
movzbl (%rsi,%rax,1),%eax
movzbl (%rsi,%rbx,1),%ebx
movzbl (%rsi,%rcx,1),%ecx
movzbl (%rsi,%rbp,1),%edx
movd   %eax,%xmm5
pinsrw $0x2,%ebx,%xmm5
pinsrw $0x4,%ecx,%xmm5
pinsrw $0x6,%edx,%xmm5
cvtdq2ps %xmm5,%xmm5
mulps  %xmm2,%xmm5
addps  %xmm3,%xmm5
divps  %xmm4,%xmm5
movups %xmm5,(%r10,%rdi,4)
add    $0x4,%rdi
add    $0xc,%ebp
cmp    %rdi,%r8
jne    1780 <rgb2float+0x680>
mov    %r8,%r13
cmp    %r12,%r8
mov    -0x70(%rsp),%r9
mov    -0x74(%rsp),%r8d
mov    -0x68(%rsp),%rdx
mov    -0x60(%rsp),%rbx
je     1660 <rgb2float+0x560>
jmp    1803 <rgb2float+0x703>
cs nopw 0x0(%rax,%rax,1)
xor    %r13d,%r13d
lea    0x0(%r13,%r13,2),%edi
add    %r11d,%edi
nopl   0x0(%rax,%rax,1)
movslq %edi,%rdi
movzbl (%rsi,%rdi,1),%eax
xorps  %xmm3,%xmm3
cvtsi2ss %eax,%xmm3
mulss  %xmm0,%xmm3
subss  (%rdx),%xmm3
divss  (%rbx),%xmm3
movss  %xmm3,(%r10,%r13,4)
add    $0x1,%r13
add    $0x3,%edi
cmp    %r13,%r12
jne    1810 <rgb2float+0x710>
jmp    1660 <rgb2float+0x560>
xor    %r13d,%r13d
mov    -0x70(%rsp),%r9
mov    -0x74(%rsp),%r8d
mov    -0x68(%rsp),%rdx
mov    -0x60(%rsp),%rbx
jmp    1803 <rgb2float+0x703>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @rgb2float(float* nocapture writeonly %0, i8* nocapture %1, i32 %2, i32 %3, i32 %4, float* nocapture %5, float* nocapture %6) {
%8 = icmp sgt i32 %3, 0
%9 = icmp sgt i32 %2, 0
%10 = sext i32 %2 to i64
%11 = sext i32 %3 to i64
br i1 %8, label %12, label %403
12: ; preds = %7
%13 = zext i32 %3 to i64
%14 = zext i32 %2 to i64
%15 = add nsw i64 %14, -1
%16 = getelementptr float, float* %5, i64 1
%17 = getelementptr float, float* %6, i64 1
%18 = mul nuw nsw i64 %14, 3
%19 = add nsw i64 %18, -2
%20 = getelementptr i8, i8* %1, i64 %19
%21 = icmp ult i32 %2, 4
%22 = trunc i64 %15 to i32
%23 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %22, i32 3)
%24 = extractvalue { i32, i1 } %23, 0
%25 = extractvalue { i32, i1 } %23, 1
%26 = icmp ugt i64 %15, 4294967295
%27 = and i64 %14, 4294967292
%28 = icmp eq i64 %27, %14
br label %29
29: ; preds = %12, %132
%30 = phi i64 [ 0, %12 ], [ %133, %132 ]
%31 = mul i64 %30, %10
%32 = getelementptr float, float* %0, i64 %31
%33 = bitcast float* %32 to i8*
%34 = add i64 %31, %14
%35 = getelementptr float, float* %0, i64 %34
%36 = bitcast float* %35 to i8*
%37 = trunc i64 %30 to i32
%38 = mul i32 %37, %4
%39 = sext i32 %38 to i64
%40 = getelementptr i8, i8* %1, i64 %39
%41 = getelementptr i8, i8* %20, i64 %39
%42 = trunc i64 %30 to i32
%43 = mul i32 %42, %4
br i1 %9, label %44, label %132
44: ; preds = %29
%45 = trunc i64 %30 to i32
%46 = mul i32 %45, %4
%47 = mul nsw i64 %30, %10
br i1 %21, label %112, label %48
48: ; preds = %44
%49 = add i32 %43, %24
%50 = icmp slt i32 %49, %43
%51 = or i1 %50, %25
%52 = or i1 %51, %26
br i1 %52, label %112, label %53
53: ; preds = %48
%54 = icmp ult float* %32, %16
%55 = icmp ugt float* %35, %5
%56 = and i1 %54, %55
%57 = icmp ult float* %32, %17
%58 = icmp ugt float* %35, %6
%59 = and i1 %57, %58
%60 = or i1 %56, %59
%61 = icmp ugt i8* %41, %33
%62 = icmp ult i8* %40, %36
%63 = and i1 %61, %62
%64 = or i1 %60, %63
br i1 %64, label %112, label %65
65: ; preds = %53
%66 = load float, float* %5
%67 = insertelement <4 x float> poison, float %66, i64 0
%68 = shufflevector <4 x float> %67, <4 x float> poison, <4 x i32> zeroinitializer
%69 = fneg <4 x float> %68
%70 = load float, float* %6
%71 = insertelement <4 x float> poison, float %70, i64 0
%72 = shufflevector <4 x float> %71, <4 x float> poison, <4 x i32> zeroinitializer
br label %73
73: ; preds = %73, %65
%74 = phi i64 [ 0, %65 ], [ %109, %73 ]
%75 = trunc i64 %74 to i32
%76 = or i32 %75, 1
%77 = or i32 %75, 2
%78 = or i32 %75, 3
%79 = mul i32 %75, 3
%80 = mul i32 %76, 3
%81 = mul i32 %77, 3
%82 = mul i32 %78, 3
%83 = add i32 %46, %79
%84 = add i32 %46, %80
%85 = add i32 %46, %81
%86 = add i32 %46, %82
%87 = sext i32 %83 to i64
%88 = sext i32 %84 to i64
%89 = sext i32 %85 to i64
%90 = sext i32 %86 to i64
%91 = getelementptr inbounds i8, i8* %1, i64 %87
%92 = getelementptr inbounds i8, i8* %1, i64 %88
%93 = getelementptr inbounds i8, i8* %1, i64 %89
%94 = getelementptr inbounds i8, i8* %1, i64 %90
%95 = load i8, i8* %91
%96 = load i8, i8* %92
%97 = load i8, i8* %93
%98 = load i8, i8* %94
%99 = insertelement <4 x i8> poison, i8 %95, i64 0
%100 = insertelement <4 x i8> %99, i8 %96, i64 1
%101 = insertelement <4 x i8> %100, i8 %97, i64 2
%102 = insertelement <4 x i8> %101, i8 %98, i64 3
%103 = uitofp <4 x i8> %102 to <4 x float>
%104 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %103, <4 x float> <float 0x3F70100FE0000000, float 0x3F70100FE0000000, float 0x3F70100FE0000000, float 0x3F70100FE0000000>, <4 x float> %69)
%105 = fdiv <4 x float> %104, %72
%106 = add nsw i64 %74, %47
%107 = getelementptr inbounds float, float* %0, i64 %106
%108 = bitcast float* %107 to <4 x float>*
store <4 x float> %105, <4 x float>* %108
%109 = add nuw i64 %74, 4
%110 = icmp eq i64 %109, %27
br i1 %110, label %111, label %73
111: ; preds = %73
br i1 %28, label %132, label %112
112: ; preds = %53, %48, %44, %111
%113 = phi i64 [ 0, %53 ], [ 0, %48 ], [ 0, %44 ], [ %27, %111 ]
br label %114
114: ; preds = %112, %114
%115 = phi i64 [ %130, %114 ], [ %113, %112 ]
%116 = trunc i64 %115 to i32
%117 = mul i32 %116, 3
%118 = add i32 %46, %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i8, i8* %1, i64 %119
%121 = load i8, i8* %120
%122 = uitofp i8 %121 to float
%123 = load float, float* %5
%124 = fneg float %123
%125 = tail call float @llvm.fmuladd.f32(float %122, float 0x3F70100FE0000000, float %124)
%126 = load float, float* %6
%127 = fdiv float %125, %126
%128 = add nsw i64 %115, %47
%129 = getelementptr inbounds float, float* %0, i64 %128
store float %127, float* %129
%130 = add nuw nsw i64 %115, 1
%131 = icmp eq i64 %130, %14
br i1 %131, label %132, label %114
132: ; preds = %114, %111, %29
%133 = add nuw nsw i64 %30, 1
%134 = icmp eq i64 %133, %13
br i1 %134, label %135, label %29
135: ; preds = %132
br i1 %8, label %136, label %403
136: ; preds = %135
%137 = getelementptr float, float* %5, i64 1
%138 = getelementptr float, float* %6, i64 1
%139 = zext i32 %3 to i64
%140 = zext i32 %2 to i64
%141 = add nsw i64 %14, -1
%142 = mul nsw i64 %11, %10
%143 = add i64 %142, %14
%144 = getelementptr float, float* %5, i64 2
%145 = getelementptr float, float* %6, i64 2
%146 = mul nuw nsw i64 %14, 3
%147 = add nsw i64 %146, -2
%148 = getelementptr i8, i8* %1, i64 %147
%149 = icmp ult i32 %2, 4
%150 = trunc i64 %141 to i32
%151 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %150, i32 3)
%152 = extractvalue { i32, i1 } %151, 0
%153 = extractvalue { i32, i1 } %151, 1
%154 = icmp ugt i64 %141, 4294967295
%155 = and i64 %14, 4294967292
%156 = icmp eq i64 %155, %14
br label %157
157: ; preds = %265, %136
%158 = phi i64 [ 0, %136 ], [ %266, %265 ]
%159 = mul i64 %158, %10
%160 = add i64 %142, %159
%161 = getelementptr float, float* %0, i64 %160
%162 = bitcast float* %161 to i8*
%163 = add i64 %143, %159
%164 = getelementptr float, float* %0, i64 %163
%165 = bitcast float* %164 to i8*
%166 = trunc i64 %158 to i32
%167 = mul i32 %166, %4
%168 = add i32 %167, 1
%169 = sext i32 %168 to i64
%170 = getelementptr i8, i8* %1, i64 %169
%171 = getelementptr i8, i8* %148, i64 %169
%172 = trunc i64 %158 to i32
%173 = mul i32 %172, %4
%174 = add i32 %173, 1
br i1 %9, label %175, label %265
175: ; preds = %157
%176 = trunc i64 %158 to i32
%177 = mul i32 %176, %4
%178 = add i32 %177, 1
%179 = add nsw i64 %158, %11
%180 = mul nsw i64 %179, %10
br i1 %149, label %245, label %181
181: ; preds = %175
%182 = add i32 %174, %152
%183 = icmp slt i32 %182, %174
%184 = or i1 %183, %153
%185 = or i1 %184, %154
br i1 %185, label %245, label %186
186: ; preds = %181
%187 = icmp ult float* %161, %144
%188 = icmp ult float* %137, %164
%189 = and i1 %187, %188
%190 = icmp ult float* %161, %145
%191 = icmp ult float* %138, %164
%192 = and i1 %190, %191
%193 = or i1 %189, %192
%194 = icmp ugt i8* %171, %162
%195 = icmp ult i8* %170, %165
%196 = and i1 %194, %195
%197 = or i1 %193, %196
br i1 %197, label %245, label %198
198: ; preds = %186
%199 = load float, float* %137
%200 = insertelement <4 x float> poison, float %199, i64 0
%201 = shufflevector <4 x float> %200, <4 x float> poison, <4 x i32> zeroinitializer
%202 = fneg <4 x float> %201
%203 = load float, float* %138
%204 = insertelement <4 x float> poison, float %203, i64 0
%205 = shufflevector <4 x float> %204, <4 x float> poison, <4 x i32> zeroinitializer
br label %206
206: ; preds = %206, %198
%207 = phi i64 [ 0, %198 ], [ %242, %206 ]
%208 = trunc i64 %207 to i32
%209 = or i32 %208, 1
%210 = or i32 %208, 2
%211 = or i32 %208, 3
%212 = mul i32 %208, 3
%213 = mul i32 %209, 3
%214 = mul i32 %210, 3
%215 = mul i32 %211, 3
%216 = add i32 %178, %212
%217 = add i32 %178, %213
%218 = add i32 %178, %214
%219 = add i32 %178, %215
%220 = sext i32 %216 to i64
%221 = sext i32 %217 to i64
%222 = sext i32 %218 to i64
%223 = sext i32 %219 to i64
%224 = getelementptr inbounds i8, i8* %1, i64 %220
%225 = getelementptr inbounds i8, i8* %1, i64 %221
%226 = getelementptr inbounds i8, i8* %1, i64 %222
%227 = getelementptr inbounds i8, i8* %1, i64 %223
%228 = load i8, i8* %224
%229 = load i8, i8* %225
%230 = load i8, i8* %226
%231 = load i8, i8* %227
%232 = insertelement <4 x i8> poison, i8 %228, i64 0
%233 = insertelement <4 x i8> %232, i8 %229, i64 1
%234 = insertelement <4 x i8> %233, i8 %230, i64 2
%235 = insertelement <4 x i8> %234, i8 %231, i64 3
%236 = uitofp <4 x i8> %235 to <4 x float>
%237 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %236, <4 x float> <float 0x3F70100FE0000000, float 0x3F70100FE0000000, float 0x3F70100FE0000000, float 0x3F70100FE0000000>, <4 x float> %202)
%238 = fdiv <4 x float> %237, %205
%239 = add nsw i64 %207, %180
%240 = getelementptr inbounds float, float* %0, i64 %239
%241 = bitcast float* %240 to <4 x float>*
store <4 x float> %238, <4 x float>* %241
%242 = add nuw i64 %207, 4
%243 = icmp eq i64 %242, %155
br i1 %243, label %244, label %206
244: ; preds = %206
br i1 %156, label %265, label %245
245: ; preds = %186, %181, %175, %244
%246 = phi i64 [ 0, %186 ], [ 0, %181 ], [ 0, %175 ], [ %155, %244 ]
br label %247
247: ; preds = %245, %247
%248 = phi i64 [ %263, %247 ], [ %246, %245 ]
%249 = trunc i64 %248 to i32
%250 = mul i32 %249, 3
%251 = add i32 %178, %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i8, i8* %1, i64 %252
%254 = load i8, i8* %253
%255 = uitofp i8 %254 to float
%256 = load float, float* %137
%257 = fneg float %256
%258 = tail call float @llvm.fmuladd.f32(float %255, float 0x3F70100FE0000000, float %257)
%259 = load float, float* %138
%260 = fdiv float %258, %259
%261 = add nsw i64 %248, %180
%262 = getelementptr inbounds float, float* %0, i64 %261
store float %260, float* %262
%263 = add nuw nsw i64 %248, 1
%264 = icmp eq i64 %263, %140
br i1 %264, label %265, label %247
265: ; preds = %247, %244, %157
%266 = add nuw nsw i64 %158, 1
%267 = icmp eq i64 %266, %139
br i1 %267, label %268, label %157
268: ; preds = %265
br i1 %8, label %269, label %403
269: ; preds = %268
%270 = getelementptr float, float* %5, i64 2
%271 = getelementptr float, float* %6, i64 2
%272 = shl nsw i64 %11, 1
%273 = zext i32 %3 to i64
%274 = zext i32 %2 to i64
%275 = add nsw i64 %14, -1
%276 = mul nsw i64 %11, %10
%277 = shl i64 %276, 1
%278 = add i64 %277, %14
%279 = getelementptr float, float* %5, i64 3
%280 = getelementptr float, float* %6, i64 3
%281 = mul nuw nsw i64 %14, 3
%282 = add nsw i64 %281, -2
%283 = getelementptr i8, i8* %1, i64 %282
%284 = icmp ult i32 %2, 4
%285 = trunc i64 %275 to i32
%286 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %285, i32 3)
%287 = extractvalue { i32, i1 } %286, 0
%288 = extractvalue { i32, i1 } %286, 1
%289 = icmp ugt i64 %275, 4294967295
%290 = and i64 %14, 4294967292
%291 = icmp eq i64 %290, %14
br label %292
292: ; preds = %400, %269
%293 = phi i64 [ 0, %269 ], [ %401, %400 ]
%294 = mul i64 %293, %10
%295 = add i64 %277, %294
%296 = getelementptr float, float* %0, i64 %295
%297 = bitcast float* %296 to i8*
%298 = add i64 %278, %294
%299 = getelementptr float, float* %0, i64 %298
%300 = bitcast float* %299 to i8*
%301 = trunc i64 %293 to i32
%302 = mul i32 %301, %4
%303 = add i32 %302, 2
%304 = sext i32 %303 to i64
%305 = getelementptr i8, i8* %1, i64 %304
%306 = getelementptr i8, i8* %283, i64 %304
%307 = trunc i64 %293 to i32
%308 = mul i32 %307, %4
%309 = add i32 %308, 2
br i1 %9, label %310, label %400
310: ; preds = %292
%311 = trunc i64 %293 to i32
%312 = mul i32 %311, %4
%313 = add i32 %312, 2
%314 = add nsw i64 %293, %272
%315 = mul nsw i64 %314, %10
br i1 %284, label %380, label %316
316: ; preds = %310
%317 = add i32 %309, %287
%318 = icmp slt i32 %317, %309
%319 = or i1 %318, %288
%320 = or i1 %319, %289
br i1 %320, label %380, label %321
321: ; preds = %316
%322 = icmp ult float* %296, %279
%323 = icmp ult float* %270, %299
%324 = and i1 %322, %323
%325 = icmp ult float* %296, %280
%326 = icmp ult float* %271, %299
%327 = and i1 %325, %326
%328 = or i1 %324, %327
%329 = icmp ugt i8* %306, %297
%330 = icmp ult i8* %305, %300
%331 = and i1 %329, %330
%332 = or i1 %328, %331
br i1 %332, label %380, label %333
333: ; preds = %321
%334 = load float, float* %270
%335 = insertelement <4 x float> poison, float %334, i64 0
%336 = shufflevector <4 x float> %335, <4 x float> poison, <4 x i32> zeroinitializer
%337 = fneg <4 x float> %336
%338 = load float, float* %271
%339 = insertelement <4 x float> poison, float %338, i64 0
%340 = shufflevector <4 x float> %339, <4 x float> poison, <4 x i32> zeroinitializer
br label %341
341: ; preds = %341, %333
%342 = phi i64 [ 0, %333 ], [ %377, %341 ]
%343 = trunc i64 %342 to i32
%344 = or i32 %343, 1
%345 = or i32 %343, 2
%346 = or i32 %343, 3
%347 = mul i32 %343, 3
%348 = mul i32 %344, 3
%349 = mul i32 %345, 3
%350 = mul i32 %346, 3
%351 = add i32 %313, %347
%352 = add i32 %313, %348
%353 = add i32 %313, %349
%354 = add i32 %313, %350
%355 = sext i32 %351 to i64
%356 = sext i32 %352 to i64
%357 = sext i32 %353 to i64
%358 = sext i32 %354 to i64
%359 = getelementptr inbounds i8, i8* %1, i64 %355
%360 = getelementptr inbounds i8, i8* %1, i64 %356
%361 = getelementptr inbounds i8, i8* %1, i64 %357
%362 = getelementptr inbounds i8, i8* %1, i64 %358
%363 = load i8, i8* %359
%364 = load i8, i8* %360
%365 = load i8, i8* %361
%366 = load i8, i8* %362
%367 = insertelement <4 x i8> poison, i8 %363, i64 0
%368 = insertelement <4 x i8> %367, i8 %364, i64 1
%369 = insertelement <4 x i8> %368, i8 %365, i64 2
%370 = insertelement <4 x i8> %369, i8 %366, i64 3
%371 = uitofp <4 x i8> %370 to <4 x float>
%372 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %371, <4 x float> <float 0x3F70100FE0000000, float 0x3F70100FE0000000, float 0x3F70100FE0000000, float 0x3F70100FE0000000>, <4 x float> %337)
%373 = fdiv <4 x float> %372, %340
%374 = add nsw i64 %342, %315
%375 = getelementptr inbounds float, float* %0, i64 %374
%376 = bitcast float* %375 to <4 x float>*
store <4 x float> %373, <4 x float>* %376
%377 = add nuw i64 %342, 4
%378 = icmp eq i64 %377, %290
br i1 %378, label %379, label %341
379: ; preds = %341
br i1 %291, label %400, label %380
380: ; preds = %321, %316, %310, %379
%381 = phi i64 [ 0, %321 ], [ 0, %316 ], [ 0, %310 ], [ %290, %379 ]
br label %382
382: ; preds = %380, %382
%383 = phi i64 [ %398, %382 ], [ %381, %380 ]
%384 = trunc i64 %383 to i32
%385 = mul i32 %384, 3
%386 = add i32 %313, %385
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds i8, i8* %1, i64 %387
%389 = load i8, i8* %388
%390 = uitofp i8 %389 to float
%391 = load float, float* %270
%392 = fneg float %391
%393 = tail call float @llvm.fmuladd.f32(float %390, float 0x3F70100FE0000000, float %392)
%394 = load float, float* %271
%395 = fdiv float %393, %394
%396 = add nsw i64 %383, %315
%397 = getelementptr inbounds float, float* %0, i64 %396
store float %395, float* %397
%398 = add nuw nsw i64 %383, 1
%399 = icmp eq i64 %398, %274
br i1 %399, label %400, label %382
400: ; preds = %382, %379, %292
%401 = add nuw nsw i64 %293, 1
%402 = icmp eq i64 %401, %273
br i1 %402, label %403, label %292
403: ; preds = %400, %7, %135, %268
ret void
}