void conv_vok(double *v, double *k, double *o, int n, int h, int w, int f,
              int ph, int pw, int out_f, int kh, int kw, int sh, int sw) {
  int out_h = (h + 2 * ph - kh) / sh + 1;
  int out_w = (w + 2 * pw - kw) / sw + 1;
  int colcol = kh * kw * f;
  int fkw = f * kw;
  int o_size = out_h * out_w * out_f;
  int v_size = h * w * f;
  double *o_ptr = o;
  double *v_ptr = v;
  register double part;
  int n_idx, ho, wo, fo, kcoli;
  int v_hi, v_wi, fi, v_idx, off_o, off_k, sho, swo;
  for (n_idx = 0; n_idx < n; ++n_idx) {
    for (ho = 0; ho < out_h; ++ho) {
      for (wo = 0; wo < out_w; ++wo) {
        off_o = out_f * (wo + out_w * ho);
        sho = ho * sh;
        swo = wo * sw;
        for (kcoli = 0; kcoli < colcol; ++kcoli) {
          v_hi = sho + kcoli / fkw % kh;
          v_wi = swo + kcoli / f % kw;
          if ((v_hi < ph) | (v_wi < pw) | (v_hi >= h + ph) | (v_wi >= w + pw)) {
            continue;
          }
          fi = kcoli % f;
          v_idx = fi + f * (v_wi - pw + w * (v_hi - ph));
          register double part = v_ptr[v_idx];
          for (fo = 0; fo < out_f; ++fo) {
            k[kcoli * out_f + fo] += part * o_ptr[fo + off_o];
          }
        }
      }
    }
    o_ptr += o_size;
    v_ptr += v_size;
  }
}


