#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 */
double Int_Power(double, int);
int /*<<< orphan*/ fatal_error(char *, char *);
int /*<<< orphan*/ flist2bitstream(float *, unsigned char *, unsigned int, int);
double floor(float);
int /*<<< orphan*/ flt2ieee(double, unsigned char *);
int /*<<< orphan*/ frexp(double, int *);
int /*<<< orphan*/ int2_char(int, unsigned char *);
double ldexp(double, int);
scalar_t__ malloc(size_t);
int /*<<< orphan*/ min_max_array_all_defined(float *, unsigned int, float *,
                                             float *);
int omp_get_num_threads();
int /*<<< orphan*/ uint2_char(int /*<<< orphan*/, unsigned char *);
int /*<<< orphan*/ uint_char(unsigned int, unsigned char *);
int mk_sec5and7(float *data, unsigned int n, unsigned char **sec5,
                unsigned char **sec7, int use_scale, int dec_scale,
                int bin_scale, int wanted_bits, int max_bits) {
  float min_val, max_val, ncep_min_val;
  int nbits, binary_scale, j;
  double ref, frange, scale, dec_factor;
  size_t sec5_size, sec7_size;
  unsigned char *p;
  unsigned int i, k, di;
  int nthreads;
  binary_scale = bin_scale;
  if (n == 0) {
    nbits = 0;
    ref = ncep_min_val = 0.0;
  } else {
    min_max_array_all_defined(data, n, &min_val, &max_val);
    ncep_min_val = min_val;
    if (use_scale == 0) {
      ref = min_val;
      frange = max_val - ref;
      dec_scale = 0;
      if (frange != 0.0) {
        frexp(frange, &j);
        binary_scale = j - wanted_bits;
        nbits = wanted_bits;
        scale = ldexp(1.0, -binary_scale);
        frange = floor((max_val - ref) * scale + 0.5);
        frexp(frange, &j);
        if (j != nbits)
          binary_scale++;
      } else {
        binary_scale = nbits = 0;
        scale = 1;
      }
    } else {
      if (dec_scale) {
        dec_factor = Int_Power(10.0, -dec_scale);
        min_val *= dec_factor;
        max_val *= dec_factor;
#pragma omp parallel for
        for (i = 0; i < n; i++) {
          data[i] *= dec_factor;
        }
      }
      scale = ldexp(1.0, -binary_scale);
      ref = min_val;
      frange = floor((max_val - ref) * scale + 0.5);
      frexp(frange, &nbits);
      if (nbits > max_bits) {
        binary_scale += (nbits - max_bits);
        nbits = max_bits;
      }
    }
    if (binary_scale) {
      scale = ldexp(1.0, -binary_scale);
#pragma omp parallel for
      for (i = 0; i < n; i++) {
        data[i] = (data[i] - ref) * scale;
      }
    } else {
#pragma omp parallel for
      for (i = 0; i < n; i++) {
        data[i] = data[i] - ref;
      }
    }
  }
  sec5_size = 21;
  sec7_size = 5 + (nbits * (n / 8)) + (nbits * (n % 8) + 7) / 8;
  *sec7 = p = (unsigned char *)malloc(sec7_size);
  if (p == NULL)
    fatal_error("mk_sec5and7: memory allocation", "");
  uint_char(sec7_size, p);
  p[4] = 7;
  if (n != 0) {
#pragma omp parallel private(i, k)
    {
#pragma omp single
      {
        nthreads = omp_get_num_threads();
        di = (n + nthreads - 1) / nthreads;
        di = ((di + 7) | 7) ^ 7;
      }
#pragma omp for
      for (i = 0; i < n; i += di) {
        k = n - i;
        if (k > di)
          k = di;
        flist2bitstream(data + i, p + 5 + (i / 8) * nbits, k, nbits);
      }
    }
  }
  if (nbits == 0) {
    dec_scale = binary_scale = 0;
    ref = ncep_min_val;
  }
  *sec5 = p = (unsigned char *)malloc(sec5_size);
  if (p == NULL)
    fatal_error("mk_sec5and7: memory allocation", "");
  uint_char(sec5_size, p);
  p[4] = 5;
  uint_char(n, p + 5);
  uint2_char(0, p + 9);
  flt2ieee(ref, p + 11);
  int2_char(binary_scale, p + 15);
  int2_char(-dec_scale, p + 17);
  p[19] = nbits;
  p[20] = 0;
  return 0;
}


