#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
void update_ring_buffer(float **chunk, float **ring_buffer, int nchan,
                        int nchunk, int nring, int *ring_t0) {
  assert(nring >= nchunk + nchan - 1);
  int t0 = *ring_t0;
  for (int j = 0; j < nchan; j++) {
    int t1 = (t0 - j + nring) % nring;
    int n1, t2;
    if (t1 + j < nring) {
      n1 = j;
      t2 = t1 + j;
    } else {
      n1 = nring - t1;
      t2 = t1 + j - nring;
    }
    int n2 = (t2 + nchunk < nring) ? nchunk : (nring - t2);
    for (int i = 0; i < n1; i++) {
      ring_buffer[j][t1 + i] += chunk[j][i];
    }
    for (int i = n1; i < j; i++) {
      ring_buffer[j][i - n1] += chunk[j][i];
    }
    for (int i = 0; i < n2; i++) {
      ring_buffer[j][t2 + i] = chunk[j][j + i];
    }
    for (int i = n2; i < nchunk; i++) {
      ring_buffer[j][i - n2] = chunk[j][j + i];
    }
  }
}


x86 assembly (clang, -O0):
<update_ring_buffer>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    133b <update_ring_buffer+0x22b>
mov    -0x2c(%rbp),%eax
sub    -0x30(%rbp),%eax
add    -0x1c(%rbp),%eax
cltd
idivl  -0x1c(%rbp)
mov    %edx,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1198 <update_ring_buffer+0x88>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    11ad <update_ring_buffer+0x9d>
mov    -0x1c(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    -0x30(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11c7 <update_ring_buffer+0xb7>
mov    -0x18(%rbp),%eax
mov    %eax,-0x54(%rbp)
jmp    11d0 <update_ring_buffer+0xc0>
mov    -0x1c(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    122b <update_ring_buffer+0x11b>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x34(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11dd <update_ring_buffer+0xcd>
mov    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    127f <update_ring_buffer+0x16f>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x48(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1231 <update_ring_buffer+0x121>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    12d4 <update_ring_buffer+0x1c4>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1286 <update_ring_buffer+0x176>
mov    -0x40(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1328 <update_ring_buffer+0x218>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x50(%rbp),%ecx
sub    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12da <update_ring_buffer+0x1ca>
jmp    132d <update_ring_buffer+0x21d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1159 <update_ring_buffer+0x49>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<update_ring_buffer>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,%r14
mov    %ecx,%r13d
mov    %edx,%ebx
mov    %rsi,0x28(%rsp)
mov    %rdi,0x20(%rsp)
lea    (%rbx,%r13,1),%eax
add    $0xffffffff,%eax
xor    %edi,%edi
mov    %r8d,(%rsp)
cmp    %r8d,%eax
setle  %dil
call   1030 <assert@plt>
test   %ebx,%ebx
jle    1882 <update_ring_buffer+0x772>
mov    (%r14),%eax
add    (%rsp),%eax
mov    %eax,0x44(%rsp)
movslq %r13d,%r10
mov    %ebx,%eax
mov    %rax,0x50(%rsp)
mov    $0xc,%eax
mov    %rax,0x48(%rsp)
xor    %r11d,%r11d
xor    %r14d,%r14d
mov    %r13d,%eax
mov    %rax,0x30(%rsp)
mov    %r13,0x10(%rsp)
jmp    11b6 <update_ring_buffer+0xa6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r11
mov    0x30(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x30(%rsp)
add    $0xffffffff,%r14d
addq   $0x1,0x48(%rsp)
cmp    0x50(%rsp),%r11
je     1882 <update_ring_buffer+0x772>
mov    %r14d,0x4(%rsp)
mov    0x44(%rsp),%eax
sub    %r11d,%eax
cltd
mov    (%rsp),%ecx
idiv   %ecx
lea    (%rdx,%r11,1),%r8d
mov    %ecx,%esi
sub    %edx,%esi
cmp    %ecx,%r8d
cmovl  %r11d,%esi
mov    %ecx,%r15d
mov    $0x0,%eax
cmovl  %eax,%r15d
mov    %r8d,%ebp
sub    %r15d,%ebp
lea    0x0(%rbp,%r13,1),%eax
mov    %ecx,%r12d
sub    %ebp,%r12d
cmp    %ecx,%eax
cmovl  %r13d,%r12d
test   %esi,%esi
mov    %rdx,0x8(%rsp)
jle    1270 <update_ring_buffer+0x160>
mov    0x20(%rsp),%rax
mov    (%rax,%r11,8),%rax
mov    0x28(%rsp),%rcx
mov    (%rcx,%r11,8),%rcx
movslq %edx,%r14
mov    %esi,%r9d
cmp    $0x8,%esi
jb     1242 <update_ring_buffer+0x132>
lea    (%rcx,%r14,4),%rdx
lea    (%rax,%r9,4),%rsi
cmp    %rsi,%rdx
jae    12f8 <update_ring_buffer+0x1e8>
lea    (%r14,%r9,1),%rdx
lea    (%rcx,%rdx,4),%rdx
cmp    %rdx,%rax
jae    12f8 <update_ring_buffer+0x1e8>
xor    %ebx,%ebx
lea    (%rcx,%r14,4),%rcx
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rbx,4),%xmm0
addss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rbx,4)
add    $0x1,%rbx
cmp    %r9,%rbx
jb     1250 <update_ring_buffer+0x140>
jmp    1273 <update_ring_buffer+0x163>
nopw   0x0(%rax,%rax,1)
movslq %esi,%r9
cmp    %r11,%r9
jge    14eb <update_ring_buffer+0x3db>
mov    0x20(%rsp),%rax
mov    (%rax,%r11,8),%rax
mov    0x28(%rsp),%rcx
mov    (%rcx,%r11,8),%rcx
mov    (%rsp),%esi
cmp    %r8d,%esi
mov    %r8d,%edx
cmovl  %esi,%edx
sub    0x8(%rsp),%edx
movslq %edx,%r14
lea    0x1(%r14),%rdx
cmp    %rdx,%r11
mov    %rdx,%rbx
cmovg  %r11,%rbx
sub    %r14,%rbx
cmp    $0x8,%rbx
jb     14c0 <update_ring_buffer+0x3b0>
mov    %r14,%rsi
sub    %r9,%rsi
lea    (%rcx,%rsi,4),%rsi
cmp    %rdx,%r11
cmovg  %r11,%rdx
lea    (%rax,%rdx,4),%rdi
cmp    %rdi,%rsi
jae    13a4 <update_ring_buffer+0x294>
sub    %r9,%rdx
lea    (%rcx,%rdx,4),%rdx
lea    (%rax,%r14,4),%rsi
cmp    %rdx,%rsi
jae    13a4 <update_ring_buffer+0x294>
mov    0x10(%rsp),%r13
jmp    14c0 <update_ring_buffer+0x3b0>
mov    %rbp,0x18(%rsp)
mov    %r9d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rdx
mov    %rdx,%r13
shr    $0x3,%r13
add    $0x1,%r13
test   %rdx,%rdx
je     17d2 <update_ring_buffer+0x6c2>
mov    (%rsp),%edx
cmp    %r8d,%edx
mov    %r8d,%ebp
cmovl  %edx,%ebp
lea    (%rcx,%r14,4),%rsi
add    $0x30,%rsi
sub    0x8(%rsp),%ebp
and    $0xfffffff8,%ebp
add    $0xfffffffffffffff8,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups -0x30(%rsi,%rdi,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rsi,%rdi,4),%xmm0
addps  %xmm1,%xmm0
movups -0x10(%rsi,%rdi,4),%xmm1
movups (%rsi,%rdi,4),%xmm3
movups %xmm2,-0x30(%rsi,%rdi,4)
movups %xmm0,-0x20(%rsi,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm0
addps  %xmm1,%xmm0
movups 0x30(%rax,%rdi,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,-0x10(%rsi,%rdi,4)
movups %xmm1,(%rsi,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1350 <update_ring_buffer+0x240>
jmp    17d4 <update_ring_buffer+0x6c4>
mov    %rbx,%r13
and    $0xfffffffffffffff8,%r13
lea    -0x8(%r13),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
mov    %rbp,0x18(%rsp)
mov    %rsi,0x38(%rsp)
je     1816 <update_ring_buffer+0x706>
mov    (%rsp),%esi
cmp    %r8d,%esi
mov    %r8d,%edx
cmovl  %esi,%edx
sub    0x8(%rsp),%edx
movslq %edx,%rsi
mov    %rsi,%rdx
sub    %r9,%rdx
lea    (%rcx,%rdx,4),%rdi
add    $0x30,%rdi
lea    0x1(%rsi),%rbp
cmp    %rbp,%r11
cmovg  %r11,%rbp
lea    (%rax,%rsi,4),%rdx
add    $0x30,%rdx
sub    %rsi,%rbp
and    $0xfffffffffffffff8,%rbp
add    $0xfffffffffffffff8,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rsi,4),%xmm0
movups -0x20(%rdx,%rsi,4),%xmm1
movups -0x30(%rdi,%rsi,4),%xmm2
addps  %xmm0,%xmm2
movups -0x20(%rdi,%rsi,4),%xmm0
addps  %xmm1,%xmm0
movups -0x10(%rdi,%rsi,4),%xmm1
movups (%rdi,%rsi,4),%xmm3
movups %xmm2,-0x30(%rdi,%rsi,4)
movups %xmm0,-0x20(%rdi,%rsi,4)
movups -0x10(%rdx,%rsi,4),%xmm0
addps  %xmm1,%xmm0
movups (%rdx,%rsi,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,-0x10(%rdi,%rsi,4)
movups %xmm1,(%rdi,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rbp
jne    1420 <update_ring_buffer+0x310>
testb  $0x1,0x38(%rsp)
je     149d <update_ring_buffer+0x38d>
add    %r14,%rsi
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm1
sub    %r9,%rsi
movups (%rcx,%rsi,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rsi,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rcx,%rsi,4)
movups %xmm0,0x10(%rcx,%rsi,4)
cmp    %r13,%rbx
mov    %r13,%rdx
mov    0x10(%rsp),%r13
mov    0x18(%rsp),%rbp
je     14eb <update_ring_buffer+0x3db>
add    %rdx,%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
shl    $0x2,%r9
sub    %r9,%rcx
nopw   0x0(%rax,%rax,1)
movss  (%rax,%r14,4),%xmm0
addss  (%rcx,%r14,4),%xmm0
movss  %xmm0,(%rcx,%r14,4)
add    $0x1,%r14
cmp    %r11,%r14
jl     14d0 <update_ring_buffer+0x3c0>
test   %r12d,%r12d
mov    0x4(%rsp),%r14d
jle    153a <update_ring_buffer+0x42a>
mov    0x20(%rsp),%rax
mov    (%rax,%r11,8),%rdi
mov    0x28(%rsp),%rax
mov    (%rax,%r11,8),%rcx
mov    %r12d,%ebx
cmp    $0x8,%r12d
jae    16e0 <update_ring_buffer+0x5d0>
xor    %eax,%eax
sub    %r15d,%r8d
lea    (%rdi,%r11,4),%rdx
nopl   (%rax)
movss  (%rdx,%rax,4),%xmm0
lea    (%r8,%rax,1),%esi
movslq %esi,%rsi
movss  %xmm0,(%rcx,%rsi,4)
add    $0x1,%rax
cmp    %rbx,%rax
jb     1520 <update_ring_buffer+0x410>
cmp    %r13d,%r12d
jge    1190 <update_ring_buffer+0x80>
mov    0x20(%rsp),%rax
mov    (%rax,%r11,8),%r8
mov    0x28(%rsp),%rax
mov    (%rax,%r11,8),%rax
mov    0x30(%rsp),%rcx
mov    0x8(%rsp),%rdi
add    %edi,%ecx
sub    %r15d,%ecx
mov    (%rsp),%esi
cmp    %ecx,%esi
mov    %ecx,%edx
cmovl  %esi,%edx
add    %r15d,%edx
add    %r14d,%edx
sub    %edi,%edx
movslq %edx,%rbp
mov    %r10,%rbx
sub    %rbp,%rbx
cmp    $0x8,%rbx
jb     16a0 <update_ring_buffer+0x590>
lea    (%r11,%r10,1),%rdx
lea    (%r8,%rdx,4),%rdx
cmp    %rdx,%rax
jae    15b6 <update_ring_buffer+0x4a6>
lea    (%rax,%r10,4),%rdx
lea    0x0(,%rbp,4),%rsi
sub    %rsi,%rdx
lea    (%r11,%rbp,1),%rsi
lea    (%r8,%rsi,4),%rsi
cmp    %rdx,%rsi
jb     16a0 <update_ring_buffer+0x590>
mov    %rbx,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rdx
mov    %rdx,%r14
shr    $0x3,%r14
add    $0x1,%r14
test   %rdx,%rdx
je     1828 <update_ring_buffer+0x718>
mov    (%rsp),%esi
cmp    %ecx,%esi
mov    %ecx,%edx
cmovl  %esi,%edx
add    %r15d,%edx
add    0x4(%rsp),%edx
sub    0x8(%rsp),%edx
movslq %edx,%rdx
mov    %r10,%rdi
sub    %rdx,%rdi
and    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffff8,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
add    %r11,%rdx
lea    (%r8,%rdx,4),%rsi
add    $0x10,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rsi,%rdx,4),%xmm0
movups (%rsi,%rdx,4),%xmm1
movups %xmm0,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
movups 0x10(%rsi,%rdx,4),%xmm0
movups 0x20(%rsi,%rdx,4),%xmm1
movups %xmm0,0x20(%rax,%rdx,4)
movups %xmm1,0x30(%rax,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1620 <update_ring_buffer+0x510>
test   $0x1,%r14b
je     1677 <update_ring_buffer+0x567>
movslq %r12d,%rsi
add    %rbp,%rdx
lea    (%rdx,%r11,1),%rdi
movups (%r8,%rdi,4),%xmm0
movups 0x10(%r8,%rdi,4),%xmm1
sub    %rsi,%rdx
movups %xmm0,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
cmp    %r9,%rbx
mov    0x10(%rsp),%r13
mov    0x4(%rsp),%r14d
je     1190 <update_ring_buffer+0x80>
mov    %r9,%rdx
add    %r9,%rbp
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsp),%edx
cmp    %ecx,%edx
cmovl  %edx,%ecx
add    %ecx,%r15d
add    %r14d,%r15d
sub    %edi,%r15d
movslq %r15d,%rcx
shl    $0x2,%rcx
sub    %rcx,%rax
lea    (%r8,%r11,4),%rcx
nop
movss  (%rcx,%rbp,4),%xmm0
movss  %xmm0,(%rax,%rbp,4)
add    $0x1,%rbp
cmp    %r10,%rbp
jl     16c0 <update_ring_buffer+0x5b0>
jmp    1190 <update_ring_buffer+0x80>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rbx),%rax
lea    (%rax,%rbp,1),%edx
cmp    %ebp,%edx
jl     1514 <update_ring_buffer+0x404>
shr    $0x20,%rax
mov    $0x0,%eax
jne    1516 <update_ring_buffer+0x406>
lea    (%rdi,%r11,4),%rdx
movslq %ebp,%rax
lea    (%rax,%rbx,1),%rsi
lea    (%rcx,%rsi,4),%rsi
cmp    %rsi,%rdx
jae    1727 <update_ring_buffer+0x617>
lea    (%r11,%rbx,1),%rdx
lea    (%rdi,%rdx,4),%rdx
lea    (%rcx,%rax,4),%rax
cmp    %rdx,%rax
jb     1514 <update_ring_buffer+0x404>
mov    %ebx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %rsi,0x38(%rsp)
test   %rdx,%rdx
mov    %rbp,0x18(%rsp)
je     1839 <update_ring_buffer+0x729>
mov    0x48(%rsp),%rdx
mov    %rdi,%r13
lea    (%rdi,%rdx,4),%r9
mov    0x30(%rsp),%rdx
mov    0x8(%rsp),%rsi
lea    (%rsi,%rdx,1),%edi
sub    %r15d,%edi
mov    (%rsp),%edx
cmp    %edi,%edx
cmovl  %edx,%edi
add    %r15d,%edi
add    %r14d,%edi
sub    %esi,%edi
and    $0xfffffff8,%edi
add    $0xfffffffffffffff8,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nop
movups -0x30(%r9,%rdx,4),%xmm0
movups -0x20(%r9,%rdx,4),%xmm1
movslq %ebp,%rbp
movups %xmm0,(%rcx,%rbp,4)
movups %xmm1,0x10(%rcx,%rbp,4)
movups -0x10(%r9,%rdx,4),%xmm0
movups (%r9,%rdx,4),%xmm1
lea    0x8(%rbp),%r14d
movslq %r14d,%rsi
movups %xmm0,(%rcx,%rsi,4)
movups %xmm1,0x10(%rcx,%rsi,4)
add    $0x10,%rdx
add    $0x10,%ebp
add    $0xfffffffffffffffe,%rdi
jne    1790 <update_ring_buffer+0x680>
jmp    183e <update_ring_buffer+0x72e>
xor    %edi,%edi
test   $0x1,%r13b
mov    0x18(%rsp),%rbp
je     1803 <update_ring_buffer+0x6f3>
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
add    %r14,%rdi
movups (%rcx,%rdi,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rdi,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rcx,%rdi,4)
movups %xmm0,0x10(%rcx,%rdi,4)
cmp    %r9,%rbx
mov    0x10(%rsp),%r13
je     1273 <update_ring_buffer+0x163>
jmp    1244 <update_ring_buffer+0x134>
xor    %esi,%esi
testb  $0x1,0x38(%rsp)
jne    1476 <update_ring_buffer+0x366>
jmp    149d <update_ring_buffer+0x38d>
xor    %edx,%edx
test   $0x1,%r14b
jne    1656 <update_ring_buffer+0x546>
jmp    1677 <update_ring_buffer+0x567>
mov    %rdi,%r13
xor    %edx,%edx
testb  $0x1,0x38(%rsp)
mov    %r13,%rdi
je     186a <update_ring_buffer+0x75a>
mov    %rdx,%rsi
add    %r11,%rsi
movups (%rdi,%rsi,4),%xmm0
movups 0x10(%rdi,%rsi,4),%xmm1
mov    0x18(%rsp),%rsi
add    %edx,%esi
movslq %esi,%rdx
movups %xmm0,(%rcx,%rdx,4)
movups %xmm1,0x10(%rcx,%rdx,4)
cmp    %rbx,%rax
mov    0x10(%rsp),%r13
mov    0x4(%rsp),%r14d
jne    1516 <update_ring_buffer+0x406>
jmp    153a <update_ring_buffer+0x42a>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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