#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 int32_t;
typedef int int16_t;

/* Variables and functions */
int /*<<< orphan*/ dct32(int *, int *);
int /*<<< orphan*/ memcpy(int *, int *, int);
int round_sample(int *);
void mp3_synth_filter(int16_t *synth_buf_ptr, int *synth_buf_offset,
                      int16_t *window, int *dither_state, int16_t *samples,
                      int incr, int32_t sb_samples[32]) {
  int32_t tmp[32];
  register int16_t *synth_buf;
  register const int16_t *w, *w2, *p;
  int j, offset, v;
  int16_t *samples2;
  int sum, sum2;
  dct32(tmp, sb_samples);
  offset = *synth_buf_offset;
  synth_buf = synth_buf_ptr + offset;
  for (j = 0; j < 32; j++) {
    v = tmp[j];
    if (v > 32767)
      v = 32767;
    else if (v < -32768)
      v = -32768;
    synth_buf[j] = v;
  }
  memcpy(synth_buf + 512, synth_buf, 32 * sizeof(int16_t));
  samples2 = samples + 31 * incr;
  w = window;
  w2 = window + 31;
  sum = *dither_state;
  p = synth_buf + 16;
  {
    sum += (((w)[0 * 64]) * (p[0 * 64]));
    sum += (((w)[1 * 64]) * (p[1 * 64]));
    sum += (((w)[2 * 64]) * (p[2 * 64]));
    sum += (((w)[3 * 64]) * (p[3 * 64]));
    sum += (((w)[4 * 64]) * (p[4 * 64]));
    sum += (((w)[5 * 64]) * (p[5 * 64]));
    sum += (((w)[6 * 64]) * (p[6 * 64]));
    sum += (((w)[7 * 64]) * (p[7 * 64]));
  };
  p = synth_buf + 48;
  {
    sum -= (((w + 32)[0 * 64]) * (p[0 * 64]));
    sum -= (((w + 32)[1 * 64]) * (p[1 * 64]));
    sum -= (((w + 32)[2 * 64]) * (p[2 * 64]));
    sum -= (((w + 32)[3 * 64]) * (p[3 * 64]));
    sum -= (((w + 32)[4 * 64]) * (p[4 * 64]));
    sum -= (((w + 32)[5 * 64]) * (p[5 * 64]));
    sum -= (((w + 32)[6 * 64]) * (p[6 * 64]));
    sum -= (((w + 32)[7 * 64]) * (p[7 * 64]));
  };
  *samples = round_sample(&sum);
  samples += incr;
  w++;
  for (j = 1; j < 16; j++) {
    sum2 = 0;
    p = synth_buf + 16 + j;
    {
      int tmp;
      tmp = p[0 * 64];
      sum += (((w)[0 * 64]) * (tmp));
      sum2 -= (((w2)[0 * 64]) * (tmp));
      tmp = p[1 * 64];
      sum += (((w)[1 * 64]) * (tmp));
      sum2 -= (((w2)[1 * 64]) * (tmp));
      tmp = p[2 * 64];
      sum += (((w)[2 * 64]) * (tmp));
      sum2 -= (((w2)[2 * 64]) * (tmp));
      tmp = p[3 * 64];
      sum += (((w)[3 * 64]) * (tmp));
      sum2 -= (((w2)[3 * 64]) * (tmp));
      tmp = p[4 * 64];
      sum += (((w)[4 * 64]) * (tmp));
      sum2 -= (((w2)[4 * 64]) * (tmp));
      tmp = p[5 * 64];
      sum += (((w)[5 * 64]) * (tmp));
      sum2 -= (((w2)[5 * 64]) * (tmp));
      tmp = p[6 * 64];
      sum += (((w)[6 * 64]) * (tmp));
      sum2 -= (((w2)[6 * 64]) * (tmp));
      tmp = p[7 * 64];
      sum += (((w)[7 * 64]) * (tmp));
      sum2 -= (((w2)[7 * 64]) * (tmp));
    };
    p = synth_buf + 48 - j;
    {
      int tmp;
      tmp = p[0 * 64];
      sum -= (((w + 32)[0 * 64]) * (tmp));
      sum2 -= (((w2 + 32)[0 * 64]) * (tmp));
      tmp = p[1 * 64];
      sum -= (((w + 32)[1 * 64]) * (tmp));
      sum2 -= (((w2 + 32)[1 * 64]) * (tmp));
      tmp = p[2 * 64];
      sum -= (((w + 32)[2 * 64]) * (tmp));
      sum2 -= (((w2 + 32)[2 * 64]) * (tmp));
      tmp = p[3 * 64];
      sum -= (((w + 32)[3 * 64]) * (tmp));
      sum2 -= (((w2 + 32)[3 * 64]) * (tmp));
      tmp = p[4 * 64];
      sum -= (((w + 32)[4 * 64]) * (tmp));
      sum2 -= (((w2 + 32)[4 * 64]) * (tmp));
      tmp = p[5 * 64];
      sum -= (((w + 32)[5 * 64]) * (tmp));
      sum2 -= (((w2 + 32)[5 * 64]) * (tmp));
      tmp = p[6 * 64];
      sum -= (((w + 32)[6 * 64]) * (tmp));
      sum2 -= (((w2 + 32)[6 * 64]) * (tmp));
      tmp = p[7 * 64];
      sum -= (((w + 32)[7 * 64]) * (tmp));
      sum2 -= (((w2 + 32)[7 * 64]) * (tmp));
    };
    *samples = round_sample(&sum);
    samples += incr;
    sum += sum2;
    *samples2 = round_sample(&sum);
    samples2 -= incr;
    w++;
    w2--;
  }
  p = synth_buf + 32;
  {
    sum -= (((w + 32)[0 * 64]) * (p[0 * 64]));
    sum -= (((w + 32)[1 * 64]) * (p[1 * 64]));
    sum -= (((w + 32)[2 * 64]) * (p[2 * 64]));
    sum -= (((w + 32)[3 * 64]) * (p[3 * 64]));
    sum -= (((w + 32)[4 * 64]) * (p[4 * 64]));
    sum -= (((w + 32)[5 * 64]) * (p[5 * 64]));
    sum -= (((w + 32)[6 * 64]) * (p[6 * 64]));
    sum -= (((w + 32)[7 * 64]) * (p[7 * 64]));
  };
  *samples = round_sample(&sum);
  *dither_state = sum;
  offset = (offset - 32) & 511;
  *synth_buf_offset = offset;
}