x86 assembly (clang, -O0):
<mk_sec5and7>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0xc(%rbp)
jne    1227 <mk_sec5and7+0x57>
movl   $0x0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1528 <mk_sec5and7+0x358>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
lea    -0x2c(%rbp),%rdx
lea    -0x30(%rbp),%rcx
call   1050 <min_max_array_all_defined@plt>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x34(%rbp)
cmpl   $0x0,-0x24(%rbp)
jne    1341 <mk_sec5and7+0x171>
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x28(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1294 <mk_sec5and7+0xc4>
jp     1294 <mk_sec5and7+0xc4>
jmp    1321 <mk_sec5and7+0x151>
movsd  -0x50(%rbp),%xmm0
lea    -0x40(%rbp),%rdi
call   1090 <frexp@plt>
mov    -0x40(%rbp),%eax
sub    0x18(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x18(%rbp),%eax
mov    %eax,-0x38(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
movsd  0xd52(%rip),%xmm0
call   1040 <ldexp@plt>
movsd  %xmm0,-0x58(%rbp)
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xd21(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   10f0 <floor@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
lea    -0x40(%rbp),%rdi
call   1090 <frexp@plt>
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
je     131c <mk_sec5and7+0x14c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    133c <mk_sec5and7+0x16c>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movsd  0xcd9(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1467 <mk_sec5and7+0x297>
cmpl   $0x0,-0x28(%rbp)
je     13e0 <mk_sec5and7+0x210>
xor    %edi,%edi
sub    -0x28(%rbp),%edi
movsd  0xca8(%rip),%xmm0
call   10a0 <Int_Power@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movsd  -0x60(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    13db <mk_sec5and7+0x20b>
movsd  -0x60(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x7c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    139f <mk_sec5and7+0x1cf>
jmp    13e0 <mk_sec5and7+0x210>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
movsd  0xc23(%rip),%xmm0
call   1040 <ldexp@plt>
movsd  %xmm0,-0x58(%rbp)
movss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xbe4(%rip),%xmm1
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   10f0 <floor@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
lea    -0x38(%rbp),%rdi
call   1090 <frexp@plt>
mov    -0x38(%rbp),%eax
cmp    0x20(%rbp),%eax
jle    1462 <mk_sec5and7+0x292>
mov    -0x38(%rbp),%eax
sub    0x20(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    0x20(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1467 <mk_sec5and7+0x297>
cmpl   $0x0,-0x3c(%rbp)
je     14d8 <mk_sec5and7+0x308>
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
movsd  0xb92(%rip),%xmm0
call   1040 <ldexp@plt>
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    14d3 <mk_sec5and7+0x303>
mov    -0x8(%rbp),%rax
mov    -0x7c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x48(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x7c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    148f <mk_sec5and7+0x2bf>
jmp    1523 <mk_sec5and7+0x353>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    151e <mk_sec5and7+0x34e>
mov    -0x8(%rbp),%rax
mov    -0x7c(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  -0x48(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x7c(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    14df <mk_sec5and7+0x30f>
jmp    1523 <mk_sec5and7+0x353>
jmp    1528 <mk_sec5and7+0x358>
movq   $0x15,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    -0xc(%rbp),%ecx
shr    $0x3,%ecx
imul   %ecx,%eax
add    $0x5,%eax
mov    -0x38(%rbp),%ecx
mov    -0xc(%rbp),%edx
and    $0x7,%edx
imul   %edx,%ecx
add    $0x7,%ecx
shr    $0x3,%ecx
add    %ecx,%eax
mov    %eax,%eax
mov    %rax,-0x70(%rbp)
mov    -0x70(%rbp),%rdi
call   10c0 <malloc@plt>
mov    %rax,%rcx
mov    %rcx,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
cmpq   $0x0,-0x78(%rbp)
jne    158e <mk_sec5and7+0x3be>
lea    0xa96(%rip),%rdi
lea    0xaad(%rip),%rsi
call   10b0 <fatal_error@plt>
mov    -0x70(%rbp),%rax
mov    %eax,%edi
mov    -0x78(%rbp),%rsi
call   1030 <uint_char@plt>
mov    -0x78(%rbp),%rax
movb   $0x7,0x4(%rax)
cmpl   $0x0,-0xc(%rbp)
je     1665 <mk_sec5and7+0x495>
mov    $0x0,%al
call   1080 <omp_get_num_threads@plt>
mov    %eax,-0x88(%rbp)
mov    -0xc(%rbp),%eax
add    -0x88(%rbp),%eax
sub    $0x1,%eax
xor    %edx,%edx
divl   -0x88(%rbp)
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
add    $0x7,%eax
or     $0x7,%eax
xor    $0x7,%eax
mov    %eax,-0x84(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jae    1660 <mk_sec5and7+0x490>
mov    -0xc(%rbp),%eax
sub    -0x7c(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x84(%rbp),%eax
jbe    161f <mk_sec5and7+0x44f>
mov    -0x84(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x7c(%rbp),%eax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x78(%rbp),%rsi
add    $0x5,%rsi
mov    -0x7c(%rbp),%eax
shr    $0x3,%eax
imul   -0x38(%rbp),%eax
mov    %eax,%eax
add    %rax,%rsi
mov    -0x80(%rbp),%edx
mov    -0x38(%rbp),%ecx
call   1070 <flist2bitstream@plt>
mov    -0x84(%rbp),%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
jmp    15f2 <mk_sec5and7+0x422>
jmp    1665 <mk_sec5and7+0x495>
cmpl   $0x0,-0x38(%rbp)
jne    168b <mk_sec5and7+0x4bb>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x28(%rbp)
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x68(%rbp),%rdi
call   10c0 <malloc@plt>
mov    %rax,%rcx
mov    %rcx,-0x78(%rbp)
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
cmpq   $0x0,-0x78(%rbp)
jne    16c0 <mk_sec5and7+0x4f0>
lea    0x964(%rip),%rdi
lea    0x97b(%rip),%rsi
call   10b0 <fatal_error@plt>
mov    -0x68(%rbp),%rax
mov    %eax,%edi
mov    -0x78(%rbp),%rsi
call   1030 <uint_char@plt>
mov    -0x78(%rbp),%rax
movb   $0x5,0x4(%rax)
mov    -0xc(%rbp),%edi
mov    -0x78(%rbp),%rsi
add    $0x5,%rsi
call   1030 <uint_char@plt>
mov    -0x78(%rbp),%rsi
add    $0x9,%rsi
xor    %edi,%edi
call   1060 <uint2_char@plt>
movsd  -0x48(%rbp),%xmm0
mov    -0x78(%rbp),%rdi
add    $0xb,%rdi
call   10e0 <flt2ieee@plt>
mov    -0x3c(%rbp),%edi
mov    -0x78(%rbp),%rsi
add    $0xf,%rsi
call   10d0 <int2_char@plt>
xor    %edi,%edi
sub    -0x28(%rbp),%edi
mov    -0x78(%rbp),%rsi
add    $0x11,%rsi
call   10d0 <int2_char@plt>
mov    -0x38(%rbp),%eax
mov    %al,%cl
mov    -0x78(%rbp),%rax
mov    %cl,0x13(%rax)
mov    -0x78(%rbp),%rax
movb   $0x0,0x14(%rax)
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mk_sec5and7>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,%r13d
mov    %rdx,%rbp
mov    %esi,%r12d
mov    %rdi,%rbx
mov    0x80(%rsp),%r14d
test   %esi,%esi
mov    %rdx,0x40(%rsp)
je     1298 <mk_sec5and7+0xc8>
mov    %r8d,%r15d
mov    %rcx,0x38(%rsp)
lea    0x10(%rsp),%rdx
lea    0x8(%rsp),%rcx
mov    %rbx,%rdi
mov    %r12d,%esi
call   1050 <min_max_array_all_defined@plt>
movss  0x10(%rsp),%xmm0
test   %r15d,%r15d
movss  %xmm0,0x18(%rsp)
je     12c9 <mk_sec5and7+0xf9>
mov    0x90(%rsp),%r15d
test   %r13d,%r13d
je     14af <mk_sec5and7+0x2df>
mov    %r13d,%edi
neg    %edi
movsd  0xdb1(%rip),%xmm0
call   10a0 <Int_Power@plt>
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  0x8(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm1,0x10(%rsp)
movss  %xmm2,0x8(%rsp)
mov    %r12d,%eax
cmp    $0x8,%r12d
jae    1372 <mk_sec5and7+0x1a2>
xor    %ecx,%ecx
jmp    1490 <mk_sec5and7+0x2c0>
mov    %r14d,0xc(%rsp)
mov    %rcx,%r14
mov    %r13d,0x14(%rsp)
movl   $0x0,0x4(%rsp)
xorpd  %xmm0,%xmm0
movss  %xmm0,0x18(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x20(%rsp)
xor    %r15d,%r15d
jmp    18a7 <mk_sec5and7+0x6d7>
cvtss2sd %xmm0,%xmm5
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm5,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12eb <mk_sec5and7+0x11b>
jnp    1708 <mk_sec5and7+0x538>
mov    0x88(%rsp),%r15d
lea    0x1c(%rsp),%r14
mov    %r14,%rdi
movaps %xmm5,0x20(%rsp)
call   1090 <frexp@plt>
mov    0x1c(%rsp),%ebp
sub    %r15d,%ebp
mov    %r15d,0x4(%rsp)
mov    %ebp,%edi
neg    %edi
movsd  0xceb(%rip),%xmm0
call   1040 <ldexp@plt>
movss  0x8(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  0x20(%rsp),%xmm1
mulsd  %xmm0,%xmm1
addsd  0xcd2(%rip),%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
call   10f0 <floor@plt>
mov    %r14,%rdi
call   1090 <frexp@plt>
xor    %r14d,%r14d
cmp    %r15d,0x1c(%rsp)
setne  %r14b
add    %ebp,%r14d
xor    %r13d,%r13d
test   %r14d,%r14d
jne    151c <mk_sec5and7+0x34c>
jmp    155f <mk_sec5and7+0x38f>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1a3d <mk_sec5and7+0x86d>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cvtps2pd 0x8(%rbx,%rdx,4),%xmm2
cvtps2pd (%rbx,%rdx,4),%xmm3
cvtps2pd 0x18(%rbx,%rdx,4),%xmm4
cvtps2pd 0x10(%rbx,%rdx,4),%xmm5
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm4
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm2,%xmm3
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movupd %xmm3,(%rbx,%rdx,4)
movupd %xmm2,0x10(%rbx,%rdx,4)
cvtps2pd 0x28(%rbx,%rdx,4),%xmm2
cvtps2pd 0x20(%rbx,%rdx,4),%xmm3
cvtps2pd 0x38(%rbx,%rdx,4),%xmm4
cvtps2pd 0x30(%rbx,%rdx,4),%xmm5
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm4
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm2,%xmm3
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movupd %xmm3,0x20(%rbx,%rdx,4)
movupd %xmm2,0x30(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    13a0 <mk_sec5and7+0x1d0>
test   $0x1,%sil
je     1488 <mk_sec5and7+0x2b8>
cvtps2pd 0x8(%rbx,%rdx,4),%xmm2
cvtps2pd (%rbx,%rdx,4),%xmm3
cvtps2pd 0x18(%rbx,%rdx,4),%xmm4
cvtps2pd 0x10(%rbx,%rdx,4),%xmm5
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm4
cvtpd2ps %xmm2,%xmm1
cvtpd2ps %xmm3,%xmm2
cvtpd2ps %xmm4,%xmm3
cvtpd2ps %xmm5,%xmm4
unpcklpd %xmm1,%xmm2
unpcklpd %xmm3,%xmm4
movupd %xmm2,(%rbx,%rdx,4)
movupd %xmm4,0x10(%rbx,%rdx,4)
cmp    %rax,%rcx
je     14af <mk_sec5and7+0x2df>
nopl   (%rax)
movss  (%rbx,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1490 <mk_sec5and7+0x2c0>
mov    %r14d,%edi
neg    %edi
movsd  0xb4c(%rip),%xmm0
call   1040 <ldexp@plt>
movss  0x10(%rsp),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
movss  0x8(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movaps %xmm2,0x20(%rsp)
subsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm1
addsd  0xb23(%rip),%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
call   10f0 <floor@plt>
lea    0x4(%rsp),%rdi
call   1090 <frexp@plt>
mov    0x4(%rsp),%eax
cmp    %r15d,%eax
jle    1557 <mk_sec5and7+0x387>
sub    %r15d,%r14d
add    %eax,%r14d
mov    %r15d,0x4(%rsp)
test   %r14d,%r14d
je     155f <mk_sec5and7+0x38f>
mov    %r14d,%edi
neg    %edi
movsd  0xadf(%rip),%xmm0
call   1040 <ldexp@plt>
cmp    $0x2,%r12d
mov    $0x1,%eax
cmovae %r12d,%eax
cmp    $0x8,%eax
mov    %r13d,0x14(%rsp)
mov    %r14d,0xc(%rsp)
jae    1569 <mk_sec5and7+0x399>
xor    %ecx,%ecx
movapd 0x20(%rsp),%xmm7
jmp    16d1 <mk_sec5and7+0x501>
mov    %eax,%r15d
test   %r14d,%r14d
jne    151c <mk_sec5and7+0x34c>
movaps 0x20(%rsp),%xmm5
jmp    1716 <mk_sec5and7+0x546>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movapd 0x20(%rsp),%xmm7
movapd %xmm7,%xmm2
unpcklpd %xmm7,%xmm2
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1a1b <mk_sec5and7+0x84b>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
cvtps2pd (%rbx,%rdx,4),%xmm3
cvtps2pd 0x8(%rbx,%rdx,4),%xmm4
cvtps2pd 0x10(%rbx,%rdx,4),%xmm5
cvtps2pd 0x18(%rbx,%rdx,4),%xmm6
subpd  %xmm2,%xmm4
subpd  %xmm2,%xmm3
subpd  %xmm2,%xmm6
subpd  %xmm2,%xmm5
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm6
cvtpd2ps %xmm4,%xmm4
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm6,%xmm6
unpcklpd %xmm4,%xmm3
cvtpd2ps %xmm5,%xmm4
unpcklpd %xmm6,%xmm4
movupd %xmm3,(%rbx,%rdx,4)
movupd %xmm4,0x10(%rbx,%rdx,4)
cvtps2pd 0x20(%rbx,%rdx,4),%xmm3
cvtps2pd 0x28(%rbx,%rdx,4),%xmm4
cvtps2pd 0x30(%rbx,%rdx,4),%xmm5
cvtps2pd 0x38(%rbx,%rdx,4),%xmm6
subpd  %xmm2,%xmm4
subpd  %xmm2,%xmm3
subpd  %xmm2,%xmm6
subpd  %xmm2,%xmm5
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm6
cvtpd2ps %xmm4,%xmm4
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm6,%xmm6
unpcklpd %xmm4,%xmm3
cvtpd2ps %xmm5,%xmm4
unpcklpd %xmm6,%xmm4
movupd %xmm3,0x20(%rbx,%rdx,4)
movupd %xmm4,0x30(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    15b0 <mk_sec5and7+0x3e0>
test   $0x1,%sil
je     16c8 <mk_sec5and7+0x4f8>
cvtps2pd (%rbx,%rdx,4),%xmm3
cvtps2pd 0x8(%rbx,%rdx,4),%xmm4
cvtps2pd 0x10(%rbx,%rdx,4),%xmm5
cvtps2pd 0x18(%rbx,%rdx,4),%xmm6
subpd  %xmm2,%xmm4
subpd  %xmm2,%xmm3
subpd  %xmm2,%xmm6
subpd  %xmm2,%xmm5
mulpd  %xmm1,%xmm3
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
mulpd  %xmm1,%xmm6
cvtpd2ps %xmm4,%xmm1
cvtpd2ps %xmm3,%xmm2
cvtpd2ps %xmm6,%xmm3
cvtpd2ps %xmm5,%xmm4
unpcklpd %xmm1,%xmm2
unpcklpd %xmm3,%xmm4
movupd %xmm2,(%rbx,%rdx,4)
movupd %xmm4,0x10(%rbx,%rdx,4)
cmp    %rax,%rcx
je     1865 <mk_sec5and7+0x695>
mov    0x38(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
subsd  %xmm7,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    16e0 <mk_sec5and7+0x510>
jmp    18a7 <mk_sec5and7+0x6d7>
movl   $0x0,0x4(%rsp)
xor    %r13d,%r13d
xor    %r15d,%r15d
cmp    $0x2,%r12d
mov    $0x1,%eax
cmovae %r12d,%eax
cmp    $0x8,%eax
mov    %r13d,0x14(%rsp)
movaps %xmm5,0x20(%rsp)
jae    1739 <mk_sec5and7+0x569>
xor    %ecx,%ecx
jmp    186c <mk_sec5and7+0x69c>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1a2c <mk_sec5and7+0x85c>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
cvtps2pd 0x8(%rbx,%rdx,4),%xmm1
cvtps2pd (%rbx,%rdx,4),%xmm2
cvtps2pd 0x18(%rbx,%rdx,4),%xmm3
cvtps2pd 0x10(%rbx,%rdx,4),%xmm4
subpd  %xmm0,%xmm2
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm4
subpd  %xmm0,%xmm3
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm1,%xmm2
cvtpd2ps %xmm4,%xmm1
unpcklpd %xmm3,%xmm1
movupd %xmm2,(%rbx,%rdx,4)
movupd %xmm1,0x10(%rbx,%rdx,4)
cvtps2pd 0x28(%rbx,%rdx,4),%xmm1
cvtps2pd 0x20(%rbx,%rdx,4),%xmm2
cvtps2pd 0x38(%rbx,%rdx,4),%xmm3
cvtps2pd 0x30(%rbx,%rdx,4),%xmm4
subpd  %xmm0,%xmm2
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm4
subpd  %xmm0,%xmm3
cvtpd2ps %xmm1,%xmm1
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
unpcklpd %xmm1,%xmm2
cvtpd2ps %xmm4,%xmm1
unpcklpd %xmm3,%xmm1
movupd %xmm2,0x20(%rbx,%rdx,4)
movupd %xmm1,0x30(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1770 <mk_sec5and7+0x5a0>
test   $0x1,%sil
je     1858 <mk_sec5and7+0x688>
cvtps2pd 0x8(%rbx,%rdx,4),%xmm1
cvtps2pd (%rbx,%rdx,4),%xmm2
cvtps2pd 0x18(%rbx,%rdx,4),%xmm3
cvtps2pd 0x10(%rbx,%rdx,4),%xmm4
subpd  %xmm0,%xmm2
subpd  %xmm0,%xmm1
subpd  %xmm0,%xmm4
subpd  %xmm0,%xmm3
cvtpd2ps %xmm1,%xmm0
cvtpd2ps %xmm2,%xmm1
cvtpd2ps %xmm3,%xmm2
cvtpd2ps %xmm4,%xmm3
unpcklpd %xmm0,%xmm1
unpcklpd %xmm2,%xmm3
movupd %xmm1,(%rbx,%rdx,4)
movupd %xmm3,0x10(%rbx,%rdx,4)
cmp    %rax,%rcx
jne    186c <mk_sec5and7+0x69c>
movl   $0x0,0xc(%rsp)
mov    0x38(%rsp),%r14
jmp    18a7 <mk_sec5and7+0x6d7>
mov    0x38(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm5,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1880 <mk_sec5and7+0x6b0>
movl   $0x0,0xc(%rsp)
mov    %r12d,%eax
shr    $0x3,%eax
imul   %r15d,%eax
mov    %r12d,%ecx
and    $0x7,%ecx
imul   %r15d,%ecx
add    $0x7,%ecx
shr    $0x3,%ecx
lea    (%rax,%rcx,1),%ebp
add    $0x5,%ebp
mov    %rbp,%rdi
call   10c0 <malloc@plt>
mov    %rax,%r13
mov    %rax,(%r14)
test   %rax,%rax
jne    18ed <mk_sec5and7+0x71d>
lea    0x737(%rip),%rdi
lea    0x74e(%rip),%rsi
call   10b0 <fatal_error@plt>
mov    %ebp,%edi
mov    %r13,%rsi
call   1030 <uint_char@plt>
movb   $0x7,0x4(%r13)
test   %r12d,%r12d
je     195e <mk_sec5and7+0x78e>
xor    %ebp,%ebp
xor    %eax,%eax
call   1080 <omp_get_num_threads@plt>
mov    %eax,%ecx
lea    (%r12,%rcx,1),%eax
add    $0xffffffff,%eax
xor    %edx,%edx
div    %ecx
mov    %eax,%r14d
add    $0x7,%r14d
and    $0xfffffff8,%r14d
add    $0x5,%r13
cs nopw 0x0(%rax,%rax,1)
mov    %r12d,%edx
sub    %ebp,%edx
cmp    %r14d,%edx
cmova  %r14d,%edx
mov    %ebp,%eax
lea    (%rbx,%rax,4),%rdi
mov    %ebp,%esi
shr    $0x3,%esi
imul   %r15d,%esi
add    %r13,%rsi
mov    %r15d,%ecx
call   1070 <flist2bitstream@plt>
add    %r14d,%ebp
cmp    %r12d,%ebp
jb     1930 <mk_sec5and7+0x760>
mov    $0x15,%edi
call   10c0 <malloc@plt>
mov    %rax,%rbx
mov    0x40(%rsp),%rax
mov    %rbx,(%rax)
test   %rbx,%rbx
jne    198b <mk_sec5and7+0x7bb>
lea    0x699(%rip),%rdi
lea    0x6b0(%rip),%rsi
call   10b0 <fatal_error@plt>
test   %r15d,%r15d
mov    0x14(%rsp),%ebp
cmove  %r15d,%ebp
mov    0xc(%rsp),%r14d
cmove  %r15d,%r14d
jne    19b0 <mk_sec5and7+0x7e0>
movss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps %xmm0,0x20(%rsp)
mov    $0x15,%edi
mov    %rbx,%rsi
call   1030 <uint_char@plt>
movb   $0x5,0x4(%rbx)
lea    0x5(%rbx),%rsi
mov    %r12d,%edi
call   1030 <uint_char@plt>
lea    0x9(%rbx),%rsi
xor    %edi,%edi
call   1060 <uint2_char@plt>
lea    0xb(%rbx),%rdi
movaps 0x20(%rsp),%xmm0
call   10e0 <flt2ieee@plt>
lea    0xf(%rbx),%rsi
mov    %r14d,%edi
call   10d0 <int2_char@plt>
neg    %ebp
mov    %rbx,%rsi
add    $0x11,%rsi
mov    %ebp,%edi
call   10d0 <int2_char@plt>
mov    %r15b,0x13(%rbx)
movb   $0x0,0x14(%rbx)
xor    %eax,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%sil
jne    1672 <mk_sec5and7+0x4a2>
jmp    16c8 <mk_sec5and7+0x4f8>
xor    %edx,%edx
test   $0x1,%sil
jne    1812 <mk_sec5and7+0x642>
jmp    1858 <mk_sec5and7+0x688>
xor    %edx,%edx
test   $0x1,%sil
jne    1442 <mk_sec5and7+0x272>
jmp    1488 <mk_sec5and7+0x2b8>

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

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