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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int M_PI;
scalar_t__ drand48();
float fmod(float, int);
int /*<<< orphan*/ free(float *);
scalar_t__ malloc(int);
double pow(float, double);
float sin(double);
float sqrt(int);
int /*<<< orphan*/ srand48(long);
void fractint(int *zp, int minx, int maxx, float dx, float dz, float *interface,
              float Nsin, float ampl, float D, float k0, float b, float seed) {
  int i, j, ndeltx;
  long idum;
  float deltx, *phase, scale, *fract, fact;
  float k0bn, argsin;
  phase = (float *)malloc(Nsin * sizeof(float));
  idum = (long)seed;
  srand48(idum);
  for (j = 0; j < (int)Nsin; j++) {
    phase[j] = (float)drand48();
  }
  deltx = dx * (maxx - minx);
  ndeltx = (maxx - minx) + 1;
  fract = (float *)malloc((ndeltx + 1) * sizeof(float));
  k0 *= 2 * M_PI / deltx;
  for (j = 0; j <= ndeltx; j++)
    fract[j] = 0.0;
  for (i = 0; i < (int)Nsin; i++) {
    k0bn = k0 * pow((double)b, (double)i);
    for (j = 0; j <= ndeltx; j++) {
      argsin = fmod((k0bn * j * dx + phase[i]), 2 * M_PI);
      fract[j] += (float)pow((double)(D - 1), (double)i) * sin((double)argsin);
    }
  }
  scale = ampl * sqrt((2 * D * (2 - D)) / (1.0 - pow((D - 1), (2.0 * Nsin))));
  for (j = 0; j <= ndeltx; j++)
    fract[j] *= scale;
  j = 0;
  for (i = minx; i < maxx; i++) {
    zp[i] = ((int)(((interface[i] + fract[j]) / dz) > 0.0
                       ? ((interface[i] + fract[j]) / dz) + 0.5
                       : ((interface[i] + fract[j]) / dz) - 0.5));
    j++;
    if (((zp[i]) < 0 ? -1.0 : 1.0) < 0)
      zp[i] = 0;
  }
  free(phase);
  free(fract);
  return;
}


