int _compute_viterbi(int *path, const double *A, const double *pobs,
                     const double *pi, int N, int T) {
  int i, j, t, maxi, result;
  double sum;
  double *v, *vnext, *h, *vh;
  int *ptr;
  result = 0;
  v = (double *)malloc(N * sizeof(double));
  vnext = (double *)malloc(N * sizeof(double));
  h = (double *)malloc(N * sizeof(double));
  ptr = (int *)malloc(T * N * sizeof(int));
  if (!v || !vnext || !h || !ptr) {
    result = 2;
    goto error;
  }
  sum = 0.0;
  for (i = 0; i < N; i++) {
    v[i] = pobs[i] * pi[i];
    sum += v[i];
  }
  for (i = 0; i < N; i++) {
    v[i] /= sum;
  }
  for (t = 1; t < T; t++) {
    sum = 0.0;
    for (j = 0; j < N; j++) {
      for (i = 0; i < N; i++) {
        h[i] = v[i] * A[i * N + j];
      }
      maxi = argmax(h, N);
      ptr[t * N + j] = maxi;
      vnext[j] = pobs[t * N + j] * v[maxi] * A[maxi * N + j];
      sum += vnext[j];
    }
    for (i = 0; i < N; i++) {
      vnext[i] /= sum;
    }
    vh = v;
    v = vnext;
    vnext = vh;
  }
  path[T - 1] = argmax(v, N);
  for (t = T - 2; t >= 0; t--) {
    path[t] = ptr[(t + 1) * N + path[t + 1]];
  }
error:
  free(v);
  free(vnext);
  free(h);
  free(ptr);
  return result;
}


