void ViterbiTb(int output_u_int[], int out0[], int state0[], int out1[],
               int state1[], double input_c[], int KK, int nn, int LL,
               int depth) {
  int i, t, state, mm, states, max_state;
  int number_symbols, starting_bit;
  float metric;
  float *prev_section, *next_section;
  int *prev_bit;
  int *prev_state;
  float *metric_c;
  float *rec_array;
  float max_val;
  mm = KK - 1;
  states = 1 << mm;
  number_symbols = 1 << nn;
  prev_section = (float *)calloc(states, sizeof(float));
  next_section = (float *)calloc(states, sizeof(float));
  prev_bit = (int *)calloc(states * (LL + depth), sizeof(int));
  prev_state = (int *)calloc(states * (LL + depth), sizeof(int));
  rec_array = (float *)calloc(nn, sizeof(float));
  metric_c = (float *)calloc(number_symbols, sizeof(float));
  for (state = 0; state < states; state++) {
    prev_section[state] = 0;
    next_section[state] = -1e7;
  }
  for (t = -depth; t < LL + depth; t++) {
    starting_bit = nn * (t % LL);
    if (starting_bit < 0)
      starting_bit = nn * LL + starting_bit;
    for (i = 0; i < nn; i++) {
      rec_array[i] = (float)input_c[starting_bit + i];
    }
    for (i = 0; i < number_symbols; i++)
      metric_c[i] = Gamma(rec_array, i, nn);
    for (state = 0; state < states; state++) {
      metric = prev_section[state] + metric_c[out0[state]];
      if (metric > next_section[state0[state]]) {
        next_section[state0[state]] = metric;
        if (t >= 0) {
          prev_state[t * states + state0[state]] = state;
          prev_bit[t * states + state0[state]] = 0;
        }
      }
      metric = prev_section[state] + metric_c[out1[state]];
      if (metric > next_section[state1[state]]) {
        next_section[state1[state]] = metric;
        if (t >= 0) {
          prev_state[t * states + state1[state]] = state;
          prev_bit[t * states + state1[state]] = 1;
        }
      }
    }
    max_val = 0;
    for (state = 0; state < states; state++) {
      if (next_section[state] > max_val) {
        max_val = next_section[state];
        max_state = state;
      }
    }
    for (state = 0; state < states; state++) {
      prev_section[state] = next_section[state] - max_val;
      next_section[state] = -1e7;
    }
  }
  state = max_state;
  for (t = LL + depth - 1; t >= LL; t--) {
    state = prev_state[t * states + state];
  }
  for (t = LL - 1; t >= 0; t--) {
    output_u_int[t] = prev_bit[t * states + state];
    state = prev_state[t * states + state];
  }
  free(prev_section);
  free(next_section);
  free(prev_bit);
  free(prev_state);
  free(rec_array);
  free(metric_c);
}


