#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
double ConvertFromIeeeExtended(char *);
int /*<<< orphan*/ IO_Read_Str(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ filter_interp8(double *, int, double *, int);
int /*<<< orphan*/ filter_reduce8(double *, int);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ vlq_read_short(int /*<<< orphan*/ *, short *);
int read_compressed_array(int ratio, FILE *fp, double *v, int n) {
  int i;
  char data[10];
  double base;
  double delta;
  short previous = 0;
  if (!IO_Read_Str(data, 10, fp))
    return 0;
  base = ConvertFromIeeeExtended(data);
  if (!IO_Read_Str(data, 10, fp))
    return 0;
  delta = ConvertFromIeeeExtended(data);
  if ((1 + (n - 1) / ratio) >= (2 * 4 + 1)) {
    double *sv;
    sv = ((double *)malloc((1 + (n - 1) / ratio) * sizeof(double)));
    for (i = 0; i < n; i += ratio) {
      short s;
      if (!vlq_read_short(fp, &s))
        return 0;
      s += previous;
      previous = s;
      sv[i / ratio] = base + (s * delta) / 16383.0;
    }
    filter_interp8(v, ((n - 1) / ratio) * ratio + 1, sv, 1 + (n - 1) / ratio);
    for (i = i - ratio + 1; i < n; i++) {
      short s;
      if (!vlq_read_short(fp, &s))
        return 0;
      s += previous;
      previous = s;
      v[i] = base + (s * delta) / 16383.0;
    }
    free(sv);
  } else {
    for (i = 0; i < n; i += ratio) {
      int j;
      short s;
      double value;
      if (!vlq_read_short(fp, &s))
        return 0;
      s += previous;
      previous = s;
      value = (s * delta) / 16383.0;
      for (j = 0; (((i + j) < n) && (j < ratio)); j++)
        v[i + j] = value;
    }
    for (i = i - ratio + 1; i < n; i++) {
      short s;
      if (!vlq_read_short(fp, &s))
        return 0;
      s += previous;
      previous = s;
      v[i] = (s * delta) / 16383.0;
    }
    filter_reduce8(v, n);
    for (i = 0; i < n; i++)
      v[i] += base;
  }
  for (i = 0; i < n; i++)
    if (v[i] < 0)
      v[i] = 0;
  return 1;
}


x86 assembly (clang, -O0):
<read_compressed_array>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movw   $0x0,-0x42(%rbp)
lea    -0x2a(%rbp),%rdi
mov    -0x10(%rbp),%rdx
mov    $0xa,%esi
call   1050 <IO_Read_Str@plt>
cmp    $0x0,%eax
jne    11b6 <read_compressed_array+0x46>
movl   $0x0,-0x4(%rbp)
jmp    1598 <read_compressed_array+0x428>
lea    -0x2a(%rbp),%rdi
call   1040 <ConvertFromIeeeExtended@plt>
movsd  %xmm0,-0x38(%rbp)
lea    -0x2a(%rbp),%rdi
mov    -0x10(%rbp),%rdx
mov    $0xa,%esi
call   1050 <IO_Read_Str@plt>
cmp    $0x0,%eax
jne    11eb <read_compressed_array+0x7b>
movl   $0x0,-0x4(%rbp)
jmp    1598 <read_compressed_array+0x428>
lea    -0x2a(%rbp),%rdi
call   1040 <ConvertFromIeeeExtended@plt>
movsd  %xmm0,-0x40(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x8(%rbp)
add    $0x1,%eax
cmp    $0x9,%eax
jl     1397 <read_compressed_array+0x227>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x8(%rbp)
add    $0x1,%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12c5 <read_compressed_array+0x155>
mov    -0x10(%rbp),%rdi
lea    -0x52(%rbp),%rsi
call   1080 <vlq_read_short@plt>
cmp    $0x0,%eax
jne    1262 <read_compressed_array+0xf2>
movl   $0x0,-0x4(%rbp)
jmp    1598 <read_compressed_array+0x428>
movswl -0x42(%rbp),%ecx
movswl -0x52(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x52(%rbp)
mov    -0x52(%rbp),%ax
mov    %ax,-0x42(%rbp)
movsd  -0x38(%rbp),%xmm0
movswl -0x52(%rbp),%eax
cvtsi2sd %eax,%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  0xd6e(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x50(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%eax
cltd
idivl  -0x8(%rbp)
mov    %eax,%ecx
mov    -0x78(%rbp),%rax
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1234 <read_compressed_array+0xc4>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x8(%rbp)
mov    %eax,%esi
imul   -0x8(%rbp),%esi
add    $0x1,%esi
mov    -0x50(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
cltd
idivl  -0x8(%rbp)
mov    -0x80(%rbp),%rdx
mov    %eax,%ecx
add    $0x1,%ecx
call   1070 <filter_interp8@plt>
mov    -0x20(%rbp),%eax
sub    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1389 <read_compressed_array+0x219>
mov    -0x10(%rbp),%rdi
lea    -0x54(%rbp),%rsi
call   1080 <vlq_read_short@plt>
cmp    $0x0,%eax
jne    1336 <read_compressed_array+0x1c6>
movl   $0x0,-0x4(%rbp)
jmp    1598 <read_compressed_array+0x428>
movswl -0x42(%rbp),%ecx
movswl -0x54(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x54(%rbp)
mov    -0x54(%rbp),%ax
mov    %ax,-0x42(%rbp)
movsd  -0x38(%rbp),%xmm0
movswl -0x54(%rbp),%eax
cvtsi2sd %eax,%xmm1
mulsd  -0x40(%rbp),%xmm1
movsd  0xc9a(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1308 <read_compressed_array+0x198>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
jmp    1545 <read_compressed_array+0x3d5>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1478 <read_compressed_array+0x308>
mov    -0x10(%rbp),%rdi
lea    -0x5a(%rbp),%rsi
call   1080 <vlq_read_short@plt>
cmp    $0x0,%eax
jne    13cc <read_compressed_array+0x25c>
movl   $0x0,-0x4(%rbp)
jmp    1598 <read_compressed_array+0x428>
movswl -0x42(%rbp),%ecx
movswl -0x5a(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x5a(%rbp)
mov    -0x5a(%rbp),%ax
mov    %ax,-0x42(%rbp)
movswl -0x5a(%rbp),%eax
cvtsi2sd %eax,%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  0xc09(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x20(%rbp),%ecx
add    -0x58(%rbp),%ecx
xor    %eax,%eax
cmp    -0x1c(%rbp),%ecx
mov    %al,-0x81(%rbp)
jge    142d <read_compressed_array+0x2bd>
mov    -0x58(%rbp),%eax
cmp    -0x8(%rbp),%eax
setl   %al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
test   $0x1,%al
jne    1440 <read_compressed_array+0x2d0>
jmp    1465 <read_compressed_array+0x2f5>
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1407 <read_compressed_array+0x297>
jmp    146a <read_compressed_array+0x2fa>
mov    -0x8(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    139e <read_compressed_array+0x22e>
mov    -0x20(%rbp),%eax
sub    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14fc <read_compressed_array+0x38c>
mov    -0x10(%rbp),%rdi
lea    -0x6a(%rbp),%rsi
call   1080 <vlq_read_short@plt>
cmp    $0x0,%eax
jne    14b2 <read_compressed_array+0x342>
movl   $0x0,-0x4(%rbp)
jmp    1598 <read_compressed_array+0x428>
movswl -0x42(%rbp),%ecx
movswl -0x6a(%rbp),%eax
add    %ecx,%eax
mov    %ax,-0x6a(%rbp)
mov    -0x6a(%rbp),%ax
mov    %ax,-0x42(%rbp)
movswl -0x6a(%rbp),%eax
cvtsi2sd %eax,%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  0xb23(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1484 <read_compressed_array+0x314>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1090 <filter_reduce8@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1540 <read_compressed_array+0x3d0>
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    150f <read_compressed_array+0x39f>
jmp    1545 <read_compressed_array+0x3d5>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1591 <read_compressed_array+0x421>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    157e <read_compressed_array+0x40e>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1583 <read_compressed_array+0x413>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    154c <read_compressed_array+0x3dc>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<read_compressed_array>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %ecx,%ebx
mov    %rdx,%r15
mov    %rsi,%r13
mov    %edi,%r12d
lea    0x56(%rsp),%rdi
mov    $0xa,%esi
mov    %r13,%rdx
call   1050 <IO_Read_Str@plt>
xor    %r14d,%r14d
test   %eax,%eax
je     1744 <read_compressed_array+0x5d4>
mov    %rbx,0x10(%rsp)
lea    0x56(%rsp),%rbp
mov    %rbp,%rdi
call   1040 <ConvertFromIeeeExtended@plt>
movapd %xmm0,0x40(%rsp)
mov    %rbp,%rdi
mov    $0xa,%esi
mov    %r13,%rdx
call   1050 <IO_Read_Str@plt>
test   %eax,%eax
je     1744 <read_compressed_array+0x5d4>
lea    0x56(%rsp),%rdi
call   1040 <ConvertFromIeeeExtended@plt>
movsd  %xmm0,0x28(%rsp)
mov    0x10(%rsp),%rbp
lea    -0x1(%rbp),%eax
cltd
idiv   %r12d
cmp    $0x7,%eax
mov    %r12d,0xc(%rsp)
jle    128b <read_compressed_array+0x11b>
mov    %eax,%r14d
lea    0x1(%r14),%ebx
lea    0x0(,%rbx,8),%edi
call   1060 <malloc@plt>
mov    %rax,0x20(%rsp)
test   %ebp,%ebp
mov    %rbx,0x30(%rsp)
mov    %r13,%r12
jle    14c3 <read_compressed_array+0x353>
xor    %r13d,%r13d
xor    %ebx,%ebx
mov    %r12,%rdi
lea    0xa(%rsp),%rsi
call   1080 <vlq_read_short@plt>
test   %eax,%eax
je     162b <read_compressed_array+0x4bb>
add    0xa(%rsp),%bx
movswl %bx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x28(%rsp),%xmm0
divsd  0xd9e(%rip),%xmm0
addsd  0x40(%rsp),%xmm0
mov    %r13d,%eax
cltd
mov    0xc(%rsp),%ecx
idiv   %ecx
cltq
mov    0x20(%rsp),%rdx
movsd  %xmm0,(%rdx,%rax,8)
add    %ecx,%r13d
cmp    %ebp,%r13d
jl     1230 <read_compressed_array+0xc0>
jmp    14c8 <read_compressed_array+0x358>
test   %ebp,%ebp
jle    157e <read_compressed_array+0x40e>
mov    %r13,0x38(%rsp)
movslq %r12d,%r14
mov    %ebp,%r13d
lea    -0x1(%r14),%rax
mov    %rax,0x68(%rsp)
lea    0x70(%r15),%rbx
lea    0x0(,%r14,8),%rax
mov    %rax,0x60(%rsp)
mov    %r15,0x18(%rsp)
lea    0x10(%r15),%r9
mov    $0x1,%ecx
mov    $0xffffffffffffffff,%rdx
xor    %ebp,%ebp
xor    %r12d,%r12d
xor    %r8d,%r8d
jmp    1313 <read_compressed_array+0x1a3>
nopw   0x0(%rax,%rax,1)
add    %r14,%r12
mov    0x70(%rsp),%rbp
add    $0x1,%rbp
mov    0x60(%rsp),%rax
add    %rax,%rbx
mov    0x80(%rsp),%rcx
add    %r14,%rcx
mov    0x78(%rsp),%rdx
sub    %r14,%rdx
add    %rax,%r9
cmp    %r13,%r12
jge    1586 <read_compressed_array+0x416>
mov    %r9,0x30(%rsp)
mov    %r8d,0x20(%rsp)
cmp    %r13,%rcx
mov    %r13,%r15
mov    %rcx,0x80(%rsp)
cmovg  %rcx,%r15
mov    %rdx,0x78(%rsp)
add    %rdx,%r15
mov    0x68(%rsp),%rcx
cmp    %rcx,%r15
cmovae %rcx,%r15
lea    0x1(%r12),%rax
cmp    %r13,%rax
cmovle %r13,%rax
mov    %rbp,0x70(%rsp)
imul   %r14,%rbp
not    %rbp
add    %rax,%rbp
cmp    %rcx,%rbp
cmovae %rcx,%rbp
mov    0x38(%rsp),%rdi
lea    0xa(%rsp),%rsi
call   1080 <vlq_read_short@plt>
test   %eax,%eax
je     162b <read_compressed_array+0x4bb>
mov    0x20(%rsp),%r8d
add    0xa(%rsp),%r8w
movswl %r8w,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x28(%rsp),%xmm0
divsd  0xc60(%rip),%xmm0
cmpl   $0x0,0xc(%rsp)
mov    0x30(%rsp),%r9
jle    12e0 <read_compressed_array+0x170>
lea    0x1(%rbp),%rax
cmp    $0x4,%rax
jae    13d0 <read_compressed_array+0x260>
xor    %ecx,%ecx
mov    %r12,%rax
jmp    1491 <read_compressed_array+0x321>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xfffffffffffffffd,%r15
shr    $0x2,%r15
add    $0xfffffffffffffffd,%rbp
mov    %rbp,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmp    $0xc,%rbp
jae    13f9 <read_compressed_array+0x289>
xor    %esi,%esi
jmp    1449 <read_compressed_array+0x2d9>
lea    0x1(%r15),%rcx
and    $0xfffffffffffffffc,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd %xmm1,-0x70(%rbx,%rsi,8)
movupd %xmm1,-0x60(%rbx,%rsi,8)
movupd %xmm1,-0x50(%rbx,%rsi,8)
movupd %xmm1,-0x40(%rbx,%rsi,8)
movupd %xmm1,-0x30(%rbx,%rsi,8)
movupd %xmm1,-0x20(%rbx,%rsi,8)
movupd %xmm1,-0x10(%rbx,%rsi,8)
movupd %xmm1,(%rbx,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rcx
jne    1410 <read_compressed_array+0x2a0>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
test   $0x3,%dl
je     1484 <read_compressed_array+0x314>
add    $0x1,%r15b
movzbl %r15b,%edx
and    $0x3,%edx
shl    $0x5,%rdx
lea    (%r9,%rsi,8),%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd %xmm1,-0x10(%rsi,%rdi,1)
movupd %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1470 <read_compressed_array+0x300>
cmp    %rcx,%rax
je     12e0 <read_compressed_array+0x170>
lea    (%r12,%rcx,1),%rax
add    $0x1,%rcx
mov    0x18(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xchg   %ax,%ax
movsd  %xmm0,(%rax)
cmp    %r14,%rcx
jge    12e0 <read_compressed_array+0x170>
lea    (%r12,%rcx,1),%rdx
add    $0x1,%rcx
add    $0x8,%rax
cmp    %r13,%rdx
jl     14a0 <read_compressed_array+0x330>
jmp    12e0 <read_compressed_array+0x170>
xor    %ebx,%ebx
xor    %r13d,%r13d
imul   0xc(%rsp),%r14d
add    $0x1,%r14d
mov    %r15,0x18(%rsp)
mov    %r15,%rdi
mov    %r14d,%esi
mov    0x20(%rsp),%rdx
mov    0x30(%rsp),%rcx
call   1070 <filter_interp8@plt>
mov    0xc(%rsp),%edx
mov    %r13d,%eax
sub    %edx,%eax
add    $0x1,%eax
cmp    %ebp,%eax
jge    1565 <read_compressed_array+0x3f5>
cltq
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,8),%r15
add    0x10(%rsp),%edx
not    %r13d
add    %edx,%r13d
xor    %ebp,%ebp
lea    0xa(%rsp),%r14
nopl   0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    %r14,%rsi
call   1080 <vlq_read_short@plt>
test   %eax,%eax
je     162b <read_compressed_array+0x4bb>
add    0xa(%rsp),%bx
movswl %bx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x28(%rsp),%xmm0
divsd  0xab0(%rip),%xmm0
addsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %ebp,%r13d
jne    1520 <read_compressed_array+0x3b0>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%rbx
jmp    1719 <read_compressed_array+0x5a9>
xor    %r8d,%r8d
xor    %r12d,%r12d
jmp    1595 <read_compressed_array+0x425>
mov    0x18(%rsp),%r15
mov    0x10(%rsp),%rbp
mov    0x38(%rsp),%r13
mov    %r12d,%eax
mov    0xc(%rsp),%ecx
sub    %ecx,%eax
add    $0x1,%eax
cmp    %ebp,%eax
jge    1604 <read_compressed_array+0x494>
cltq
lea    (%r15,%rax,8),%rbx
add    0x10(%rsp),%ecx
not    %r12d
add    %ecx,%r12d
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    %r8d,%r14d
mov    %r13,%rdi
lea    0xa(%rsp),%rsi
call   1080 <vlq_read_short@plt>
test   %eax,%eax
je     162b <read_compressed_array+0x4bb>
mov    %r14d,%r8d
add    0xa(%rsp),%r8w
movswl %r8w,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x28(%rsp),%xmm0
divsd  0xa0a(%rip),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x1,%rbp
cmp    %ebp,%r12d
jne    15c0 <read_compressed_array+0x450>
mov    %r15,%rdi
mov    0x10(%rsp),%rbx
mov    %ebx,%esi
call   1090 <filter_reduce8@plt>
test   %ebx,%ebx
jle    1633 <read_compressed_array+0x4c3>
mov    %ebx,%eax
cmp    $0x4,%ebx
jae    163e <read_compressed_array+0x4ce>
xor    %ecx,%ecx
movapd 0x40(%rsp),%xmm5
jmp    1700 <read_compressed_array+0x590>
xor    %r14d,%r14d
jmp    1744 <read_compressed_array+0x5d4>
mov    $0x1,%r14d
jmp    1744 <read_compressed_array+0x5d4>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd 0x40(%rsp),%xmm5
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
lea    -0x4(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     16c2 <read_compressed_array+0x552>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
xchg   %ax,%ax
movupd (%r15,%rdx,8),%xmm1
movupd 0x10(%r15,%rdx,8),%xmm2
movupd 0x20(%r15,%rdx,8),%xmm3
movupd 0x30(%r15,%rdx,8),%xmm4
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,(%r15,%rdx,8)
movupd %xmm2,0x10(%r15,%rdx,8)
addpd  %xmm0,%xmm3
addpd  %xmm0,%xmm4
movupd %xmm3,0x20(%r15,%rdx,8)
movupd %xmm4,0x30(%r15,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1670 <read_compressed_array+0x500>
jmp    16c4 <read_compressed_array+0x554>
xor    %edx,%edx
test   $0x1,%sil
je     16ec <read_compressed_array+0x57c>
movupd (%r15,%rdx,8),%xmm1
movupd 0x10(%r15,%rdx,8),%xmm2
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,(%r15,%rdx,8)
movupd %xmm2,0x10(%r15,%rdx,8)
cmp    %rax,%rcx
je     1719 <read_compressed_array+0x5a9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rcx,8),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,(%r15,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1700 <read_compressed_array+0x590>
mov    $0x1,%r14d
test   %ebx,%ebx
jle    1744 <read_compressed_array+0x5d4>
mov    %ebx,%eax
cmp    $0x1,%ebx
jne    1759 <read_compressed_array+0x5e9>
xor    %ecx,%ecx
test   $0x1,%al
je     1744 <read_compressed_array+0x5d4>
xorpd  %xmm0,%xmm0
ucomisd (%r15,%rcx,8),%xmm0
jbe    1744 <read_compressed_array+0x5d4>
movq   $0x0,(%r15,%rcx,8)
mov    %r14d,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
jmp    1779 <read_compressed_array+0x609>
cs nopw 0x0(%rax,%rax,1)
add    $0x2,%rcx
cmp    %rcx,%rdx
je     172c <read_compressed_array+0x5bc>
ucomisd (%r15,%rcx,8),%xmm0
jbe    1789 <read_compressed_array+0x619>
movq   $0x0,(%r15,%rcx,8)
ucomisd 0x8(%r15,%rcx,8),%xmm0
jbe    1770 <read_compressed_array+0x600>
movq   $0x0,0x8(%r15,%rcx,8)
jmp    1770 <read_compressed_array+0x600>

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

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