x86 assembly (clang, -O0):
<mp3_synth_filter>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
lea    -0xb0(%rbp),%rdi
mov    0x10(%rbp),%rsi
call   1050 <dct32@plt>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x8(%rbp),%rax
movslq -0xd8(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0xd4(%rbp)
cmpl   $0x20,-0xd4(%rbp)
jge    1220 <mp3_synth_filter+0xf0>
movslq -0xd4(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%eax
mov    %eax,-0xdc(%rbp)
cmpl   $0x7fff,-0xdc(%rbp)
jle    11d6 <mp3_synth_filter+0xa6>
movl   $0x7fff,-0xdc(%rbp)
jmp    11f5 <mp3_synth_filter+0xc5>
cmpl   $0xffff8000,-0xdc(%rbp)
80 ff ff
jge    11f0 <mp3_synth_filter+0xc0>
movl   $0xffff8000,-0xdc(%rbp)
80 ff ff
jmp    11f5 <mp3_synth_filter+0xc5>
mov    -0xdc(%rbp),%edx
mov    -0xb8(%rbp),%rax
movslq -0xd4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1196 <mp3_synth_filter+0x66>
mov    -0xb8(%rbp),%rdi
add    $0x800,%rdi
mov    -0xb8(%rbp),%rsi
mov    $0x80,%edx
call   1040 <memcpy@plt>
mov    -0x28(%rbp),%rax
imul   $0x1f,-0x2c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x18(%rbp),%rax
add    $0x7c,%rax
mov    %rax,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xec(%rbp)
mov    -0xb8(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc0(%rbp),%rax
mov    (%rax),%eax
mov    -0xd0(%rbp),%rcx
imul   (%rcx),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x100(%rax),%eax
mov    -0xd0(%rbp),%rcx
imul   0x100(%rcx),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x200(%rax),%eax
mov    -0xd0(%rbp),%rcx
imul   0x200(%rcx),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x300(%rax),%eax
mov    -0xd0(%rbp),%rcx
imul   0x300(%rcx),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x400(%rax),%eax
mov    -0xd0(%rbp),%rcx
imul   0x400(%rcx),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x500(%rax),%eax
mov    -0xd0(%rbp),%rcx
imul   0x500(%rcx),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x600(%rax),%eax
mov    -0xd0(%rbp),%rcx
imul   0x600(%rcx),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x700(%rax),%eax
mov    -0xd0(%rbp),%rcx
imul   0x700(%rcx),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xb8(%rbp),%rax
add    $0xc0,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x80(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   (%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x180(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x100(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x280(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x200(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x380(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x300(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x480(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x400(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x580(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x500(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x680(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x600(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x780(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x700(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
lea    -0xec(%rbp),%rdi
call   1030 <round_sample@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0xc0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xc0(%rbp)
movl   $0x1,-0xd4(%rbp)
cmpl   $0x10,-0xd4(%rbp)
jge    1bb5 <mp3_synth_filter+0xa85>
movl   $0x0,-0xf0(%rbp)
mov    -0xb8(%rbp),%rax
add    $0x40,%rax
movslq -0xd4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xc0(%rbp),%rax
mov    (%rax),%eax
imul   -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    (%rax),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x100(%rax),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x100(%rax),%eax
imul   -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x100(%rax),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x200(%rax),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x200(%rax),%eax
imul   -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x200(%rax),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x300(%rax),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x300(%rax),%eax
imul   -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x300(%rax),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x400(%rax),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x400(%rax),%eax
imul   -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x400(%rax),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x500(%rax),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x500(%rax),%eax
imul   -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x500(%rax),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x600(%rax),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x600(%rax),%eax
imul   -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x600(%rax),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x700(%rax),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x700(%rax),%eax
imul   -0xf4(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x700(%rax),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xb8(%rbp),%rax
add    $0xc0,%rax
movslq -0xd4(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x80(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x80(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x100(%rax),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x180(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x180(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x200(%rax),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x280(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x280(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x300(%rax),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x380(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x380(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x400(%rax),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x480(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x480(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x500(%rax),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x580(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x580(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x600(%rax),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x680(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x680(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
mov    -0xd0(%rbp),%rax
mov    0x700(%rax),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x780(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc8(%rbp),%rax
mov    0x780(%rax),%ecx
imul   -0xf8(%rbp),%ecx
mov    -0xf0(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xf0(%rbp)
lea    -0xec(%rbp),%rdi
call   1030 <round_sample@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0xf0(%rbp),%eax
add    -0xec(%rbp),%eax
mov    %eax,-0xec(%rbp)
lea    -0xec(%rbp),%rdi
call   1030 <round_sample@plt>
mov    %eax,%ecx
mov    -0xe8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0xe8(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xc0(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc8(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0xc8(%rbp)
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    155d <mp3_synth_filter+0x42d>
mov    -0xb8(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0xd0(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x80(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   (%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x180(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x100(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x280(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x200(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x380(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x300(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x480(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x400(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x580(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x500(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x680(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x600(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xc0(%rbp),%rax
mov    0x780(%rax),%ecx
mov    -0xd0(%rbp),%rax
imul   0x700(%rax),%ecx
mov    -0xec(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xec(%rbp)
lea    -0xec(%rbp),%rdi
call   1030 <round_sample@plt>
mov    %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xec(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xd8(%rbp),%eax
sub    $0x20,%eax
and    $0x1ff,%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mp3_synth_filter>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %r9d,%r13d
mov    %r8,%r15
mov    %rcx,%r12
mov    %rdx,%rbx
mov    %rsi,%rbp
mov    %rdi,%r14
mov    0x130(%rsp),%rsi
lea    0x70(%rsp),%rdi
call   1050 <dct32@plt>
mov    %rbp,0x50(%rsp)
movslq 0x0(%rbp),%rbp
lea    (%r14,%rbp,4),%rsi
movdqa 0x70(%rsp),%xmm1
movdqa 0xe80(%rip),%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movdqa 0xe74(%rip),%xmm1
movdqa %xmm1,%xmm3
pcmpgtd %xmm2,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm1,%xmm3
por    %xmm2,%xmm3
movdqu %xmm3,(%r14,%rbp,4)
movdqa 0x80(%rsp),%xmm2
movdqa %xmm2,%xmm3
pcmpgtd %xmm0,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqu %xmm2,0x10(%r14,%rbp,4)
movdqa 0x90(%rsp),%xmm2
movdqa %xmm2,%xmm3
pcmpgtd %xmm0,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqu %xmm2,0x20(%r14,%rbp,4)
movdqa 0xa0(%rsp),%xmm2
movdqa %xmm2,%xmm3
pcmpgtd %xmm0,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqu %xmm2,0x30(%r14,%rbp,4)
movdqa 0xb0(%rsp),%xmm2
movdqa %xmm2,%xmm3
pcmpgtd %xmm0,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqu %xmm2,0x40(%r14,%rbp,4)
movdqa 0xc0(%rsp),%xmm2
movdqa %xmm2,%xmm3
pcmpgtd %xmm0,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqu %xmm2,0x50(%r14,%rbp,4)
movdqa 0xd0(%rsp),%xmm2
movdqa %xmm2,%xmm3
pcmpgtd %xmm0,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqu %xmm2,0x60(%r14,%rbp,4)
movdqa 0xe0(%rsp),%xmm2
movdqa %xmm2,%xmm3
pcmpgtd %xmm0,%xmm3
pand   %xmm3,%xmm2
pandn  %xmm0,%xmm3
por    %xmm2,%xmm3
movdqa %xmm1,%xmm0
pcmpgtd %xmm3,%xmm0
pand   %xmm0,%xmm3
pandn  %xmm1,%xmm0
por    %xmm3,%xmm0
movdqu %xmm0,0x70(%r14,%rbp,4)
lea    (%r14,%rbp,4),%rdi
add    $0x800,%rdi
mov    %rsi,0x28(%rsp)
mov    $0x80,%edx
call   1040 <memcpy@plt>
mov    %r13d,%eax
shl    $0x5,%eax
sub    %r13d,%eax
cltq
mov    0x40(%r14,%rbp,4),%ecx
imul   (%rbx),%ecx
mov    0xc0(%r14,%rbp,4),%edx
mov    %r12,0x48(%rsp)
add    (%r12),%ecx
mov    0x140(%r14,%rbp,4),%esi
imul   0x100(%rbx),%esi
add    %ecx,%esi
mov    0x240(%r14,%rbp,4),%ecx
imul   0x200(%rbx),%ecx
add    %esi,%ecx
mov    0x340(%r14,%rbp,4),%esi
imul   0x300(%rbx),%esi
add    %ecx,%esi
mov    0x440(%r14,%rbp,4),%ecx
imul   0x400(%rbx),%ecx
add    %esi,%ecx
mov    0x540(%r14,%rbp,4),%esi
imul   0x500(%rbx),%esi
add    %ecx,%esi
mov    0x640(%r14,%rbp,4),%edi
imul   0x600(%rbx),%edi
add    %esi,%edi
mov    0x740(%r14,%rbp,4),%ecx
imul   0x700(%rbx),%ecx
imul   0x80(%rbx),%edx
add    %edi,%ecx
mov    0x1c0(%r14,%rbp,4),%esi
imul   0x180(%rbx),%esi
add    %edx,%esi
mov    0x2c0(%r14,%rbp,4),%edx
imul   0x280(%rbx),%edx
add    %esi,%edx
mov    0x3c0(%r14,%rbp,4),%esi
imul   0x380(%rbx),%esi
add    %edx,%esi
mov    0x4c0(%r14,%rbp,4),%edx
imul   0x480(%rbx),%edx
add    %esi,%edx
mov    0x5c0(%r14,%rbp,4),%esi
imul   0x580(%rbx),%esi
add    %edx,%esi
mov    0x6c0(%r14,%rbp,4),%edx
imul   0x680(%rbx),%edx
lea    (%r15,%rax,4),%rax
mov    %rax,0x38(%rsp)
mov    %rbp,0x40(%rsp)
mov    0x7c0(%r14,%rbp,4),%eax
mov    %rbx,0x30(%rsp)
imul   0x780(%rbx),%eax
add    %esi,%edx
add    %edx,%eax
sub    %eax,%ecx
mov    %ecx,0x8(%rsp)
lea    0x8(%rsp),%rdi
call   1030 <round_sample@plt>
mov    %eax,(%r15)
movslq %r13d,%rax
lea    (%r15,%rax,4),%r15
shl    $0x2,%rax
mov    %rax,0x60(%rsp)
neg    %rax
mov    %rax,0x58(%rsp)
mov    $0x784,%r12d
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
mov    %r15,0x68(%rsp)
mov    0x28(%rsp),%r11
mov    -0x740(%r11,%r12,1),%ecx
ff
mov    %ecx,0x24(%rsp)
mov    0x30(%rsp),%rbp
mov    -0x780(%rbp,%r12,1),%eax
ff
imul   %ecx,%eax
add    0x8(%rsp),%eax
mov    -0x640(%r11,%r12,1),%edx
ff
mov    %edx,0x20(%rsp)
mov    -0x680(%rbp,%r12,1),%ecx
ff
imul   %edx,%ecx
add    %eax,%ecx
mov    -0x540(%r11,%r12,1),%edx
ff
mov    %edx,0x1c(%rsp)
mov    -0x580(%rbp,%r12,1),%eax
ff
imul   %edx,%eax
add    %ecx,%eax
mov    -0x440(%r11,%r12,1),%r15d
ff
mov    -0x480(%rbp,%r12,1),%ecx
ff
imul   %r15d,%ecx
add    %eax,%ecx
mov    -0x340(%r11,%r12,1),%edx
ff
mov    %edx,0x18(%rsp)
mov    -0x380(%rbp,%r12,1),%eax
ff
imul   %edx,%eax
add    %ecx,%eax
mov    -0x240(%r11,%r12,1),%edx
ff
mov    %edx,0x14(%rsp)
mov    -0x280(%rbp,%r12,1),%ecx
ff
imul   %edx,%ecx
add    %eax,%ecx
mov    -0x140(%r11,%r12,1),%edx
ff
mov    %edx,0x10(%rsp)
mov    -0x180(%rbp,%r12,1),%eax
ff
imul   %edx,%eax
add    %ecx,%eax
mov    -0x40(%r11,%r12,1),%r9d
mov    -0x80(%rbp,%r12,1),%ecx
imul   %r9d,%ecx
add    %eax,%ecx
mov    %ecx,0xc(%rsp)
mov    0xbc(%r11,%r14,1),%edi
mov    0x1bc(%r11,%r14,1),%r10d
mov    -0x700(%rbp,%r12,1),%eax
ff
imul   %edi,%eax
mov    -0x600(%rbp,%r12,1),%ecx
ff
imul   %r10d,%ecx
add    %eax,%ecx
mov    0x2bc(%r11,%r14,1),%r8d
mov    -0x500(%rbp,%r12,1),%eax
ff
imul   %r8d,%eax
add    %ecx,%eax
mov    0x3bc(%r11,%r14,1),%esi
mov    -0x400(%rbp,%r12,1),%ebx
ff
imul   %esi,%ebx
add    %eax,%ebx
mov    0x4bc(%r11,%r14,1),%edx
mov    -0x300(%rbp,%r12,1),%eax
ff
imul   %edx,%eax
add    %ebx,%eax
mov    0x5bc(%r11,%r14,1),%r13d
mov    -0x200(%rbp,%r12,1),%ebx
ff
imul   %r13d,%ebx
add    %eax,%ebx
mov    0x6bc(%r11,%r14,1),%ecx
mov    -0x100(%rbp,%r12,1),%eax
ff
imul   %ecx,%eax
add    %ebx,%eax
mov    0x7bc(%r11,%r14,1),%ebx
mov    0x0(%rbp,%r12,1),%r11d
imul   %ebx,%r11d
add    %eax,%r11d
sub    %r11d,0xc(%rsp)
mov    0x24(%rsp),%r11d
imul   0x7c(%rbp,%r14,1),%r11d
mov    0x20(%rsp),%eax
imul   0x17c(%rbp,%r14,1),%eax
add    %r11d,%eax
mov    %eax,%r11d
mov    0x1c(%rsp),%eax
imul   0x27c(%rbp,%r14,1),%eax
add    %r11d,%eax
mov    %r15d,%r11d
imul   0x37c(%rbp,%r14,1),%r11d
mov    0x18(%rsp),%r15d
imul   0x47c(%rbp,%r14,1),%r15d
add    %eax,%r11d
add    %r11d,%r15d
mov    0x14(%rsp),%eax
imul   0x57c(%rbp,%r14,1),%eax
add    %r15d,%eax
mov    %eax,%r11d
mov    0x10(%rsp),%eax
imul   0x67c(%rbp,%r14,1),%eax
add    %r11d,%eax
imul   0x77c(%rbp,%r14,1),%r9d
imul   0xfc(%rbp,%r14,1),%edi
add    %eax,%r9d
add    %r9d,%edi
imul   0x1fc(%rbp,%r14,1),%r10d
add    %edi,%r10d
mov    0x68(%rsp),%r15
imul   0x2fc(%rbp,%r14,1),%r8d
add    %r10d,%r8d
imul   0x3fc(%rbp,%r14,1),%esi
imul   0x4fc(%rbp,%r14,1),%edx
add    %r8d,%esi
add    %esi,%edx
imul   0x5fc(%rbp,%r14,1),%r13d
add    %edx,%r13d
imul   0x6fc(%rbp,%r14,1),%ecx
add    %r13d,%ecx
mov    0xc(%rsp),%eax
mov    %eax,0x8(%rsp)
imul   0x7fc(%rbp,%r14,1),%ebx
add    %ecx,%ebx
lea    0x8(%rsp),%rbp
mov    %rbp,%rdi
call   1030 <round_sample@plt>
mov    %eax,(%r15)
sub    %ebx,0x8(%rsp)
mov    %rbp,%rdi
call   1030 <round_sample@plt>
mov    0x38(%rsp),%rcx
mov    %eax,(%rcx)
add    $0xfffffffffffffffc,%r14
add    $0x4,%r12
add    0x60(%rsp),%r15
add    0x58(%rsp),%rcx
mov    %rcx,0x38(%rsp)
cmp    $0xffffffffffffffc4,%r14
jne    14c0 <mp3_synth_filter+0x390>
mov    0x28(%rsp),%rsi
mov    0x80(%rsi),%eax
mov    0x180(%rsi),%ecx
mov    0x30(%rsp),%rdx
imul   -0x700(%rdx,%r12,1),%eax
ff ff
imul   -0x600(%rdx,%r12,1),%ecx
ff ff
add    %eax,%ecx
mov    0x280(%rsi),%eax
imul   -0x500(%rdx,%r12,1),%eax
ff ff
add    %ecx,%eax
mov    0x380(%rsi),%ecx
imul   -0x400(%rdx,%r12,1),%ecx
ff ff
add    %eax,%ecx
mov    0x480(%rsi),%eax
imul   -0x300(%rdx,%r12,1),%eax
ff ff
add    %ecx,%eax
mov    0x580(%rsi),%ecx
imul   -0x200(%rdx,%r12,1),%ecx
ff ff
add    %eax,%ecx
mov    0x680(%rsi),%eax
imul   -0x100(%rdx,%r12,1),%eax
ff ff
add    %ecx,%eax
mov    0x780(%rsi),%ecx
imul   (%rdx,%r12,1),%ecx
add    %eax,%ecx
sub    %ecx,0x8(%rsp)
lea    0x8(%rsp),%rdi
call   1030 <round_sample@plt>
mov    %eax,(%r15)
mov    0x8(%rsp),%eax
mov    0x48(%rsp),%rcx
mov    %eax,(%rcx)
mov    0x40(%rsp),%rax
add    $0x1e0,%eax
and    $0x1ff,%eax
mov    0x50(%rsp),%rcx
mov    %eax,(%rcx)
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @mp3_synth_filter(i32* %0, i32* %1, i32* %2, i32* %3, i32* %4, i32 %5, i32* %6) {
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i32*
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i32
%14 = alloca i32*
%15 = alloca [32 x i32]
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32*
%19 = alloca i32*
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32*
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
store i32* %0, i32** %8
store i32* %1, i32** %9
store i32* %2, i32** %10
store i32* %3, i32** %11
store i32* %4, i32** %12
store i32 %5, i32* %13
store i32* %6, i32** %14
%28 = getelementptr inbounds [32 x i32], [32 x i32]* %15, i64 0, i64 0
%29 = load i32*, i32** %14
%30 = call i32 @dct32(i32* %28, i32* %29)
%31 = load i32*, i32** %9
%32 = load i32, i32* %31
store i32 %32, i32* %21
%33 = load i32*, i32** %8
%34 = load i32, i32* %21
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i32, i32* %33, i64 %35
store i32* %36, i32** %16
store i32 0, i32* %20
br label %37
37: ; preds = %59, %7
%38 = load i32, i32* %20
%39 = icmp slt i32 %38, 32
br i1 %39, label %40, label %62
40: ; preds = %37
%41 = load i32, i32* %20
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [32 x i32], [32 x i32]* %15, i64 0, i64 %42
%44 = load i32, i32* %43
store i32 %44, i32* %22
%45 = load i32, i32* %22
%46 = icmp sgt i32 %45, 32767
br i1 %46, label %47, label %48
47: ; preds = %40
store i32 32767, i32* %22
br label %53
48: ; preds = %40
%49 = load i32, i32* %22
%50 = icmp slt i32 %49, -32768
br i1 %50, label %51, label %52
51: ; preds = %48
store i32 -32768, i32* %22
br label %52
52: ; preds = %51, %48
br label %53
53: ; preds = %52, %47
%54 = load i32, i32* %22
%55 = load i32*, i32** %16
%56 = load i32, i32* %20
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
store i32 %54, i32* %58
br label %59
59: ; preds = %53
%60 = load i32, i32* %20
%61 = add nsw i32 %60, 1
store i32 %61, i32* %20
br label %37
62: ; preds = %37
%63 = load i32*, i32** %16
%64 = getelementptr inbounds i32, i32* %63, i64 512
%65 = load i32*, i32** %16
%66 = call i32 @memcpy(i32* %64, i32* %65, i32 128)
%67 = load i32*, i32** %12
%68 = load i32, i32* %13
%69 = mul nsw i32 31, %68
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i32, i32* %67, i64 %70
store i32* %71, i32** %23
%72 = load i32*, i32** %10
store i32* %72, i32** %17
%73 = load i32*, i32** %10
%74 = getelementptr inbounds i32, i32* %73, i64 31
store i32* %74, i32** %18
%75 = load i32*, i32** %11
%76 = load i32, i32* %75
store i32 %76, i32* %24
%77 = load i32*, i32** %16
%78 = getelementptr inbounds i32, i32* %77, i64 16
store i32* %78, i32** %19
%79 = load i32*, i32** %17
%80 = getelementptr inbounds i32, i32* %79, i64 0
%81 = load i32, i32* %80
%82 = load i32*, i32** %19
%83 = getelementptr inbounds i32, i32* %82, i64 0
%84 = load i32, i32* %83
%85 = mul nsw i32 %81, %84
%86 = load i32, i32* %24
%87 = add nsw i32 %86, %85
store i32 %87, i32* %24
%88 = load i32*, i32** %17
%89 = getelementptr inbounds i32, i32* %88, i64 64
%90 = load i32, i32* %89
%91 = load i32*, i32** %19
%92 = getelementptr inbounds i32, i32* %91, i64 64
%93 = load i32, i32* %92
%94 = mul nsw i32 %90, %93
%95 = load i32, i32* %24
%96 = add nsw i32 %95, %94
store i32 %96, i32* %24
%97 = load i32*, i32** %17
%98 = getelementptr inbounds i32, i32* %97, i64 128
%99 = load i32, i32* %98
%100 = load i32*, i32** %19
%101 = getelementptr inbounds i32, i32* %100, i64 128
%102 = load i32, i32* %101
%103 = mul nsw i32 %99, %102
%104 = load i32, i32* %24
%105 = add nsw i32 %104, %103
store i32 %105, i32* %24
%106 = load i32*, i32** %17
%107 = getelementptr inbounds i32, i32* %106, i64 192
%108 = load i32, i32* %107
%109 = load i32*, i32** %19
%110 = getelementptr inbounds i32, i32* %109, i64 192
%111 = load i32, i32* %110
%112 = mul nsw i32 %108, %111
%113 = load i32, i32* %24
%114 = add nsw i32 %113, %112
store i32 %114, i32* %24
%115 = load i32*, i32** %17
%116 = getelementptr inbounds i32, i32* %115, i64 256
%117 = load i32, i32* %116
%118 = load i32*, i32** %19
%119 = getelementptr inbounds i32, i32* %118, i64 256
%120 = load i32, i32* %119
%121 = mul nsw i32 %117, %120
%122 = load i32, i32* %24
%123 = add nsw i32 %122, %121
store i32 %123, i32* %24
%124 = load i32*, i32** %17
%125 = getelementptr inbounds i32, i32* %124, i64 320
%126 = load i32, i32* %125
%127 = load i32*, i32** %19
%128 = getelementptr inbounds i32, i32* %127, i64 320
%129 = load i32, i32* %128
%130 = mul nsw i32 %126, %129
%131 = load i32, i32* %24
%132 = add nsw i32 %131, %130
store i32 %132, i32* %24
%133 = load i32*, i32** %17
%134 = getelementptr inbounds i32, i32* %133, i64 384
%135 = load i32, i32* %134
%136 = load i32*, i32** %19
%137 = getelementptr inbounds i32, i32* %136, i64 384
%138 = load i32, i32* %137
%139 = mul nsw i32 %135, %138
%140 = load i32, i32* %24
%141 = add nsw i32 %140, %139
store i32 %141, i32* %24
%142 = load i32*, i32** %17
%143 = getelementptr inbounds i32, i32* %142, i64 448
%144 = load i32, i32* %143
%145 = load i32*, i32** %19
%146 = getelementptr inbounds i32, i32* %145, i64 448
%147 = load i32, i32* %146
%148 = mul nsw i32 %144, %147
%149 = load i32, i32* %24
%150 = add nsw i32 %149, %148
store i32 %150, i32* %24
%151 = load i32*, i32** %16
%152 = getelementptr inbounds i32, i32* %151, i64 48
store i32* %152, i32** %19
%153 = load i32*, i32** %17
%154 = getelementptr inbounds i32, i32* %153, i64 32
%155 = getelementptr inbounds i32, i32* %154, i64 0
%156 = load i32, i32* %155
%157 = load i32*, i32** %19
%158 = getelementptr inbounds i32, i32* %157, i64 0
%159 = load i32, i32* %158
%160 = mul nsw i32 %156, %159
%161 = load i32, i32* %24
%162 = sub nsw i32 %161, %160
store i32 %162, i32* %24
%163 = load i32*, i32** %17
%164 = getelementptr inbounds i32, i32* %163, i64 32
%165 = getelementptr inbounds i32, i32* %164, i64 64
%166 = load i32, i32* %165
%167 = load i32*, i32** %19
%168 = getelementptr inbounds i32, i32* %167, i64 64
%169 = load i32, i32* %168
%170 = mul nsw i32 %166, %169
%171 = load i32, i32* %24
%172 = sub nsw i32 %171, %170
store i32 %172, i32* %24
%173 = load i32*, i32** %17
%174 = getelementptr inbounds i32, i32* %173, i64 32
%175 = getelementptr inbounds i32, i32* %174, i64 128
%176 = load i32, i32* %175
%177 = load i32*, i32** %19
%178 = getelementptr inbounds i32, i32* %177, i64 128
%179 = load i32, i32* %178
%180 = mul nsw i32 %176, %179
%181 = load i32, i32* %24
%182 = sub nsw i32 %181, %180
store i32 %182, i32* %24
%183 = load i32*, i32** %17
%184 = getelementptr inbounds i32, i32* %183, i64 32
%185 = getelementptr inbounds i32, i32* %184, i64 192
%186 = load i32, i32* %185
%187 = load i32*, i32** %19
%188 = getelementptr inbounds i32, i32* %187, i64 192
%189 = load i32, i32* %188
%190 = mul nsw i32 %186, %189
%191 = load i32, i32* %24
%192 = sub nsw i32 %191, %190
store i32 %192, i32* %24
%193 = load i32*, i32** %17
%194 = getelementptr inbounds i32, i32* %193, i64 32
%195 = getelementptr inbounds i32, i32* %194, i64 256
%196 = load i32, i32* %195
%197 = load i32*, i32** %19
%198 = getelementptr inbounds i32, i32* %197, i64 256
%199 = load i32, i32* %198
%200 = mul nsw i32 %196, %199
%201 = load i32, i32* %24
%202 = sub nsw i32 %201, %200
store i32 %202, i32* %24
%203 = load i32*, i32** %17
%204 = getelementptr inbounds i32, i32* %203, i64 32
%205 = getelementptr inbounds i32, i32* %204, i64 320
%206 = load i32, i32* %205
%207 = load i32*, i32** %19
%208 = getelementptr inbounds i32, i32* %207, i64 320
%209 = load i32, i32* %208
%210 = mul nsw i32 %206, %209
%211 = load i32, i32* %24
%212 = sub nsw i32 %211, %210
store i32 %212, i32* %24
%213 = load i32*, i32** %17
%214 = getelementptr inbounds i32, i32* %213, i64 32
%215 = getelementptr inbounds i32, i32* %214, i64 384
%216 = load i32, i32* %215
%217 = load i32*, i32** %19
%218 = getelementptr inbounds i32, i32* %217, i64 384
%219 = load i32, i32* %218
%220 = mul nsw i32 %216, %219
%221 = load i32, i32* %24
%222 = sub nsw i32 %221, %220
store i32 %222, i32* %24
%223 = load i32*, i32** %17
%224 = getelementptr inbounds i32, i32* %223, i64 32
%225 = getelementptr inbounds i32, i32* %224, i64 448
%226 = load i32, i32* %225
%227 = load i32*, i32** %19
%228 = getelementptr inbounds i32, i32* %227, i64 448
%229 = load i32, i32* %228
%230 = mul nsw i32 %226, %229
%231 = load i32, i32* %24
%232 = sub nsw i32 %231, %230
store i32 %232, i32* %24
%233 = call i32 @round_sample(i32* %24)
%234 = load i32*, i32** %12
store i32 %233, i32* %234
%235 = load i32, i32* %13
%236 = load i32*, i32** %12
%237 = sext i32 %235 to i64
%238 = getelementptr inbounds i32, i32* %236, i64 %237
store i32* %238, i32** %12
%239 = load i32*, i32** %17
%240 = getelementptr inbounds i32, i32* %239, i32 1
store i32* %240, i32** %17
store i32 1, i32* %20
br label %241
241: ; preds = %564, %62
%242 = load i32, i32* %20
%243 = icmp slt i32 %242, 16
br i1 %243, label %244, label %567
244: ; preds = %241
store i32 0, i32* %25
%245 = load i32*, i32** %16
%246 = getelementptr inbounds i32, i32* %245, i64 16
%247 = load i32, i32* %20
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i32, i32* %246, i64 %248
store i32* %249, i32** %19
%250 = load i32*, i32** %19
%251 = getelementptr inbounds i32, i32* %250, i64 0
%252 = load i32, i32* %251
store i32 %252, i32* %26
%253 = load i32*, i32** %17
%254 = getelementptr inbounds i32, i32* %253, i64 0
%255 = load i32, i32* %254
%256 = load i32, i32* %26
%257 = mul nsw i32 %255, %256
%258 = load i32, i32* %24
%259 = add nsw i32 %258, %257
store i32 %259, i32* %24
%260 = load i32*, i32** %18
%261 = getelementptr inbounds i32, i32* %260, i64 0
%262 = load i32, i32* %261
%263 = load i32, i32* %26
%264 = mul nsw i32 %262, %263
%265 = load i32, i32* %25
%266 = sub nsw i32 %265, %264
store i32 %266, i32* %25
%267 = load i32*, i32** %19
%268 = getelementptr inbounds i32, i32* %267, i64 64
%269 = load i32, i32* %268
store i32 %269, i32* %26
%270 = load i32*, i32** %17
%271 = getelementptr inbounds i32, i32* %270, i64 64
%272 = load i32, i32* %271
%273 = load i32, i32* %26
%274 = mul nsw i32 %272, %273
%275 = load i32, i32* %24
%276 = add nsw i32 %275, %274
store i32 %276, i32* %24
%277 = load i32*, i32** %18
%278 = getelementptr inbounds i32, i32* %277, i64 64
%279 = load i32, i32* %278
%280 = load i32, i32* %26
%281 = mul nsw i32 %279, %280
%282 = load i32, i32* %25
%283 = sub nsw i32 %282, %281
store i32 %283, i32* %25
%284 = load i32*, i32** %19
%285 = getelementptr inbounds i32, i32* %284, i64 128
%286 = load i32, i32* %285
store i32 %286, i32* %26
%287 = load i32*, i32** %17
%288 = getelementptr inbounds i32, i32* %287, i64 128
%289 = load i32, i32* %288
%290 = load i32, i32* %26
%291 = mul nsw i32 %289, %290
%292 = load i32, i32* %24
%293 = add nsw i32 %292, %291
store i32 %293, i32* %24
%294 = load i32*, i32** %18
%295 = getelementptr inbounds i32, i32* %294, i64 128
%296 = load i32, i32* %295
%297 = load i32, i32* %26
%298 = mul nsw i32 %296, %297
%299 = load i32, i32* %25
%300 = sub nsw i32 %299, %298
store i32 %300, i32* %25
%301 = load i32*, i32** %19
%302 = getelementptr inbounds i32, i32* %301, i64 192
%303 = load i32, i32* %302
store i32 %303, i32* %26
%304 = load i32*, i32** %17
%305 = getelementptr inbounds i32, i32* %304, i64 192
%306 = load i32, i32* %305
%307 = load i32, i32* %26
%308 = mul nsw i32 %306, %307
%309 = load i32, i32* %24
%310 = add nsw i32 %309, %308
store i32 %310, i32* %24
%311 = load i32*, i32** %18
%312 = getelementptr inbounds i32, i32* %311, i64 192
%313 = load i32, i32* %312
%314 = load i32, i32* %26
%315 = mul nsw i32 %313, %314
%316 = load i32, i32* %25
%317 = sub nsw i32 %316, %315
store i32 %317, i32* %25
%318 = load i32*, i32** %19
%319 = getelementptr inbounds i32, i32* %318, i64 256
%320 = load i32, i32* %319
store i32 %320, i32* %26
%321 = load i32*, i32** %17
%322 = getelementptr inbounds i32, i32* %321, i64 256
%323 = load i32, i32* %322
%324 = load i32, i32* %26
%325 = mul nsw i32 %323, %324
%326 = load i32, i32* %24
%327 = add nsw i32 %326, %325
store i32 %327, i32* %24
%328 = load i32*, i32** %18
%329 = getelementptr inbounds i32, i32* %328, i64 256
%330 = load i32, i32* %329
%331 = load i32, i32* %26
%332 = mul nsw i32 %330, %331
%333 = load i32, i32* %25
%334 = sub nsw i32 %333, %332
store i32 %334, i32* %25
%335 = load i32*, i32** %19
%336 = getelementptr inbounds i32, i32* %335, i64 320
%337 = load i32, i32* %336
store i32 %337, i32* %26
%338 = load i32*, i32** %17
%339 = getelementptr inbounds i32, i32* %338, i64 320
%340 = load i32, i32* %339
%341 = load i32, i32* %26
%342 = mul nsw i32 %340, %341
%343 = load i32, i32* %24
%344 = add nsw i32 %343, %342
store i32 %344, i32* %24
%345 = load i32*, i32** %18
%346 = getelementptr inbounds i32, i32* %345, i64 320
%347 = load i32, i32* %346
%348 = load i32, i32* %26
%349 = mul nsw i32 %347, %348
%350 = load i32, i32* %25
%351 = sub nsw i32 %350, %349
store i32 %351, i32* %25
%352 = load i32*, i32** %19
%353 = getelementptr inbounds i32, i32* %352, i64 384
%354 = load i32, i32* %353
store i32 %354, i32* %26
%355 = load i32*, i32** %17
%356 = getelementptr inbounds i32, i32* %355, i64 384
%357 = load i32, i32* %356
%358 = load i32, i32* %26
%359 = mul nsw i32 %357, %358
%360 = load i32, i32* %24
%361 = add nsw i32 %360, %359
store i32 %361, i32* %24
%362 = load i32*, i32** %18
%363 = getelementptr inbounds i32, i32* %362, i64 384
%364 = load i32, i32* %363
%365 = load i32, i32* %26
%366 = mul nsw i32 %364, %365
%367 = load i32, i32* %25
%368 = sub nsw i32 %367, %366
store i32 %368, i32* %25
%369 = load i32*, i32** %19
%370 = getelementptr inbounds i32, i32* %369, i64 448
%371 = load i32, i32* %370
store i32 %371, i32* %26
%372 = load i32*, i32** %17
%373 = getelementptr inbounds i32, i32* %372, i64 448
%374 = load i32, i32* %373
%375 = load i32, i32* %26
%376 = mul nsw i32 %374, %375
%377 = load i32, i32* %24
%378 = add nsw i32 %377, %376
store i32 %378, i32* %24
%379 = load i32*, i32** %18
%380 = getelementptr inbounds i32, i32* %379, i64 448
%381 = load i32, i32* %380
%382 = load i32, i32* %26
%383 = mul nsw i32 %381, %382
%384 = load i32, i32* %25
%385 = sub nsw i32 %384, %383
store i32 %385, i32* %25
%386 = load i32*, i32** %16
%387 = getelementptr inbounds i32, i32* %386, i64 48
%388 = load i32, i32* %20
%389 = sext i32 %388 to i64
%390 = sub i64 0, %389
%391 = getelementptr inbounds i32, i32* %387, i64 %390
store i32* %391, i32** %19
%392 = load i32*, i32** %19
%393 = getelementptr inbounds i32, i32* %392, i64 0
%394 = load i32, i32* %393
store i32 %394, i32* %27
%395 = load i32*, i32** %17
%396 = getelementptr inbounds i32, i32* %395, i64 32
%397 = getelementptr inbounds i32, i32* %396, i64 0
%398 = load i32, i32* %397
%399 = load i32, i32* %27
%400 = mul nsw i32 %398, %399
%401 = load i32, i32* %24
%402 = sub nsw i32 %401, %400
store i32 %402, i32* %24
%403 = load i32*, i32** %18
%404 = getelementptr inbounds i32, i32* %403, i64 32
%405 = getelementptr inbounds i32, i32* %404, i64 0
%406 = load i32, i32* %405
%407 = load i32, i32* %27
%408 = mul nsw i32 %406, %407
%409 = load i32, i32* %25
%410 = sub nsw i32 %409, %408
store i32 %410, i32* %25
%411 = load i32*, i32** %19
%412 = getelementptr inbounds i32, i32* %411, i64 64
%413 = load i32, i32* %412
store i32 %413, i32* %27
%414 = load i32*, i32** %17
%415 = getelementptr inbounds i32, i32* %414, i64 32
%416 = getelementptr inbounds i32, i32* %415, i64 64
%417 = load i32, i32* %416
%418 = load i32, i32* %27
%419 = mul nsw i32 %417, %418
%420 = load i32, i32* %24
%421 = sub nsw i32 %420, %419
store i32 %421, i32* %24
%422 = load i32*, i32** %18
%423 = getelementptr inbounds i32, i32* %422, i64 32
%424 = getelementptr inbounds i32, i32* %423, i64 64
%425 = load i32, i32* %424
%426 = load i32, i32* %27
%427 = mul nsw i32 %425, %426
%428 = load i32, i32* %25
%429 = sub nsw i32 %428, %427
store i32 %429, i32* %25
%430 = load i32*, i32** %19
%431 = getelementptr inbounds i32, i32* %430, i64 128
%432 = load i32, i32* %431
store i32 %432, i32* %27
%433 = load i32*, i32** %17
%434 = getelementptr inbounds i32, i32* %433, i64 32
%435 = getelementptr inbounds i32, i32* %434, i64 128
%436 = load i32, i32* %435
%437 = load i32, i32* %27
%438 = mul nsw i32 %436, %437
%439 = load i32, i32* %24
%440 = sub nsw i32 %439, %438
store i32 %440, i32* %24
%441 = load i32*, i32** %18
%442 = getelementptr inbounds i32, i32* %441, i64 32
%443 = getelementptr inbounds i32, i32* %442, i64 128
%444 = load i32, i32* %443
%445 = load i32, i32* %27
%446 = mul nsw i32 %444, %445
%447 = load i32, i32* %25
%448 = sub nsw i32 %447, %446
store i32 %448, i32* %25
%449 = load i32*, i32** %19
%450 = getelementptr inbounds i32, i32* %449, i64 192
%451 = load i32, i32* %450
store i32 %451, i32* %27
%452 = load i32*, i32** %17
%453 = getelementptr inbounds i32, i32* %452, i64 32
%454 = getelementptr inbounds i32, i32* %453, i64 192
%455 = load i32, i32* %454
%456 = load i32, i32* %27
%457 = mul nsw i32 %455, %456
%458 = load i32, i32* %24
%459 = sub nsw i32 %458, %457
store i32 %459, i32* %24
%460 = load i32*, i32** %18
%461 = getelementptr inbounds i32, i32* %460, i64 32
%462 = getelementptr inbounds i32, i32* %461, i64 192
%463 = load i32, i32* %462
%464 = load i32, i32* %27
%465 = mul nsw i32 %463, %464
%466 = load i32, i32* %25
%467 = sub nsw i32 %466, %465
store i32 %467, i32* %25
%468 = load i32*, i32** %19
%469 = getelementptr inbounds i32, i32* %468, i64 256
%470 = load i32, i32* %469
store i32 %470, i32* %27
%471 = load i32*, i32** %17
%472 = getelementptr inbounds i32, i32* %471, i64 32
%473 = getelementptr inbounds i32, i32* %472, i64 256
%474 = load i32, i32* %473
%475 = load i32, i32* %27
%476 = mul nsw i32 %474, %475
%477 = load i32, i32* %24
%478 = sub nsw i32 %477, %476
store i32 %478, i32* %24
%479 = load i32*, i32** %18
%480 = getelementptr inbounds i32, i32* %479, i64 32
%481 = getelementptr inbounds i32, i32* %480, i64 256
%482 = load i32, i32* %481
%483 = load i32, i32* %27
%484 = mul nsw i32 %482, %483
%485 = load i32, i32* %25
%486 = sub nsw i32 %485, %484
store i32 %486, i32* %25
%487 = load i32*, i32** %19
%488 = getelementptr inbounds i32, i32* %487, i64 320
%489 = load i32, i32* %488
store i32 %489, i32* %27
%490 = load i32*, i32** %17
%491 = getelementptr inbounds i32, i32* %490, i64 32
%492 = getelementptr inbounds i32, i32* %491, i64 320
%493 = load i32, i32* %492
%494 = load i32, i32* %27
%495 = mul nsw i32 %493, %494
%496 = load i32, i32* %24
%497 = sub nsw i32 %496, %495
store i32 %497, i32* %24
%498 = load i32*, i32** %18
%499 = getelementptr inbounds i32, i32* %498, i64 32
%500 = getelementptr inbounds i32, i32* %499, i64 320
%501 = load i32, i32* %500
%502 = load i32, i32* %27
%503 = mul nsw i32 %501, %502
%504 = load i32, i32* %25
%505 = sub nsw i32 %504, %503
store i32 %505, i32* %25
%506 = load i32*, i32** %19
%507 = getelementptr inbounds i32, i32* %506, i64 384
%508 = load i32, i32* %507
store i32 %508, i32* %27
%509 = load i32*, i32** %17
%510 = getelementptr inbounds i32, i32* %509, i64 32
%511 = getelementptr inbounds i32, i32* %510, i64 384
%512 = load i32, i32* %511
%513 = load i32, i32* %27
%514 = mul nsw i32 %512, %513
%515 = load i32, i32* %24
%516 = sub nsw i32 %515, %514
store i32 %516, i32* %24
%517 = load i32*, i32** %18
%518 = getelementptr inbounds i32, i32* %517, i64 32
%519 = getelementptr inbounds i32, i32* %518, i64 384
%520 = load i32, i32* %519
%521 = load i32, i32* %27
%522 = mul nsw i32 %520, %521
%523 = load i32, i32* %25
%524 = sub nsw i32 %523, %522
store i32 %524, i32* %25
%525 = load i32*, i32** %19
%526 = getelementptr inbounds i32, i32* %525, i64 448
%527 = load i32, i32* %526
store i32 %527, i32* %27
%528 = load i32*, i32** %17
%529 = getelementptr inbounds i32, i32* %528, i64 32
%530 = getelementptr inbounds i32, i32* %529, i64 448
%531 = load i32, i32* %530
%532 = load i32, i32* %27
%533 = mul nsw i32 %531, %532
%534 = load i32, i32* %24
%535 = sub nsw i32 %534, %533
store i32 %535, i32* %24
%536 = load i32*, i32** %18
%537 = getelementptr inbounds i32, i32* %536, i64 32
%538 = getelementptr inbounds i32, i32* %537, i64 448
%539 = load i32, i32* %538
%540 = load i32, i32* %27
%541 = mul nsw i32 %539, %540
%542 = load i32, i32* %25
%543 = sub nsw i32 %542, %541
store i32 %543, i32* %25
%544 = call i32 @round_sample(i32* %24)
%545 = load i32*, i32** %12
store i32 %544, i32* %545
%546 = load i32, i32* %13
%547 = load i32*, i32** %12
%548 = sext i32 %546 to i64
%549 = getelementptr inbounds i32, i32* %547, i64 %548
store i32* %549, i32** %12
%550 = load i32, i32* %25
%551 = load i32, i32* %24
%552 = add nsw i32 %551, %550
store i32 %552, i32* %24
%553 = call i32 @round_sample(i32* %24)
%554 = load i32*, i32** %23
store i32 %553, i32* %554
%555 = load i32, i32* %13
%556 = load i32*, i32** %23
%557 = sext i32 %555 to i64
%558 = sub i64 0, %557
%559 = getelementptr inbounds i32, i32* %556, i64 %558
store i32* %559, i32** %23
%560 = load i32*, i32** %17
%561 = getelementptr inbounds i32, i32* %560, i32 1
store i32* %561, i32** %17
%562 = load i32*, i32** %18
%563 = getelementptr inbounds i32, i32* %562, i32 -1
store i32* %563, i32** %18
br label %564
564: ; preds = %244
%565 = load i32, i32* %20
%566 = add nsw i32 %565, 1
store i32 %566, i32* %20
br label %241
567: ; preds = %241
%568 = load i32*, i32** %16
%569 = getelementptr inbounds i32, i32* %568, i64 32
store i32* %569, i32** %19
%570 = load i32*, i32** %17
%571 = getelementptr inbounds i32, i32* %570, i64 32
%572 = getelementptr inbounds i32, i32* %571, i64 0
%573 = load i32, i32* %572
%574 = load i32*, i32** %19
%575 = getelementptr inbounds i32, i32* %574, i64 0
%576 = load i32, i32* %575
%577 = mul nsw i32 %573, %576
%578 = load i32, i32* %24
%579 = sub nsw i32 %578, %577
store i32 %579, i32* %24
%580 = load i32*, i32** %17
%581 = getelementptr inbounds i32, i32* %580, i64 32
%582 = getelementptr inbounds i32, i32* %581, i64 64
%583 = load i32, i32* %582
%584 = load i32*, i32** %19
%585 = getelementptr inbounds i32, i32* %584, i64 64
%586 = load i32, i32* %585
%587 = mul nsw i32 %583, %586
%588 = load i32, i32* %24
%589 = sub nsw i32 %588, %587
store i32 %589, i32* %24
%590 = load i32*, i32** %17
%591 = getelementptr inbounds i32, i32* %590, i64 32
%592 = getelementptr inbounds i32, i32* %591, i64 128
%593 = load i32, i32* %592
%594 = load i32*, i32** %19
%595 = getelementptr inbounds i32, i32* %594, i64 128
%596 = load i32, i32* %595
%597 = mul nsw i32 %593, %596
%598 = load i32, i32* %24
%599 = sub nsw i32 %598, %597
store i32 %599, i32* %24
%600 = load i32*, i32** %17
%601 = getelementptr inbounds i32, i32* %600, i64 32
%602 = getelementptr inbounds i32, i32* %601, i64 192
%603 = load i32, i32* %602
%604 = load i32*, i32** %19
%605 = getelementptr inbounds i32, i32* %604, i64 192
%606 = load i32, i32* %605
%607 = mul nsw i32 %603, %606
%608 = load i32, i32* %24
%609 = sub nsw i32 %608, %607
store i32 %609, i32* %24
%610 = load i32*, i32** %17
%611 = getelementptr inbounds i32, i32* %610, i64 32
%612 = getelementptr inbounds i32, i32* %611, i64 256
%613 = load i32, i32* %612
%614 = load i32*, i32** %19
%615 = getelementptr inbounds i32, i32* %614, i64 256
%616 = load i32, i32* %615
%617 = mul nsw i32 %613, %616
%618 = load i32, i32* %24
%619 = sub nsw i32 %618, %617
store i32 %619, i32* %24
%620 = load i32*, i32** %17
%621 = getelementptr inbounds i32, i32* %620, i64 32
%622 = getelementptr inbounds i32, i32* %621, i64 320
%623 = load i32, i32* %622
%624 = load i32*, i32** %19
%625 = getelementptr inbounds i32, i32* %624, i64 320
%626 = load i32, i32* %625
%627 = mul nsw i32 %623, %626
%628 = load i32, i32* %24
%629 = sub nsw i32 %628, %627
store i32 %629, i32* %24
%630 = load i32*, i32** %17
%631 = getelementptr inbounds i32, i32* %630, i64 32
%632 = getelementptr inbounds i32, i32* %631, i64 384
%633 = load i32, i32* %632
%634 = load i32*, i32** %19
%635 = getelementptr inbounds i32, i32* %634, i64 384
%636 = load i32, i32* %635
%637 = mul nsw i32 %633, %636
%638 = load i32, i32* %24
%639 = sub nsw i32 %638, %637
store i32 %639, i32* %24
%640 = load i32*, i32** %17
%641 = getelementptr inbounds i32, i32* %640, i64 32
%642 = getelementptr inbounds i32, i32* %641, i64 448
%643 = load i32, i32* %642
%644 = load i32*, i32** %19
%645 = getelementptr inbounds i32, i32* %644, i64 448
%646 = load i32, i32* %645
%647 = mul nsw i32 %643, %646
%648 = load i32, i32* %24
%649 = sub nsw i32 %648, %647
store i32 %649, i32* %24
%650 = call i32 @round_sample(i32* %24)
%651 = load i32*, i32** %12
store i32 %650, i32* %651
%652 = load i32, i32* %24
%653 = load i32*, i32** %11
store i32 %652, i32* %653
%654 = load i32, i32* %21
%655 = sub nsw i32 %654, 32
%656 = and i32 %655, 511
store i32 %656, i32* %21
%657 = load i32, i32* %21
%658 = load i32*, i32** %9
store i32 %657, i32* %658
ret void
}

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