x86 assembly (clang, -O0):
<ViterbiTb>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
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    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x44(%rbp)
mov    0x18(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x4c(%rbp)
movslq -0x44(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x44(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x44(%rbp),%eax
mov    0x20(%rbp),%ecx
add    0x28(%rbp),%ecx
imul   %ecx,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    0x20(%rbp),%ecx
add    0x28(%rbp),%ecx
imul   %ecx,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x78(%rbp)
movslq 0x18(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0x4c(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x80(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    124d <ViterbiTb+0x11d>
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  0xdc6(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    120e <ViterbiTb+0xde>
xor    %eax,%eax
sub    0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x20(%rbp),%ecx
add    0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    1579 <ViterbiTb+0x449>
mov    0x18(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x38(%rbp),%eax
cltd
idivl  0x20(%rbp)
mov    -0x90(%rbp),%eax
imul   %edx,%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x50(%rbp)
jge    1299 <ViterbiTb+0x169>
mov    0x18(%rbp),%eax
imul   0x20(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jge    12e0 <ViterbiTb+0x1b0>
mov    -0x30(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12a0 <ViterbiTb+0x170>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1326 <ViterbiTb+0x1f6>
mov    -0x88(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    0x18(%rbp),%edx
mov    $0x0,%al
call   1030 <Gamma@plt>
cvtsi2ss %eax,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12e7 <ViterbiTb+0x1b7>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    14a8 <ViterbiTb+0x378>
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    13e7 <ViterbiTb+0x2b7>
movss  -0x54(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x38(%rbp)
jl     13e2 <ViterbiTb+0x2b2>
mov    -0x3c(%rbp),%edx
mov    -0x78(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x18(%rbp),%rsi
movslq -0x3c(%rbp),%rdi
add    (%rsi,%rdi,4),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x18(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    13e7 <ViterbiTb+0x2b7>
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1495 <ViterbiTb+0x365>
movss  -0x54(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
cmpl   $0x0,-0x38(%rbp)
jl     1490 <ViterbiTb+0x360>
mov    -0x3c(%rbp),%edx
mov    -0x78(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x28(%rbp),%rsi
movslq -0x3c(%rbp),%rdi
add    (%rsi,%rdi,4),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x44(%rbp),%ecx
mov    -0x28(%rbp),%rdx
movslq -0x3c(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1495 <ViterbiTb+0x365>
jmp    149a <ViterbiTb+0x36a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    132d <ViterbiTb+0x1fd>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    150e <ViterbiTb+0x3de>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x8c(%rbp),%xmm0
jbe    14fb <ViterbiTb+0x3cb>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1500 <ViterbiTb+0x3d0>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14ba <ViterbiTb+0x38a>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1566 <ViterbiTb+0x436>
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x8c(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  0xaad(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1515 <ViterbiTb+0x3e5>
jmp    156b <ViterbiTb+0x43b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1255 <ViterbiTb+0x125>
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x20(%rbp),%eax
add    0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x20(%rbp),%eax
jl     15bc <ViterbiTb+0x48c>
mov    -0x78(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    158b <ViterbiTb+0x45b>
mov    0x20(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     1613 <ViterbiTb+0x4e3>
mov    -0x70(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    15c5 <ViterbiTb+0x495>
mov    -0x60(%rbp),%rdi
call   1040 <free@plt>
mov    -0x68(%rbp),%rdi
call   1040 <free@plt>
mov    -0x70(%rbp),%rdi
call   1040 <free@plt>
mov    -0x78(%rbp),%rdi
call   1040 <free@plt>
mov    -0x88(%rbp),%rdi
call   1040 <free@plt>
mov    -0x80(%rbp),%rdi
call   1040 <free@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ViterbiTb>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,0x30(%rsp)
mov    %r8,0xd0(%rsp)
mov    %rcx,0xc8(%rsp)
mov    %rdx,0xe0(%rsp)
mov    %rsi,0xd8(%rsp)
mov    %rdi,0x58(%rsp)
mov    0x138(%rsp),%r14d
mov    0x130(%rsp),%r13d
mov    0x128(%rsp),%edx
mov    %edx,(%rsp)
mov    0x120(%rsp),%r15d
add    $0xffffffff,%r15d
mov    $0x1,%ebx
mov    $0x1,%eax
mov    %r15d,%ecx
shl    %cl,%eax
mov    $0x1,%r12d
mov    %edx,%ecx
shl    %cl,%r12d
mov    %eax,0x8(%rsp)
movslq %eax,%rbp
mov    $0x4,%esi
mov    %rbp,%rdi
call   1050 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    $0x4,%esi
mov    %rbp,%rdi
mov    %r13,%rbp
call   1050 <calloc@plt>
mov    %rax,%r13
mov    %r14,0x60(%rsp)
mov    %rbp,0x38(%rsp)
add    %r14d,%ebp
mov    %ebp,%eax
mov    %r15d,%ecx
shl    %cl,%eax
movslq %eax,%r14
mov    $0x4,%esi
mov    %r14,%rdi
call   1050 <calloc@plt>
mov    %rax,0x20(%rsp)
mov    $0x4,%esi
mov    %r14,%rdi
call   1050 <calloc@plt>
mov    %rax,0x40(%rsp)
movslq (%rsp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,%r14
mov    %r12,0x48(%rsp)
movslq %r12d,%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %r15d,%ecx
mov    %rax,%r15
cmp    $0x1f,%ecx
je     1382 <ViterbiTb+0x252>
mov    0x8(%rsp),%eax
cmp    $0x2,%eax
cmovge %eax,%ebx
cmp    $0x8,%ebx
jae    125a <ViterbiTb+0x12a>
xor    %eax,%eax
jmp    1370 <ViterbiTb+0x240>
mov    %ebx,%eax
and    $0x7ffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%edi
and    $0x7,%edi
cmp    $0x38,%rsi
jae    1282 <ViterbiTb+0x152>
xor    %esi,%esi
jmp    1326 <ViterbiTb+0x1f6>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
movapd 0xd70(%rip),%xmm0
movupd %xmm0,0x0(%r13,%rsi,4)
movupd %xmm0,0x10(%r13,%rsi,4)
movupd %xmm0,0x20(%r13,%rsi,4)
movupd %xmm0,0x30(%r13,%rsi,4)
movupd %xmm0,0x40(%r13,%rsi,4)
movupd %xmm0,0x50(%r13,%rsi,4)
movupd %xmm0,0x60(%r13,%rsi,4)
movupd %xmm0,0x70(%r13,%rsi,4)
movupd %xmm0,0x80(%r13,%rsi,4)
movupd %xmm0,0x90(%r13,%rsi,4)
movupd %xmm0,0xa0(%r13,%rsi,4)
movupd %xmm0,0xb0(%r13,%rsi,4)
movupd %xmm0,0xc0(%r13,%rsi,4)
movupd %xmm0,0xd0(%r13,%rsi,4)
movupd %xmm0,0xe0(%r13,%rsi,4)
movupd %xmm0,0xf0(%r13,%rsi,4)
add    $0x40,%rsi
add    $0xfffffffffffffff8,%rdx
jne    1290 <ViterbiTb+0x160>
test   %rdi,%rdi
je     1364 <ViterbiTb+0x234>
lea    0x10(,%rsi,4),%rdx
add    %r13,%rdx
shl    $0x5,%rdi
xor    %esi,%esi
movapd 0xcbc(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd %xmm0,-0x10(%rdx,%rsi,1)
movupd %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdi
jne    1350 <ViterbiTb+0x220>
cmp    %rbx,%rax
je     1382 <ViterbiTb+0x252>
nopl   0x0(%rax)
movl   $0xcb189680,0x0(%r13,%rax,4)
18 cb
add    $0x1,%rax
cmp    %rax,%rbx
jne    1370 <ViterbiTb+0x240>
mov    0x60(%rsp),%rax
mov    %eax,%esi
neg    %esi
mov    %ebp,0x1c(%rsp)
cmp    %esi,%ebp
mov    0x40(%rsp),%r11
mov    (%rsp),%ebp
mov    0x48(%rsp),%r12
mov    0x38(%rsp),%r9
jle    1903 <ViterbiTb+0x7d3>
mov    %r9d,%eax
imul   %ebp,%eax
mov    %eax,0x50(%rsp)
cmp    $0x2,%r12d
mov    $0x1,%r8d
cmovl  %r8d,%r12d
mov    %r12,0x48(%rsp)
mov    0x8(%rsp),%eax
cmp    $0x2,%eax
cmovge %eax,%r8d
mov    %ebp,%edi
mov    %edi,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xc0(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xb8(%rsp)
mov    %rdx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
lea    -0x1(%r8),%rdx
mov    %rdx,0xa8(%rsp)
mov    %r8d,%edx
and    $0x7ffffff8,%edx
mov    %rdx,0x88(%rsp)
add    $0xfffffffffffffff8,%rdx
mov    %rdx,0x80(%rsp)
mov    %rdx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %rbx,%rdx
mov    %rbx,0xb0(%rsp)
and    $0xfffffffffffffffe,%rbx
mov    %rbx,0xa0(%rsp)
mov    %r8d,%edx
and    $0x3,%edx
mov    %rdx,0x68(%rsp)
mov    %r8,0x8(%rsp)
and    $0x7ffffffc,%r8d
mov    %r8,0x90(%rsp)
movabs $0x3ffffffffffffff8,%rbx
ff ff 3f
or     $0x6,%rbx
mov    %rax,%rdx
mov    %rax,0x78(%rsp)
and    %rax,%rbx
mov    %rbx,0x70(%rsp)
mov    0x30(%rsp),%rax
add    $0x30,%rax
mov    %rax,0x98(%rsp)
mov    %ecx,0x54(%rsp)
mov    %rdi,0x10(%rsp)
jmp    14b5 <ViterbiTb+0x385>
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%ebp
mov    0x10(%rsp),%rdi
add    $0x1,%esi
cmp    0x1c(%rsp),%esi
je     1903 <ViterbiTb+0x7d3>
mov    %esi,0x4(%rsp)
mov    %esi,%eax
cltd
idiv   %r9d
test   %ebp,%ebp
jle    15c8 <ViterbiTb+0x498>
imul   %ebp,%edx
mov    %edx,%eax
sar    $0x1f,%eax
and    0x50(%rsp),%eax
add    %edx,%eax
cltq
cmp    $0x4,%ebp
jae    14f0 <ViterbiTb+0x3c0>
xor    %ecx,%ecx
jmp    15a6 <ViterbiTb+0x476>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpq   $0x0,0xb8(%rsp)
je     17e3 <ViterbiTb+0x6b3>
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,8),%rdx
mov    0xa0(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x30(%rdx,%rcx,8),%xmm0
movupd -0x20(%rdx,%rcx,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%r14,%rcx,4)
movupd -0x10(%rdx,%rcx,8),%xmm0
movupd (%rdx,%rcx,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,0x10(%r14,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1520 <ViterbiTb+0x3f0>
testb  $0x1,0xb0(%rsp)
01
je     1596 <ViterbiTb+0x466>
lea    (%rcx,%rax,1),%rdx
mov    0x30(%rsp),%rsi
movupd (%rsi,%rdx,8),%xmm0
movupd 0x10(%rsi,%rdx,8),%xmm1
cvtpd2ps %xmm0,%xmm0
cvtpd2ps %xmm1,%xmm1
unpcklpd %xmm1,%xmm0
movupd %xmm0,(%r14,%rcx,4)
mov    0xc0(%rsp),%rdx
mov    %rdx,%rcx
cmp    %rdi,%rdx
je     15c8 <ViterbiTb+0x498>
mov    0x30(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
nop
movsd  (%rax,%rcx,8),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r14,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    15b0 <ViterbiTb+0x480>
cmp    $0x1f,%ebp
je     15fa <ViterbiTb+0x4ca>
xor    %r12d,%r12d
mov    %r14,%rdi
mov    %r12d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1030 <Gamma@plt>
mov    (%rsp),%ebp
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,(%r15,%r12,4)
add    $0x1,%r12
cmp    %r12,0x48(%rsp)
jne    15d0 <ViterbiTb+0x4a0>
mov    0x54(%rsp),%ecx
cmp    $0x1f,%ecx
jne    1620 <ViterbiTb+0x4f0>
mov    0x40(%rsp),%r11
mov    0x38(%rsp),%r9
mov    0x4(%rsp),%esi
jmp    14a3 <ViterbiTb+0x373>
cs nopw 0x0(%rax,%rax,1)
mov    0x38(%rsp),%r9
mov    0x4(%rsp),%esi
mov    %esi,%r12d
shl    %cl,%r12d
xor    %edi,%edi
mov    0x28(%rsp),%r8
mov    0x20(%rsp),%r10
mov    0x40(%rsp),%r11
mov    0xd0(%rsp),%rbp
mov    0xc8(%rsp),%rax
jmp    166f <ViterbiTb+0x53f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rdi
cmp    %rdi,0x8(%rsp)
je     1710 <ViterbiTb+0x5e0>
movss  (%r8,%rdi,4),%xmm0
mov    0xd8(%rsp),%rdx
movslq (%rdx,%rdi,4),%rdx
movss  (%r15,%rdx,4),%xmm1
addss  %xmm0,%xmm1
mov    0xe0(%rsp),%rdx
movslq (%rdx,%rdi,4),%rdx
ucomiss 0x0(%r13,%rdx,4),%xmm1
jbe    16c0 <ViterbiTb+0x590>
movss  %xmm1,0x0(%r13,%rdx,4)
test   %esi,%esi
js     16c0 <ViterbiTb+0x590>
movslq %r12d,%rsi
add    %rsi,%rdx
mov    0x4(%rsp),%esi
mov    %edi,(%r11,%rdx,4)
movl   $0x0,(%r10,%rdx,4)
movslq (%rax,%rdi,4),%rdx
addss  (%r15,%rdx,4),%xmm0
movslq 0x0(%rbp,%rdi,4),%rdx
ucomiss 0x0(%r13,%rdx,4),%xmm0
jbe    1660 <ViterbiTb+0x530>
movss  %xmm0,0x0(%r13,%rdx,4)
test   %esi,%esi
js     1660 <ViterbiTb+0x530>
movslq %r12d,%rsi
add    %rsi,%rdx
mov    0x4(%rsp),%esi
mov    %edi,(%r11,%rdx,4)
movl   $0x1,(%r10,%rdx,4)
jmp    1660 <ViterbiTb+0x530>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x1f,%ecx
movaps 0x8e6(%rip),%xmm4
je     14a0 <ViterbiTb+0x370>
cmpq   $0x3,0xa8(%rsp)
jae    1732 <ViterbiTb+0x602>
xorps  %xmm1,%xmm1
xor    %eax,%eax
jmp    179a <ViterbiTb+0x66a>
xorps  %xmm1,%xmm1
xor    %eax,%eax
mov    0x90(%rsp),%rdi
nop
movss  0x0(%r13,%rax,4),%xmm0
ucomiss %xmm1,%xmm0
cmova  %eax,%ebx
movss  0x4(%r13,%rax,4),%xmm2
maxss  %xmm1,%xmm0
ucomiss %xmm0,%xmm2
lea    0x1(%rax),%esi
cmovbe %ebx,%esi
maxss  %xmm0,%xmm2
movss  0x8(%r13,%rax,4),%xmm0
ucomiss %xmm2,%xmm0
lea    0x2(%rax),%edx
cmovbe %esi,%edx
maxss  %xmm2,%xmm0
movss  0xc(%r13,%rax,4),%xmm1
ucomiss %xmm0,%xmm1
lea    0x3(%rax),%ebx
cmovbe %edx,%ebx
maxss  %xmm0,%xmm1
add    $0x4,%rax
cmp    %rdi,%rax
jne    1740 <ViterbiTb+0x610>
mov    0x4(%rsp),%esi
mov    0x8(%rsp),%rdi
movaps %xmm1,%xmm0
cmpq   $0x0,0x68(%rsp)
je     17ce <ViterbiTb+0x69e>
mov    0x68(%rsp),%rdx
nop
movss  0x0(%r13,%rax,4),%xmm0
ucomiss %xmm1,%xmm0
cmova  %eax,%ebx
maxss  %xmm1,%xmm0
add    $0x1,%rax
movaps %xmm0,%xmm1
add    $0xffffffffffffffff,%rdx
jne    17b0 <ViterbiTb+0x680>
cmp    $0x1f,%ecx
je     14a0 <ViterbiTb+0x370>
cmp    $0x8,%edi
jae    17f8 <ViterbiTb+0x6c8>
xor    %eax,%eax
jmp    18d0 <ViterbiTb+0x7a0>
xor    %ecx,%ecx
testb  $0x1,0xb0(%rsp)
01
jne    1570 <ViterbiTb+0x440>
jmp    1596 <ViterbiTb+0x466>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x0,0x80(%rsp)
je     18f8 <ViterbiTb+0x7c8>
mov    0x70(%rsp),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x0(%r13,%rax,4),%xmm2
movups 0x10(%r13,%rax,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,(%r8,%rax,4)
movups %xmm3,0x10(%r8,%rax,4)
movups %xmm4,0x0(%r13,%rax,4)
movups %xmm4,0x10(%r13,%rax,4)
movups 0x20(%r13,%rax,4),%xmm2
movups 0x30(%r13,%rax,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,0x20(%r8,%rax,4)
movups %xmm3,0x30(%r8,%rax,4)
movups %xmm4,0x20(%r13,%rax,4)
movups %xmm4,0x30(%r13,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    1820 <ViterbiTb+0x6f0>
testb  $0x1,0x78(%rsp)
je     18ad <ViterbiTb+0x77d>
movups 0x0(%r13,%rax,4),%xmm2
movups 0x10(%r13,%rax,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,(%r8,%rax,4)
movups %xmm3,0x10(%r8,%rax,4)
movups %xmm4,0x0(%r13,%rax,4)
movups %xmm4,0x10(%r13,%rax,4)
mov    0x88(%rsp),%rdx
mov    %rdx,%rax
cmp    %rdi,%rdx
je     14a0 <ViterbiTb+0x370>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%r13,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rax,4)
movl   $0xcb189680,0x0(%r13,%rax,4)
18 cb
add    $0x1,%rax
cmp    %rax,%rdi
jne    18d0 <ViterbiTb+0x7a0>
jmp    14a0 <ViterbiTb+0x370>
xor    %eax,%eax
testb  $0x1,0x78(%rsp)
jne    1884 <ViterbiTb+0x754>
jmp    18ad <ViterbiTb+0x77d>
cmpl   $0x0,0x60(%rsp)
jle    193e <ViterbiTb+0x80e>
mov    0x58(%rsp),%r8
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%r12
mov    0x1c(%rsp),%edx
nopl   (%rax)
add    $0xffffffff,%edx
mov    %edx,%eax
shl    %cl,%eax
add    %ebx,%eax
cltq
mov    (%r11,%rax,4),%ebx
cmp    %r9d,%edx
jg     1920 <ViterbiTb+0x7f0>
test   %r9d,%r9d
jg     1952 <ViterbiTb+0x822>
jmp    19bf <ViterbiTb+0x88f>
mov    0x58(%rsp),%r8
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%r12
test   %r9d,%r9d
jle    19bf <ViterbiTb+0x88f>
mov    %r9d,%eax
test   $0x1,%al
je     1974 <ViterbiTb+0x844>
add    $0xffffffffffffffff,%rax
mov    %eax,%edx
mov    %eax,%esi
shl    %cl,%esi
add    %ebx,%esi
movslq %esi,%rbx
mov    (%r12,%rbx,4),%esi
mov    %esi,(%r8,%rdx,4)
mov    (%r11,%rbx,4),%ebx
cmp    $0x1,%r9d
je     19bf <ViterbiTb+0x88f>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rax),%r10
mov    %r10d,%r9d
mov    %r10d,%esi
shl    %cl,%esi
add    %ebx,%esi
movslq %esi,%rdx
mov    (%r12,%rdx,4),%ebx
mov    %ebx,(%r8,%r9,4)
add    $0xfffffffffffffffe,%rax
mov    %eax,%esi
shl    %cl,%esi
movslq (%r11,%rdx,4),%rbx
mov    %eax,%edx
movslq %esi,%rsi
add    %rbx,%rsi
mov    (%r12,%rsi,4),%ebx
mov    %ebx,(%r8,%rdx,4)
mov    (%r11,%rsi,4),%ebx
cmp    $0x1,%r10
ja     1980 <ViterbiTb+0x850>
mov    %r11,%rbx
call   1040 <free@plt>
mov    %r13,%rdi
call   1040 <free@plt>
mov    %r12,%rdi
call   1040 <free@plt>
mov    %rbx,%rdi
call   1040 <free@plt>
mov    %r14,%rdi
call   1040 <free@plt>
mov    %r15,%rdi
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free@plt>

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

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