x86 assembly (clang, -O0):
<conv_vok>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x20(%rbp),%eax
mov    0x18(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
sub    0x30(%rbp),%eax
cltd
idivl  0x40(%rbp)
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    0x20(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
sub    0x38(%rbp),%eax
cltd
idivl  0x48(%rbp)
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    0x30(%rbp),%eax
imul   0x38(%rbp),%eax
imul   0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    0x10(%rbp),%eax
imul   0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x2c(%rbp),%eax
imul   0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%eax
imul   -0x24(%rbp),%eax
imul   0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13d3 <conv_vok+0x2d3>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    139b <conv_vok+0x29b>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1388 <conv_vok+0x288>
mov    0x28(%rbp),%eax
mov    -0x64(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x60(%rbp),%edx
add    %edx,%ecx
imul   %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x60(%rbp),%eax
imul   0x40(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x64(%rbp),%eax
imul   0x48(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1375 <conv_vok+0x275>
mov    -0x88(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x6c(%rbp),%eax
cltd
idivl  -0x34(%rbp)
cltd
idivl  0x30(%rbp)
mov    -0xa0(%rbp),%eax
add    %edx,%eax
mov    %eax,-0x70(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x6c(%rbp),%eax
cltd
idivl  0x10(%rbp)
cltd
idivl  0x38(%rbp)
mov    -0x9c(%rbp),%eax
add    %edx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
cmp    0x18(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    -0x74(%rbp),%ecx
cmp    0x20(%rbp),%ecx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
mov    -0x70(%rbp),%ecx
mov    -0x20(%rbp),%edx
add    0x18(%rbp),%edx
cmp    %edx,%ecx
setge  %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
mov    -0x74(%rbp),%ecx
mov    -0x24(%rbp),%edx
add    0x20(%rbp),%edx
cmp    %edx,%ecx
setge  %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
cmp    $0x0,%eax
je     12c3 <conv_vok+0x1c3>
jmp    1367 <conv_vok+0x267>
mov    -0x6c(%rbp),%eax
cltd
idivl  0x10(%rbp)
mov    %edx,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    0x10(%rbp),%ecx
mov    -0x74(%rbp),%edx
sub    0x20(%rbp),%edx
mov    -0x24(%rbp),%esi
mov    -0x70(%rbp),%edi
sub    0x18(%rbp),%edi
imul   %edi,%esi
add    %esi,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1362 <conv_vok+0x262>
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x48(%rbp),%rax
mov    -0x68(%rbp),%ecx
add    -0x80(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   0x28(%rbp),%ecx
add    -0x68(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    130b <conv_vok+0x20b>
jmp    1367 <conv_vok+0x267>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    121a <conv_vok+0x11a>
jmp    137a <conv_vok+0x27a>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    11d8 <conv_vok+0xd8>
jmp    138d <conv_vok+0x28d>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    11c5 <conv_vok+0xc5>
mov    -0x38(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x3c(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    11b2 <conv_vok+0xb2>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<conv_vok>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc0,%rsp
mov    %rdx,-0x18(%rsp)
mov    %rsi,-0x60(%rsp)
mov    %rdi,-0x58(%rsp)
mov    0x120(%rsp),%esi
mov    0x108(%rsp),%ebp
mov    0x100(%rsp),%eax
lea    (%r8,%rax,2),%eax
sub    0x118(%rsp),%eax
cltd
idivl  0x128(%rsp)
mov    %rax,-0x40(%rsp)
mov    %r9,%rax
mov    %r9,-0x8(%rsp)
lea    (%r9,%rbp,2),%eax
sub    %esi,%eax
cltd
idivl  0x130(%rsp)
mov    %rax,-0x30(%rsp)
mov    %ecx,-0x50(%rsp)
test   %ecx,%ecx
jle    16fa <conv_vok+0x5fa>
mov    %r8,%rdi
mov    %esi,%ecx
mov    0x110(%rsp),%r8d
mov    0xf8(%rsp),%edx
mov    -0x30(%rsp),%rax
add    $0x1,%eax
imul   %edx,%ecx
mov    %ecx,-0x44(%rsp)
mov    %ecx,%ebx
imul   0x118(%rsp),%ebx
mov    -0x8(%rsp),%r10
mov    %r10d,%ecx
imul   %edi,%ecx
imul   %edx,%ecx
mov    -0x40(%rsp),%rdx
add    $0x1,%edx
mov    %rdx,0x48(%rsp)
imul   %r8d,%edx
imul   %eax,%edx
mov    0x100(%rsp),%ebp
add    %ebp,%edi
mov    %rdi,0xb8(%rsp)
movslq %edx,%rdx
movslq %ecx,%rcx
mov    %rcx,0x18(%rsp)
movslq %r8d,%rsi
movslq %eax,%rbp
mov    %esi,%r9d
mov    %rsi,%rcx
imul   %rbp,%rcx
mov    %r9d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x98(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x90(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,%rax
mov    %rdi,0x88(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0x78(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0xb0(%rsp)
mov    0x108(%rsp),%eax
lea    (%rax,%r10,1),%edi
mov    %rbp,0x28(%rsp)
mov    %ebp,%eax
mov    %rax,0x80(%rsp)
mov    %ebx,-0x4c(%rsp)
mov    %ebx,%r14d
mov    -0x18(%rsp),%rax
lea    0x30(%rax),%rbp
mov    %rbp,-0x38(%rsp)
mov    %rdx,0x8(%rsp)
lea    0x0(,%rdx,8),%rdx
mov    %rdx,0x10(%rsp)
mov    %rcx,0x20(%rsp)
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0x40(%rsp)
mov    %rsi,(%rsp)
lea    0x0(,%rsi,8),%r12
mov    -0x60(%rsp),%rcx
lea    0x30(%rcx),%rdx
mov    %rdx,0x58(%rsp)
add    $0x8,%rcx
mov    %rcx,0x50(%rsp)
mov    0x120(%rsp),%ecx
xor    %edx,%edx
mov    %rdx,-0x78(%rsp)
mov    %rax,-0x80(%rsp)
jmp    130a <conv_vok+0x20a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rsi
add    %rsi,-0x80(%rsp)
mov    -0x58(%rsp),%rax
mov    0x18(%rsp),%rdx
lea    (%rax,%rdx,8),%rax
mov    %rax,-0x58(%rsp)
mov    -0x78(%rsp),%rax
add    $0x1,%rax
add    %rsi,-0x38(%rsp)
mov    %rax,-0x78(%rsp)
cmp    -0x50(%rsp),%eax
je     16fa <conv_vok+0x5fa>
cmpl   $0x0,-0x40(%rsp)
js     12d0 <conv_vok+0x1d0>
mov    -0x78(%rsp),%rax
imul   0x8(%rsp),%rax
mov    %rax,0x38(%rsp)
add    %r9,%rax
mov    %rax,0x30(%rsp)
mov    -0x80(%rsp),%rax
mov    %rax,-0x20(%rsp)
mov    -0x38(%rsp),%rax
mov    %rax,-0x28(%rsp)
xor    %eax,%eax
mov    %rax,-0x70(%rsp)
jmp    137b <conv_vok+0x27b>
cs nopw 0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rdx
add    $0x1,%rdx
mov    0x40(%rsp),%rax
add    %rax,-0x28(%rsp)
add    %rax,-0x20(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x70(%rsp)
cmp    0x48(%rsp),%rdx
je     12d0 <conv_vok+0x1d0>
cmpl   $0x0,-0x30(%rsp)
js     1350 <conv_vok+0x250>
mov    0x20(%rsp),%rsi
mov    -0x70(%rsp),%rdx
imul   %rdx,%rsi
mov    0x38(%rsp),%rax
add    %rsi,%rax
mov    %rax,0x68(%rsp)
add    0x30(%rsp),%rsi
mov    %rsi,0x70(%rsp)
mov    %rdx,%rax
imul   0x28(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    %edx,%eax
imul   0x128(%rsp),%eax
mov    %eax,-0x48(%rsp)
mov    -0x20(%rsp),%r13
mov    -0x28(%rsp),%r10
xor    %eax,%eax
mov    %rax,-0x68(%rsp)
jmp    1405 <conv_vok+0x305>
cs nopw 0x0(%rax,%rax,1)
mov    -0x68(%rsp),%rdx
add    $0x1,%rdx
add    %r12,%r10
add    %r12,%r13
mov    %rdx,%rax
mov    %rdx,-0x68(%rsp)
cmp    0x80(%rsp),%rdx
je     1350 <conv_vok+0x250>
cmpl   $0x0,-0x4c(%rsp)
jle    13e0 <conv_vok+0x2e0>
mov    -0x68(%rsp),%rbx
mov    %rbx,%rax
mov    (%rsp),%rsi
imul   %rsi,%rax
mov    0x68(%rsp),%rdx
add    %rax,%rdx
add    0x70(%rsp),%rax
mov    0x60(%rsp),%rbp
add    %rbx,%rbp
imul   %rsi,%rbp
mov    %rbp,-0x10(%rsp)
mov    -0x18(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    %rdx,0xa0(%rsp)
lea    (%rsi,%rax,8),%rax
mov    %rax,0xa8(%rsp)
mov    %ebx,%r11d
imul   0x130(%rsp),%r11d
mov    0x50(%rsp),%rsi
mov    0x58(%rsp),%r8
xor    %ebx,%ebx
jmp    1493 <conv_vok+0x393>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    %r12,%r8
add    %r12,%rsi
cmp    %r14,%rbx
je     13e0 <conv_vok+0x2e0>
mov    %ebx,%eax
cltd
idivl  -0x44(%rsp)
cltd
idivl  0x118(%rsp)
mov    %edx,%ebp
mov    %ebx,%eax
cltd
idivl  0xf8(%rsp)
mov    %edx,%r15d
cltd
idiv   %ecx
add    %r11d,%edx
cmp    %edi,%edx
jge    1480 <conv_vok+0x380>
add    -0x48(%rsp),%ebp
cmp    0xb8(%rsp),%ebp
jge    1480 <conv_vok+0x380>
mov    0x100(%rsp),%eax
sub    %eax,%ebp
jl     1480 <conv_vok+0x380>
mov    0x108(%rsp),%eax
sub    %eax,%edx
jl     1480 <conv_vok+0x380>
cmpl   $0x0,0x110(%rsp)
jle    1480 <conv_vok+0x380>
mov    %rbx,%rax
imul   (%rsp),%rax
imul   -0x8(%rsp),%ebp
add    %ebp,%edx
imul   0xf8(%rsp),%edx
add    %edx,%r15d
movslq %r15d,%rdx
mov    -0x58(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm0
cmpl   $0x4,0x110(%rsp)
04
jb     1546 <conv_vok+0x446>
mov    -0x60(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
cmp    0xa8(%rsp),%rdx
jae    15da <conv_vok+0x4da>
lea    (%rax,%r9,1),%rdx
lea    (%rcx,%rdx,8),%rdx
cmp    %rdx,0xa0(%rsp)
jae    15da <conv_vok+0x4da>
xor    %ebp,%ebp
mov    0x120(%rsp),%ecx
mov    %rbp,%rdx
test   $0x1,%r9b
je     158f <conv_vok+0x48f>
mov    -0x10(%rsp),%rcx
lea    (%rcx,%rbp,1),%rdx
add    %rbp,%rax
mov    -0x80(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
mov    -0x60(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
mov    0x120(%rsp),%ecx
mov    %rbp,%rdx
or     $0x1,%rdx
not    %rbp
cmp    0xb0(%rsp),%rbp
je     1480 <conv_vok+0x380>
movsd  0x0(%r13,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rsi,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%rsi,%rdx,8)
movsd  0x8(%r13,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rdx,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r9
jne    15a0 <conv_vok+0x4a0>
jmp    1480 <conv_vok+0x380>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,0x90(%rsp)
je     16ec <conv_vok+0x5ec>
mov    0x78(%rsp),%rbp
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r10,%rdx,8),%xmm2
movupd -0x20(%r10,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r8,%rdx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r8,%rdx,8),%xmm2
movupd -0x10(%r8,%rdx,8),%xmm5
movupd (%r8,%rdx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r8,%rdx,8)
movupd %xmm3,-0x20(%r8,%rdx,8)
movupd -0x10(%r10,%rdx,8),%xmm2
movupd (%r10,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r8,%rdx,8)
movupd %xmm3,(%r8,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbp
jne    1600 <conv_vok+0x500>
testb  $0x1,0x88(%rsp)
01
je     16cc <conv_vok+0x5cc>
mov    -0x10(%rsp),%rbp
add    %rdx,%rbp
mov    %edi,%r15d
mov    -0x80(%rsp),%rdi
movupd (%rdi,%rbp,8),%xmm2
movupd 0x10(%rdi,%rbp,8),%xmm3
mov    %r15d,%edi
add    %rax,%rdx
movupd (%rcx,%rdx,8),%xmm4
movupd 0x10(%rcx,%rdx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm3,0x10(%rcx,%rdx,8)
mov    0x98(%rsp),%rcx
mov    %rcx,%rbp
cmp    %r9,%rcx
mov    0x120(%rsp),%ecx
je     1480 <conv_vok+0x380>
jmp    154f <conv_vok+0x44f>
xor    %edx,%edx
testb  $0x1,0x88(%rsp)
01
jne    1685 <conv_vok+0x585>
jmp    16cc <conv_vok+0x5cc>
add    $0xc0,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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