x86 assembly (clang, -O0):
<fractint>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movss  %xmm0,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movss  %xmm2,-0x24(%rbp)
movss  %xmm3,-0x28(%rbp)
movss  %xmm4,-0x2c(%rbp)
movss  %xmm5,-0x30(%rbp)
movss  %xmm6,-0x34(%rbp)
movss  %xmm7,-0x38(%rbp)
movss  0xe37(%rip),%xmm0
mulss  -0x24(%rbp),%xmm0
cvttss2si %xmm0,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
cvttss2si -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
call   1070 <srand48@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cvttss2si -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    122c <fractint+0xac>
mov    $0x0,%al
call   10a0 <drand48@plt>
cvtsi2ss %rax,%xmm0
mov    -0x60(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11f5 <fractint+0x75>
movss  -0x14(%rbp),%xmm0
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
cvtsi2ss %eax,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    0x2d7a(%rip),%rax
mov    (%rax),%eax
shl    $0x1,%eax
cvtsi2ss %eax,%xmm0
divss  -0x54(%rbp),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     12b7 <fractint+0x137>
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    128d <fractint+0x10d>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cvttss2si -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    13e2 <fractint+0x262>
movss  -0x30(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtsi2sdl -0x3c(%rbp),%xmm1
call   1080 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     13cf <fractint+0x24f>
movss  -0x78(%rbp),%xmm0
cvtsi2ssl -0x40(%rbp),%xmm1
mulss  %xmm1,%xmm0
movss  -0x14(%rbp),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x2c98(%rip),%rax
mov    (%rax),%edi
shl    $0x1,%edi
call   1040 <fmod@plt>
movss  %xmm0,-0x7c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  0xc98(%rip),%xmm1
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtsi2sdl -0x3c(%rbp),%xmm1
call   1080 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sin@plt>
movaps %xmm0,%xmm2
movss  -0x8c(%rbp),%xmm0
ff
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1315 <fractint+0x195>
jmp    13d4 <fractint+0x254>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12be <fractint+0x13e>
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  0xc11(%rip),%xmm0
mulss  -0x2c(%rbp),%xmm0
movss  0xc04(%rip),%xmm1
subss  -0x2c(%rbp),%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
movss  0xbde(%rip),%xmm1
subss  %xmm1,%xmm0
movss  -0x24(%rbp),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xbdd(%rip),%xmm1
mulsd  %xmm2,%xmm1
call   1080 <pow@plt>
movaps %xmm0,%xmm2
movsd  -0x98(%rbp),%xmm0
ff
movsd  0xbb9(%rip),%xmm1
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1090 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x90(%rbp),%xmm0
ff
mulss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     14b4 <fractint+0x334>
movss  -0x64(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1483 <fractint+0x303>
movl   $0x0,-0x40(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    160b <fractint+0x48b>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1539 <fractint+0x3b9>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xaf8(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
jmp    1570 <fractint+0x3f0>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x40(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
divss  -0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xabc(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
cvttsd2si %xmm0,%edx
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
movsd  0xa85(%rip),%xmm0
movsd  0xa65(%rip),%xmm1
movsd  %xmm1,-0xb0(%rbp)
ff
cmp    $0x0,%eax
movsd  %xmm0,-0xa8(%rbp)
ff
jl     15d4 <fractint+0x454>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    15f8 <fractint+0x478>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    15fd <fractint+0x47d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    14c1 <fractint+0x341>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fractint>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
movss  %xmm7,0x20(%rsp)
movss  %xmm6,0x40(%rsp)
movss  %xmm5,0x14(%rsp)
movss  %xmm4,0xc(%rsp)
movss  %xmm3,0x3c(%rsp)
movss  %xmm2,0x34(%rsp)
mov    %rcx,0x50(%rsp)
movaps %xmm1,0x70(%rsp)
movss  %xmm0,0x10(%rsp)
mov    %edx,%r15d
mov    %esi,%r13d
mov    %rdi,0x48(%rsp)
movss  0xe18(%rip),%xmm0
mulss  %xmm2,%xmm0
cvttss2si %xmm0,%edi
call   1070 <malloc@plt>
mov    %rax,%r12
cvttss2si 0x20(%rsp),%rdi
call   1080 <srand48@plt>
cvttss2si 0x34(%rsp),%r14d
mov    %r14d,%ebp
test   %r14d,%r14d
jle    123e <fractint+0xae>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
call   10b0 <drand48@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,(%r12,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1220 <fractint+0x90>
mov    %rbp,0x60(%rsp)
mov    %r15d,0x30(%rsp)
mov    %r13d,0x2c(%rsp)
sub    %r13d,%r15d
lea    0x8(,%r15,4),%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
mov    0x2d81(%rip),%r13
mov    0x0(%r13),%ebp
mov    %r15,0x18(%rsp)
cmp    $0xffffffff,%r15d
jl     1297 <fractint+0x107>
mov    0x18(%rsp),%rax
add    $0x1,%eax
xor    %ecx,%ecx
test   %eax,%eax
cmovle %ecx,%eax
lea    0x4(,%rax,4),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
test   %r14d,%r14d
mov    0x50(%rsp),%r15
jle    13e6 <fractint+0x256>
mov    0x18(%rsp),%rax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
add    %ebp,%ebp
xorps  %xmm1,%xmm1
cvtsi2ss %ebp,%xmm1
mulss  0x10(%rsp),%xmm0
divss  %xmm0,%xmm1
mulss  0x14(%rsp),%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  %xmm0,0x58(%rsp)
movss  0xd25(%rip),%xmm0
addss  0xc(%rsp),%xmm0
movss  %xmm0,0x38(%rsp)
lea    0x2(%rax),%ebp
xor    %r14d,%r14d
jmp    130f <fractint+0x17f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r14
cmp    0x60(%rsp),%r14
je     13c9 <fractint+0x239>
xorps  %xmm1,%xmm1
cvtsi2sd %r14d,%xmm1
movss  0x40(%rsp),%xmm0
movsd  %xmm1,0x68(%rsp)
call   1090 <pow@plt>
cmpl   $0xffffffff,0x18(%rsp)
movss  0x10(%rsp),%xmm1
jl     1300 <fractint+0x170>
mulsd  0x58(%rsp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x44(%rsp)
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2ss %r15d,%xmm0
mulss  0x44(%rsp),%xmm0
mulss  %xmm1,%xmm0
addss  (%r12,%r14,4),%xmm0
mov    0x0(%r13),%edi
add    %edi,%edi
call   1040 <fmod@plt>
movss  %xmm0,0x20(%rsp)
movss  0x38(%rsp),%xmm0
movsd  0x68(%rsp),%xmm1
call   1090 <pow@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x14(%rsp)
movss  0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <sin@plt>
movss  0x10(%rsp),%xmm1
mulss  0x14(%rsp),%xmm0
addss  (%rbx,%r15,4),%xmm0
movss  %xmm0,(%rbx,%r15,4)
add    $0x1,%r15
cmp    %r15,%rbp
jne    1350 <fractint+0x1c0>
jmp    1300 <fractint+0x170>
mov    0x50(%rsp),%r15
mov    0x30(%rsp),%r14d
mov    0x2c(%rsp),%r13d
movss  0xc(%rsp),%xmm1
movss  0x38(%rsp),%xmm2
jmp    1402 <fractint+0x272>
movss  0xc16(%rip),%xmm2
movss  0xc(%rsp),%xmm1
addss  %xmm1,%xmm2
mov    0x30(%rsp),%r14d
mov    0x2c(%rsp),%r13d
movss  0xbfe(%rip),%xmm0
subss  %xmm1,%xmm0
addss  %xmm1,%xmm1
mulss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  %xmm0,0x20(%rsp)
movss  0x34(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
addsd  %xmm1,%xmm1
movaps %xmm2,%xmm0
call   1090 <pow@plt>
movsd  0xbcc(%rip),%xmm1
subsd  %xmm0,%xmm1
movsd  0x20(%rsp),%xmm0
divsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   10a0 <sqrt@plt>
movslq %r13d,%rax
cmpl   $0xffffffff,0x18(%rsp)
movaps 0x70(%rsp),%xmm9
jl     1559 <fractint+0x3c9>
mulss  0x3c(%rsp),%xmm0
movslq %r14d,%rdx
sub    %rax,%rdx
add    $0x1,%rdx
xor    %ecx,%ecx
test   %rdx,%rdx
cmovle %rcx,%rdx
cmp    $0x7,%rdx
jb     152f <fractint+0x39f>
add    $0x1,%rdx
movabs $0x7ffffffffffffff8,%rcx
ff ff 7f
and    %rdx,%rcx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rcx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     16d8 <fractint+0x548>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%rbx,%rsi,4),%xmm2
movups 0x10(%rbx,%rsi,4),%xmm3
movups 0x20(%rbx,%rsi,4),%xmm4
movups 0x30(%rbx,%rsi,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rsi,4)
movups %xmm3,0x10(%rbx,%rsi,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,0x20(%rbx,%rsi,4)
movups %xmm5,0x30(%rbx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    14d0 <fractint+0x340>
test   $0x1,%bpl
je     152a <fractint+0x39a>
movups (%rbx,%rsi,4),%xmm2
movups 0x10(%rbx,%rsi,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%rbx,%rsi,4)
movups %xmm3,0x10(%rbx,%rsi,4)
cmp    %rcx,%rdx
je     1559 <fractint+0x3c9>
movslq 0x18(%rsp),%rdx
add    $0xffffffffffffffff,%rcx
nopl   0x0(%rax,%rax,1)
movss  0x4(%rbx,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rdx,%rcx
jle    1540 <fractint+0x3b0>
cmp    %r13d,%r14d
jle    16b7 <fractint+0x527>
mov    0x18(%rsp),%rcx
mov    %ecx,%r10d
xor    %r9d,%r9d
cmp    $0x4,%ecx
jae    157c <fractint+0x3ec>
xor    %esi,%esi
mov    %rax,%r8
jmp    1656 <fractint+0x4c6>
mov    %r10d,%esi
and    $0xfffffffc,%esi
lea    (%rsi,%rax,1),%r8
movaps %xmm9,%xmm0
shufps $0x0,%xmm9,%xmm0
lea    (%r15,%rax,4),%rbp
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
xor    %edi,%edi
pxor   %xmm8,%xmm8
movdqa 0xa75(%rip),%xmm2
movdqa 0xa7d(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%rbp,%rdi,4),%xmm4
movups (%rbx,%rdi,4),%xmm5
addps  %xmm4,%xmm5
divps  %xmm0,%xmm5
cvtps2pd %xmm5,%xmm4
xorps  %xmm6,%xmm6
cmpltps %xmm5,%xmm6
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
movaps %xmm6,%xmm7
unpckhpd %xmm6,%xmm7
xorpd  %xmm1,%xmm1
pcmpgtd %xmm7,%xmm1
punpckldq %xmm1,%xmm7
pxor   %xmm1,%xmm1
pcmpgtd %xmm6,%xmm1
punpckldq %xmm1,%xmm6
movdqa %xmm3,%xmm1
pand   %xmm6,%xmm1
pandn  %xmm2,%xmm6
por    %xmm1,%xmm6
addpd  %xmm4,%xmm6
movdqa %xmm3,%xmm1
pand   %xmm7,%xmm1
pandn  %xmm2,%xmm7
por    %xmm1,%xmm7
addpd  %xmm5,%xmm7
cvttpd2dq %xmm6,%xmm1
cvttpd2dq %xmm7,%xmm4
unpcklpd %xmm4,%xmm1
movapd %xmm1,%xmm4
pcmpgtd %xmm8,%xmm4
pand   %xmm1,%xmm4
movdqu %xmm4,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    15c0 <fractint+0x430>
cmp    %r10,%rsi
je     16b7 <fractint+0x527>
lea    (%rbx,%rsi,4),%rax
sub    %rsi,%r10
lea    (%r15,%r8,4),%rsi
mov    0x48(%rsp),%rcx
lea    (%rcx,%r8,4),%rdi
xorps  %xmm0,%xmm0
lea    0x9cc(%rip),%rbp
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movss  (%rsi,%rdx,4),%xmm1
addss  (%rax,%rdx,4),%xmm1
divss  %xmm9,%xmm1
xor    %ecx,%ecx
ucomiss %xmm0,%xmm1
seta   %cl
cvtss2sd %xmm1,%xmm1
addsd  0x0(%rbp,%rcx,8),%xmm1
cvttsd2si %xmm1,%ecx
test   %ecx,%ecx
cmovs  %r9d,%ecx
mov    %ecx,(%rdi,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r10
jne    1680 <fractint+0x4f0>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %esi,%esi
test   $0x1,%bpl
jne    1512 <fractint+0x382>
jmp    152a <fractint+0x39a>

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

LLVM IR (-O2):
@M_PI = global i32 0
define void @fractint(i32* nocapture writeonly %0, i32 %1, i32 %2, float %3, float %4, float* nocapture %5, float %6, float %7, float %8, float %9, float %10, float %11) {
%13 = fmul float %6, 4.000000e+00
%14 = fptosi float %13 to i32
%15 = tail call i64 @malloc(i32 %14)
%16 = inttoptr i64 %15 to float*
%17 = fptosi float %11 to i64
%18 = tail call i32 @srand48(i64 %17)
%19 = fptosi float %6 to i32
%20 = icmp sgt i32 %19, 0
br i1 %20, label %21, label %30
21: ; preds = %12
%22 = zext i32 %19 to i64
br label %23
23: ; preds = %21, %23
%24 = phi i64 [ 0, %21 ], [ %28, %23 ]
%25 = tail call i64 (...) @drand48()
%26 = sitofp i64 %25 to float
%27 = getelementptr inbounds float, float* %16, i64 %24
store float %26, float* %27
%28 = add nuw nsw i64 %24, 1
%29 = icmp eq i64 %28, %22
br i1 %29, label %30, label %23
30: ; preds = %23, %12
%31 = sub nsw i32 %2, %1
%32 = sitofp i32 %31 to float
%33 = fmul float %32, %3
%34 = shl i32 %31, 2
%35 = add i32 %34, 8
%36 = tail call i64 @malloc(i32 %35)
%37 = inttoptr i64 %36 to float*
%38 = load i32, i32* @M_PI
%39 = shl nsw i32 %38, 1
%40 = sitofp i32 %39 to float
%41 = fdiv float %40, %33
%42 = fmul float %41, %9
%43 = icmp slt i32 %31, -1
br i1 %43, label %52, label %44
44: ; preds = %30
%45 = inttoptr i64 %36 to i8*
%46 = add i32 %2, 1
%47 = sub i32 %46, %1
%48 = call i32 @llvm.smax.i32(i32 %47, i32 0)
%49 = zext i32 %48 to i64
%50 = shl nuw nsw i64 %49, 2
%51 = add nuw nsw i64 %50, 4
br label %52
52: ; preds = %44, %30
br i1 %20, label %55, label %53
53: ; preds = %52
%54 = fadd float %8, -1.000000e+00
br label %93
55: ; preds = %52
%56 = fpext float %42 to double
%57 = fadd float %8, -1.000000e+00
%58 = add i32 %2, 2
%59 = sub i32 %58, %1
%60 = zext i32 %19 to i64
%61 = zext i32 %59 to i64
br label %62
62: ; preds = %55, %90
%63 = phi i64 [ 0, %55 ], [ %91, %90 ]
%64 = trunc i64 %63 to i32
%65 = sitofp i32 %64 to double
%66 = tail call double @pow(float %10, double %65)
%67 = fmul double %66, %56
%68 = fptrunc double %67 to float
br i1 %43, label %90, label %69
69: ; preds = %62
%70 = getelementptr inbounds float, float* %16, i64 %63
br label %71
71: ; preds = %69, %71
%72 = phi i64 [ 0, %69 ], [ %88, %71 ]
%73 = trunc i64 %72 to i32
%74 = sitofp i32 %73 to float
%75 = fmul float %68, %74
%76 = load float, float* %70
%77 = tail call float @llvm.fmuladd.f32(float %75, float %3, float %76)
%78 = load i32, i32* @M_PI
%79 = shl nsw i32 %78, 1
%80 = tail call float @fmod(float %77, i32 %79)
%81 = tail call double @pow(float %57, double %65)
%82 = fptrunc double %81 to float
%83 = fpext float %80 to double
%84 = tail call float @sin(double %83)
%85 = getelementptr inbounds float, float* %37, i64 %72
%86 = load float, float* %85
%87 = tail call float @llvm.fmuladd.f32(float %82, float %84, float %86)
store float %87, float* %85
%88 = add nuw nsw i64 %72, 1
%89 = icmp eq i64 %88, %61
br i1 %89, label %90, label %71
90: ; preds = %71, %62
%91 = add nuw nsw i64 %63, 1
%92 = icmp eq i64 %91, %60
br i1 %92, label %93, label %62
93: ; preds = %90, %53
%94 = phi float [ %54, %53 ], [ %57, %90 ]
%95 = fmul float %8, 2.000000e+00
%96 = fsub float 2.000000e+00, %8
%97 = fmul float %95, %96
%98 = fpext float %97 to double
%99 = fpext float %6 to double
%100 = fmul double %99, 2.000000e+00
%101 = tail call double @pow(float %94, double %100)
%102 = fsub double 1.000000e+00, %101
%103 = fdiv double %98, %102
%104 = fptosi double %103 to i32
%105 = tail call float @sqrt(i32 %104)
%106 = fmul float %105, %7
br i1 %43, label %174, label %107
107: ; preds = %93
%108 = sext i32 %31 to i64
%109 = sext i32 %2 to i64
%110 = add nsw i64 %109, 1
%111 = sext i32 %1 to i64
%112 = sub nsw i64 %110, %111
%113 = call i64 @llvm.smax.i64(i64 %112, i64 0)
%114 = add nuw nsw i64 %113, 1
%115 = icmp ult i64 %113, 7
br i1 %115, label %172, label %116
116: ; preds = %107
%117 = and i64 %114, 9223372036854775800
%118 = insertelement <4 x float> poison, float %106, i64 0
%119 = shufflevector <4 x float> %118, <4 x float> poison, <4 x i32> zeroinitializer
%120 = insertelement <4 x float> poison, float %106, i64 0
%121 = shufflevector <4 x float> %120, <4 x float> poison, <4 x i32> zeroinitializer
%122 = add nsw i64 %117, -8
%123 = lshr exact i64 %122, 3
%124 = add nuw nsw i64 %123, 1
%125 = and i64 %124, 1
%126 = icmp eq i64 %122, 0
br i1 %126, label %156, label %127
127: ; preds = %116
%128 = and i64 %124, 4611686018427387902
br label %129
129: ; preds = %129, %127
%130 = phi i64 [ 0, %127 ], [ %153, %129 ]
%131 = phi i64 [ 0, %127 ], [ %154, %129 ]
%132 = getelementptr inbounds float, float* %37, i64 %130
%133 = bitcast float* %132 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = getelementptr inbounds float, float* %132, i64 4
%136 = bitcast float* %135 to <4 x float>*
%137 = load <4 x float>, <4 x float>* %136
%138 = fmul <4 x float> %119, %134
%139 = fmul <4 x float> %121, %137
%140 = bitcast float* %132 to <4 x float>*
store <4 x float> %138, <4 x float>* %140
%141 = bitcast float* %135 to <4 x float>*
store <4 x float> %139, <4 x float>* %141
%142 = or i64 %130, 8
%143 = getelementptr inbounds float, float* %37, i64 %142
%144 = bitcast float* %143 to <4 x float>*
%145 = load <4 x float>, <4 x float>* %144
%146 = getelementptr inbounds float, float* %143, i64 4
%147 = bitcast float* %146 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = fmul <4 x float> %119, %145
%150 = fmul <4 x float> %121, %148
%151 = bitcast float* %143 to <4 x float>*
store <4 x float> %149, <4 x float>* %151
%152 = bitcast float* %146 to <4 x float>*
store <4 x float> %150, <4 x float>* %152
%153 = add nuw i64 %130, 16
%154 = add i64 %131, 2
%155 = icmp eq i64 %154, %128
br i1 %155, label %156, label %129
156: ; preds = %129, %116
%157 = phi i64 [ 0, %116 ], [ %153, %129 ]
%158 = icmp eq i64 %125, 0
br i1 %158, label %170, label %159
159: ; preds = %156
%160 = getelementptr inbounds float, float* %37, i64 %157
%161 = bitcast float* %160 to <4 x float>*
%162 = load <4 x float>, <4 x float>* %161
%163 = getelementptr inbounds float, float* %160, i64 4
%164 = bitcast float* %163 to <4 x float>*
%165 = load <4 x float>, <4 x float>* %164
%166 = fmul <4 x float> %119, %162
%167 = fmul <4 x float> %121, %165
%168 = bitcast float* %160 to <4 x float>*
store <4 x float> %166, <4 x float>* %168
%169 = bitcast float* %163 to <4 x float>*
store <4 x float> %167, <4 x float>* %169
br label %170
170: ; preds = %156, %159
%171 = icmp eq i64 %114, %117
br i1 %171, label %174, label %172
172: ; preds = %107, %170
%173 = phi i64 [ 0, %107 ], [ %117, %170 ]
br label %212
174: ; preds = %212, %170, %93
%175 = icmp sgt i32 %2, %1
br i1 %175, label %176, label %239
176: ; preds = %174
%177 = sext i32 %1 to i64
%178 = zext i32 %31 to i64
%179 = icmp ult i32 %31, 4
br i1 %179, label %209, label %180
180: ; preds = %176
%181 = and i64 %178, 4294967292
%182 = add nsw i64 %181, %177
%183 = insertelement <4 x float> poison, float %4, i64 0
%184 = shufflevector <4 x float> %183, <4 x float> poison, <4 x i32> zeroinitializer
br label %185
185: ; preds = %185, %180
%186 = phi i64 [ 0, %180 ], [ %205, %185 ]
%187 = add i64 %186, %177
%188 = getelementptr inbounds float, float* %5, i64 %187
%189 = bitcast float* %188 to <4 x float>*
%190 = load <4 x float>, <4 x float>* %189
%191 = getelementptr inbounds float, float* %37, i64 %186
%192 = bitcast float* %191 to <4 x float>*
%193 = load <4 x float>, <4 x float>* %192
%194 = fadd <4 x float> %190, %193
%195 = fdiv <4 x float> %194, %184
%196 = fpext <4 x float> %195 to <4 x double>
%197 = fcmp ogt <4 x float> %195, zeroinitializer
%198 = select <4 x i1> %197, <4 x double> <double 5.000000e-01, double 5.000000e-01, double 5.000000e-01, double 5.000000e-01>, <4 x double> <double -5.000000e-01, double -5.000000e-01, double -5.000000e-01, double -5.000000e-01>
%199 = fadd <4 x double> %198, %196
%200 = fptosi <4 x double> %199 to <4 x i32>
%201 = getelementptr inbounds i32, i32* %0, i64 %187
%202 = icmp sgt <4 x i32> %200, zeroinitializer
%203 = select <4 x i1> %202, <4 x i32> %200, <4 x i32> zeroinitializer
%204 = bitcast i32* %201 to <4 x i32>*
store <4 x i32> %203, <4 x i32>* %204
%205 = add nuw i64 %186, 4
%206 = icmp eq i64 %205, %181
br i1 %206, label %207, label %185
207: ; preds = %185
%208 = icmp eq i64 %181, %178
br i1 %208, label %239, label %209
209: ; preds = %176, %207
%210 = phi i64 [ 0, %176 ], [ %181, %207 ]
%211 = phi i64 [ %177, %176 ], [ %182, %207 ]
br label %219
212: ; preds = %172, %212
%213 = phi i64 [ %217, %212 ], [ %173, %172 ]
%214 = getelementptr inbounds float, float* %37, i64 %213
%215 = load float, float* %214
%216 = fmul float %106, %215
store float %216, float* %214
%217 = add nuw nsw i64 %213, 1
%218 = icmp sgt i64 %213, %108
br i1 %218, label %174, label %212
219: ; preds = %209, %219
%220 = phi i64 [ %234, %219 ], [ %210, %209 ]
%221 = phi i64 [ %237, %219 ], [ %211, %209 ]
%222 = getelementptr inbounds float, float* %5, i64 %221
%223 = load float, float* %222
%224 = getelementptr inbounds float, float* %37, i64 %220
%225 = load float, float* %224
%226 = fadd float %223, %225
%227 = fdiv float %226, %4
%228 = fpext float %227 to double
%229 = fcmp ogt float %227, 0.000000e+00
%230 = select i1 %229, double 5.000000e-01, double -5.000000e-01
%231 = fadd double %230, %228
%232 = fptosi double %231 to i32
%233 = getelementptr inbounds i32, i32* %0, i64 %221
%234 = add nuw nsw i64 %220, 1
%235 = icmp sgt i32 %232, 0
%236 = select i1 %235, i32 %232, i32 0
store i32 %236, i32* %233
%237 = add nsw i64 %221, 1
%238 = icmp eq i64 %234, %178
br i1 %238, label %239, label %219
239: ; preds = %219, %207, %174
%240 = tail call i32 @free(float* %16)
%241 = tail call i32 @free(float* %37)
ret void
}