x86 assembly (clang, -O0):
<_compute_viterbi>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
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,-0x3c(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0x24(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x28(%rbp),%eax
imul   -0x24(%rbp),%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
cmpq   $0x0,-0x50(%rbp)
je     11cd <_compute_viterbi+0x9d>
cmpq   $0x0,-0x58(%rbp)
je     11cd <_compute_viterbi+0x9d>
cmpq   $0x0,-0x60(%rbp)
je     11cd <_compute_viterbi+0x9d>
cmpq   $0x0,-0x70(%rbp)
jne    11d9 <_compute_viterbi+0xa9>
movl   $0x2,-0x3c(%rbp)
jmp    1465 <_compute_viterbi+0x335>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1240 <_compute_viterbi+0x110>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11e8 <_compute_viterbi+0xb8>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    127c <_compute_viterbi+0x14c>
movsd  -0x48(%rbp),%xmm1
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1247 <_compute_viterbi+0x117>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    13f0 <_compute_viterbi+0x2c0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    138e <_compute_viterbi+0x25e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12fb <_compute_viterbi+0x1cb>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12b1 <_compute_viterbi+0x181>
mov    -0x60(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <argmax@plt>
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%edx
mov    -0x70(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    129e <_compute_viterbi+0x16e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13ca <_compute_viterbi+0x29a>
movsd  -0x48(%rbp),%xmm1
mov    -0x58(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1395 <_compute_viterbi+0x265>
mov    -0x50(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1283 <_compute_viterbi+0x153>
mov    -0x50(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    $0x0,%al
call   1040 <argmax@plt>
mov    %eax,%edx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     1460 <_compute_viterbi+0x330>
mov    -0x70(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
imul   -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rdx
mov    -0x34(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1419 <_compute_viterbi+0x2e9>
jmp    1465 <_compute_viterbi+0x335>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x3c(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_compute_viterbi>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r9d,%r12d
mov    %r8d,%ebp
mov    %rcx,0x30(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rsi,0x8(%rsp)
mov    %rdi,0x48(%rsp)
movslq %r8d,%rax
mov    %rax,0x18(%rsp)
lea    0x0(,%rax,8),%r15
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    %r15,%rdi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %r12,0x10(%rsp)
mov    %r12d,%eax
mov    %rbp,0x28(%rsp)
imul   %ebp,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %r14,%rdi
mov    %rax,%r12
mov    $0x2,%r13d
test   %r14,%r14
je     1603 <_compute_viterbi+0x4d3>
test   %rbx,%rbx
je     1603 <_compute_viterbi+0x4d3>
test   %r15,%r15
je     1603 <_compute_viterbi+0x4d3>
test   %r12,%r12
je     1603 <_compute_viterbi+0x4d3>
mov    0x28(%rsp),%rsi
mov    %esi,%edx
test   %esi,%esi
mov    0x10(%rsp),%r10
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%r9
jle    1317 <_compute_viterbi+0x1e7>
cmp    $0x1,%esi
jne    1208 <_compute_viterbi+0xd8>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x30(%rsp),%rcx
jmp    1253 <_compute_viterbi+0x123>
mov    %edx,%r8d
and    $0xfffffffe,%r8d
xorpd  %xmm0,%xmm0
xor    %eax,%eax
mov    0x30(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
addsd  %xmm0,%xmm1
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
addsd  %xmm1,%xmm0
add    $0x2,%rax
cmp    %rax,%r8
jne    1220 <_compute_viterbi+0xf0>
test   $0x1,%dl
je     126c <_compute_viterbi+0x13c>
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  (%rcx,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
addsd  %xmm1,%xmm0
test   %esi,%esi
jle    1317 <_compute_viterbi+0x1e7>
cmp    $0x1,%esi
jne    1280 <_compute_viterbi+0x150>
xor    %eax,%eax
jmp    1300 <_compute_viterbi+0x1d0>
mov    %edx,%eax
and    $0xfffffffe,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rax),%rcx
mov    %rcx,%r8
shr    %r8
add    $0x1,%r8
test   %rcx,%rcx
je     1635 <_compute_viterbi+0x505>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %ebp,%ebp
nopl   (%rax)
movupd (%rdi,%rbp,8),%xmm2
movupd 0x10(%rdi,%rbp,8),%xmm3
divpd  %xmm1,%xmm2
movupd %xmm2,(%rdi,%rbp,8)
divpd  %xmm1,%xmm3
movupd %xmm3,0x10(%rdi,%rbp,8)
add    $0x4,%rbp
add    $0xfffffffffffffffe,%rcx
jne    12b0 <_compute_viterbi+0x180>
test   $0x1,%r8b
je     12ec <_compute_viterbi+0x1bc>
movupd (%rdi,%rbp,8),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rdi,%rbp,8)
cmp    %rdx,%rax
je     1317 <_compute_viterbi+0x1e7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1300 <_compute_viterbi+0x1d0>
cmp    $0x2,%r10d
mov    %r12,(%rsp)
jl     1557 <_compute_viterbi+0x427>
mov    %r10d,%eax
mov    %rax,0x60(%rsp)
mov    %edx,%r12d
and    $0xfffffffe,%r12d
lea    -0x2(%r12),%rax
mov    %rax,0x58(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x40(%rsp)
mov    %r9,%rbp
shl    $0x4,%rbp
mov    $0x1,%r8d
mov    %rbx,%rax
mov    %rdx,0x70(%rsp)
jmp    1382 <_compute_viterbi+0x252>
add    $0x1,%r8
mov    %rbx,%rax
cmp    0x60(%rsp),%r8
je     1557 <_compute_viterbi+0x427>
mov    %rdi,%rbx
mov    %rax,%rdi
test   %esi,%esi
jle    1370 <_compute_viterbi+0x240>
mov    %r8,0x68(%rsp)
imul   %r9,%r8
mov    %r8,0x78(%rsp)
xorpd  %xmm3,%xmm3
mov    0x8(%rsp),%r14
xor    %r13d,%r13d
mov    %rdi,0x80(%rsp)
jmp    1424 <_compute_viterbi+0x2f4>
mov    %r15,%rdi
xor    %eax,%eax
call   1040 <argmax@plt>
mov    0x18(%rsp),%r9
mov    0x28(%rsp),%rsi
mov    0x78(%rsp),%rcx
add    %r13,%rcx
mov    (%rsp),%rdx
mov    %eax,(%rdx,%rcx,4)
mov    0x20(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
cltq
mulsd  (%rbx,%rax,8),%xmm0
imul   %esi,%eax
cltq
add    %r13,%rax
mov    0x8(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm0
mov    0x80(%rsp),%rdi
movsd  %xmm0,(%rdi,%r13,8)
movapd 0x30(%rsp),%xmm3
addsd  %xmm0,%xmm3
add    $0x1,%r13
add    $0x8,%r14
mov    0x70(%rsp),%rdx
cmp    %rdx,%r13
je     14b0 <_compute_viterbi+0x380>
cmp    $0x1,%esi
jne    1430 <_compute_viterbi+0x300>
xor    %eax,%eax
jmp    146e <_compute_viterbi+0x33e>
nopl   (%rax)
mov    %r14,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rbx,%rax,8),%xmm0
mulsd  (%rcx),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm0
mulsd  (%rcx,%r9,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
add    $0x2,%rax
add    %rbp,%rcx
cmp    %rax,%r12
jne    1440 <_compute_viterbi+0x310>
movapd %xmm3,0x30(%rsp)
test   $0x1,%dl
je     13b0 <_compute_viterbi+0x280>
movsd  (%rbx,%rax,8),%xmm0
mov    %rax,%rcx
imul   %r9,%rcx
add    %r13,%rcx
mov    0x8(%rsp),%rdx
mulsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
jmp    13b0 <_compute_viterbi+0x280>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %esi,%esi
mov    0x68(%rsp),%r8
jle    1370 <_compute_viterbi+0x240>
cmp    $0x1,%esi
jne    14c6 <_compute_viterbi+0x396>
xor    %eax,%eax
jmp    1530 <_compute_viterbi+0x400>
movapd %xmm3,%xmm0
unpcklpd %xmm3,%xmm0
cmpq   $0x0,0x58(%rsp)
je     154c <_compute_viterbi+0x41c>
mov    0x40(%rsp),%rcx
xor    %eax,%eax
nopl   (%rax)
movupd (%rdi,%rax,8),%xmm1
movupd 0x10(%rdi,%rax,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,(%rdi,%rax,8)
divpd  %xmm0,%xmm2
movupd %xmm2,0x10(%rdi,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    14e0 <_compute_viterbi+0x3b0>
testb  $0x1,0x50(%rsp)
je     151d <_compute_viterbi+0x3ed>
movupd (%rdi,%rax,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%rdi,%rax,8)
mov    %r12,%rax
cmp    %rdx,%r12
je     1370 <_compute_viterbi+0x240>
nopl   0x0(%rax)
movsd  (%rdi,%rax,8),%xmm0
divsd  %xmm3,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1530 <_compute_viterbi+0x400>
jmp    1370 <_compute_viterbi+0x240>
xor    %eax,%eax
testb  $0x1,0x50(%rsp)
jne    150f <_compute_viterbi+0x3df>
jmp    151d <_compute_viterbi+0x3ed>
xor    %r13d,%r13d
mov    %rdi,%r14
xor    %eax,%eax
mov    %rsi,%rbp
call   1040 <argmax@plt>
mov    0x10(%rsp),%rdx
movslq %edx,%rcx
mov    0x48(%rsp),%r8
mov    %eax,-0x4(%r8,%rcx,4)
cmp    $0x2,%edx
jl     15fc <_compute_viterbi+0x4cc>
lea    -0x2(%rdx),%eax
mov    %rax,%rsi
test   $0x1,%al
mov    (%rsp),%r12
jne    15ad <_compute_viterbi+0x47d>
add    $0xffffffff,%edx
imul   %ebp,%edx
movslq 0x4(%r8,%rax,4),%rcx
movslq %edx,%rdx
add    %rcx,%rdx
mov    (%r12,%rdx,4),%ecx
mov    %ecx,(%r8,%rax,4)
lea    -0x1(%rax),%rsi
test   %rax,%rax
mov    %r14,%rdi
je     1603 <_compute_viterbi+0x4d3>
lea    0x1(%rsi),%eax
imul   %ebp,%eax
lea    0x0(%rbp,%rbp,1),%ecx
mov    %rsi,%rdx
add    $0x1,%rdx
imul   %esi,%ebp
nopl   0x0(%rax)
mov    (%r8,%rdx,4),%esi
add    %eax,%esi
movslq %esi,%rsi
mov    (%r12,%rsi,4),%esi
mov    %esi,-0x4(%r8,%rdx,4)
add    %ebp,%esi
movslq %esi,%rsi
mov    (%r12,%rsi,4),%esi
mov    %esi,-0x8(%r8,%rdx,4)
sub    %ecx,%eax
sub    %ecx,%ebp
add    $0xfffffffffffffffe,%rdx
jne    15d0 <_compute_viterbi+0x4a0>
jmp    1603 <_compute_viterbi+0x4d3>
mov    %r14,%rdi
mov    (%rsp),%r12
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13d,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
test   $0x1,%r8b
jne    12de <_compute_viterbi+0x1ae>
jmp    12ec <_compute_viterbi+0x1bc>

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

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