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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double DBL_MAX;
scalar_t__ abs(int);
void DSPEncodeFrame(short pcmInOut[16], int sampleCount,
                    unsigned char adpcmOut[8], const short coefsIn[8][2]) {
  int inSamples[8][16];
  int outSamples[8][14];
  int bestIndex = 0;
  int scale[8];
  double distAccum[8];
  for (int i = 0; i < 8; i++) {
    int v1, v2, v3;
    int distance, index;
    inSamples[i][0] = pcmInOut[0];
    inSamples[i][1] = pcmInOut[1];
    distance = 0;
    for (int s = 0; s < sampleCount; s++) {
      inSamples[i][s + 2] = v1 =
          ((pcmInOut[s] * coefsIn[i][1]) + (pcmInOut[s + 1] * coefsIn[i][0])) /
          2048;
      v2 = pcmInOut[s + 2] - v1;
      v3 = (v2 >= 32767) ? 32767 : (v2 <= -32768) ? -32768 : v2;
      if (abs(v3) > abs(distance))
        distance = v3;
    }
    for (scale[i] = 0; (scale[i] <= 12) && ((distance > 7) || (distance < -8));
         scale[i]++, distance /= 2) {
    }
    scale[i] = (scale[i] <= 1) ? -1 : scale[i] - 2;
    do {
      scale[i]++;
      distAccum[i] = 0;
      index = 0;
      for (int s = 0; s < sampleCount; s++) {
        v1 = ((inSamples[i][s] * coefsIn[i][1]) +
              (inSamples[i][s + 1] * coefsIn[i][0]));
        v2 = ((pcmInOut[s + 2] << 11) - v1) / 2048;
        v3 = (v2 > 0) ? (int)((double)v2 / (1 << scale[i]) + 0.4999999f)
                      : (int)((double)v2 / (1 << scale[i]) - 0.4999999f);
        if (v3 < -8) {
          if (index < (v3 = -8 - v3))
            index = v3;
          v3 = -8;
        } else if (v3 > 7) {
          if (index < (v3 -= 7))
            index = v3;
          v3 = 7;
        }
        outSamples[i][s] = v3;
        v1 = (v1 + ((v3 * (1 << scale[i])) << 11) + 1024) >> 11;
        inSamples[i][s + 2] = v2 = (v1 >= 32767)    ? 32767
                                   : (v1 <= -32768) ? -32768
                                                    : v1;
        v3 = pcmInOut[s + 2] - v2;
        distAccum[i] += v3 * (double)v3;
      }
      for (int x = index + 8; x > 256; x >>= 1)
        if (++scale[i] >= 12)
          scale[i] = 11;
    } while ((scale[i] < 12) && (index > 1));
  }
  double min = DBL_MAX;
  for (int i = 0; i < 8; i++) {
    if (distAccum[i] < min) {
      min = distAccum[i];
      bestIndex = i;
    }
  }
  for (int s = 0; s < sampleCount; s++)
    pcmInOut[s + 2] = inSamples[bestIndex][s + 2];
  adpcmOut[0] = (char)((bestIndex << 4) | (scale[bestIndex] & 0xF));
  for (int s = sampleCount; s < 14; s++)
    outSamples[bestIndex][s] = 0;
  for (int y = 0; y < 7; y++) {
    adpcmOut[y + 1] = (char)((outSamples[bestIndex][y * 2] << 4) |
                             (outSamples[bestIndex][y * 2 + 1] & 0xF));
  }
}


x86 assembly (clang, -O0):
<DSPEncodeFrame>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4c0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x3e4(%rbp)
movl   $0x0,-0x454(%rbp)
cmpl   $0x8,-0x454(%rbp)
jge    181e <DSPEncodeFrame+0x70e>
mov    -0x8(%rbp),%rax
movswl (%rax),%ecx
movslq -0x454(%rbp),%rdx
lea    -0x220(%rbp),%rax
shl    $0x6,%rdx
add    %rdx,%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
movswl 0x2(%rax),%ecx
movslq -0x454(%rbp),%rdx
lea    -0x220(%rbp),%rax
shl    $0x6,%rdx
add    %rdx,%rax
mov    %ecx,0x4(%rax)
movl   $0x0,-0x464(%rbp)
movl   $0x0,-0x46c(%rbp)
mov    -0x46c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1303 <DSPEncodeFrame+0x1f3>
mov    -0x8(%rbp),%rax
movslq -0x46c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    -0x20(%rbp),%rcx
movslq -0x454(%rbp),%rdx
movswl 0x2(%rcx,%rdx,4),%ecx
imul   %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    -0x46c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
mov    -0x20(%rbp),%rdx
movslq -0x454(%rbp),%rsi
movswl (%rdx,%rsi,4),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    $0x800,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    %edx,-0x458(%rbp)
movslq -0x454(%rbp),%rcx
lea    -0x220(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    -0x46c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x46c(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
sub    -0x458(%rbp),%eax
mov    %eax,-0x45c(%rbp)
cmpl   $0x7fff,-0x45c(%rbp)
jl     126a <DSPEncodeFrame+0x15a>
mov    $0x7fff,%eax
mov    %eax,-0x494(%rbp)
jmp    12a2 <DSPEncodeFrame+0x192>
cmpl   $0xffff8000,-0x45c(%rbp)
80 ff ff
jg     128a <DSPEncodeFrame+0x17a>
mov    $0xffff8000,%eax
mov    %eax,-0x498(%rbp)
jmp    1296 <DSPEncodeFrame+0x186>
mov    -0x45c(%rbp),%eax
mov    %eax,-0x498(%rbp)
mov    -0x498(%rbp),%eax
mov    %eax,-0x494(%rbp)
mov    -0x494(%rbp),%eax
mov    %eax,-0x460(%rbp)
mov    -0x460(%rbp),%edi
call   1030 <abs@plt>
mov    %rax,-0x4a0(%rbp)
mov    -0x464(%rbp),%edi
call   1030 <abs@plt>
mov    %rax,%rcx
mov    -0x4a0(%rbp),%rax
cmp    %rcx,%rax
jle    12ea <DSPEncodeFrame+0x1da>
mov    -0x460(%rbp),%eax
mov    %eax,-0x464(%rbp)
jmp    12ef <DSPEncodeFrame+0x1df>
mov    -0x46c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x46c(%rbp)
jmp    119d <DSPEncodeFrame+0x8d>
movslq -0x454(%rbp),%rax
movl   $0x0,-0x410(%rbp,%rax,4)
movslq -0x454(%rbp),%rcx
xor    %eax,%eax
cmpl   $0xc,-0x410(%rbp,%rcx,4)
0c
mov    %al,-0x4a1(%rbp)
jg     1363 <DSPEncodeFrame+0x253>
mov    $0x1,%al
cmpl   $0x7,-0x464(%rbp)
mov    %al,-0x4a2(%rbp)
jg     1357 <DSPEncodeFrame+0x247>
cmpl   $0xfffffff8,-0x464(%rbp)
setl   %al
mov    %al,-0x4a2(%rbp)
mov    -0x4a2(%rbp),%al
mov    %al,-0x4a1(%rbp)
mov    -0x4a1(%rbp),%al
test   $0x1,%al
jne    1376 <DSPEncodeFrame+0x266>
jmp    13ac <DSPEncodeFrame+0x29c>
jmp    137b <DSPEncodeFrame+0x26b>
movslq -0x454(%rbp),%rax
mov    -0x410(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x410(%rbp,%rax,4)
mov    -0x464(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x464(%rbp)
jmp    1315 <DSPEncodeFrame+0x205>
movslq -0x454(%rbp),%rax
cmpl   $0x1,-0x410(%rbp,%rax,4)
01
jg     13d1 <DSPEncodeFrame+0x2c1>
mov    $0xffffffff,%eax
mov    %eax,-0x4a8(%rbp)
jmp    13e8 <DSPEncodeFrame+0x2d8>
movslq -0x454(%rbp),%rax
mov    -0x410(%rbp,%rax,4),%eax
sub    $0x2,%eax
mov    %eax,-0x4a8(%rbp)
mov    -0x4a8(%rbp),%ecx
movslq -0x454(%rbp),%rax
mov    %ecx,-0x410(%rbp,%rax,4)
movslq -0x454(%rbp),%rax
mov    -0x410(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x410(%rbp,%rax,4)
movslq -0x454(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x450(%rbp,%rax,8)
ff ff
movl   $0x0,-0x468(%rbp)
movl   $0x0,-0x470(%rbp)
mov    -0x470(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    175a <DSPEncodeFrame+0x64a>
movslq -0x454(%rbp),%rcx
lea    -0x220(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
movslq -0x470(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x454(%rbp),%rdx
movswl 0x2(%rcx,%rdx,4),%ecx
imul   %ecx,%eax
movslq -0x454(%rbp),%rdx
lea    -0x220(%rbp),%rcx
shl    $0x6,%rdx
add    %rdx,%rcx
mov    -0x470(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
mov    -0x20(%rbp),%rdx
movslq -0x454(%rbp),%rsi
movswl (%rdx,%rsi,4),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x458(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x470(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
shl    $0xb,%eax
sub    -0x458(%rbp),%eax
mov    $0x800,%ecx
cltd
idiv   %ecx
mov    %eax,-0x45c(%rbp)
cmpl   $0x0,-0x45c(%rbp)
jle    1532 <DSPEncodeFrame+0x422>
cvtsi2sdl -0x45c(%rbp),%xmm0
ff
movslq -0x454(%rbp),%rax
mov    -0x410(%rbp,%rax,4),%ecx
mov    $0x1,%eax
shl    %cl,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  0xae1(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x4ac(%rbp)
jmp    156d <DSPEncodeFrame+0x45d>
cvtsi2sdl -0x45c(%rbp),%xmm0
ff
movslq -0x454(%rbp),%rax
mov    -0x410(%rbp,%rax,4),%ecx
mov    $0x1,%eax
shl    %cl,%eax
cvtsi2sd %eax,%xmm1
divsd  %xmm1,%xmm0
movsd  0xaa1(%rip),%xmm1
subsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x4ac(%rbp)
mov    -0x4ac(%rbp),%eax
mov    %eax,-0x460(%rbp)
cmpl   $0xfffffff8,-0x460(%rbp)
jge    15c0 <DSPEncodeFrame+0x4b0>
mov    -0x468(%rbp),%eax
mov    $0xfffffff8,%ecx
sub    -0x460(%rbp),%ecx
mov    %ecx,-0x460(%rbp)
cmp    %ecx,%eax
jge    15b1 <DSPEncodeFrame+0x4a1>
mov    -0x460(%rbp),%eax
mov    %eax,-0x468(%rbp)
movl   $0xfffffff8,-0x460(%rbp)
ff ff ff
jmp    1605 <DSPEncodeFrame+0x4f5>
cmpl   $0x7,-0x460(%rbp)
jle    1600 <DSPEncodeFrame+0x4f0>
mov    -0x468(%rbp),%eax
mov    -0x460(%rbp),%ecx
sub    $0x7,%ecx
mov    %ecx,-0x460(%rbp)
cmp    %ecx,%eax
jge    15f6 <DSPEncodeFrame+0x4e6>
mov    -0x460(%rbp),%eax
mov    %eax,-0x468(%rbp)
movl   $0x7,-0x460(%rbp)
jmp    1605 <DSPEncodeFrame+0x4f5>
mov    -0x460(%rbp),%edx
movslq -0x454(%rbp),%rcx
lea    -0x3e0(%rbp),%rax
imul   $0x38,%rcx,%rcx
add    %rcx,%rax
movslq -0x470(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x458(%rbp),%eax
mov    -0x460(%rbp),%ecx
mov    %ecx,-0x4b0(%rbp)
movslq -0x454(%rbp),%rcx
mov    -0x410(%rbp,%rcx,4),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    -0x4b0(%rbp),%ecx
imul   %edx,%ecx
shl    $0xb,%ecx
add    %ecx,%eax
add    $0x400,%eax
sar    $0xb,%eax
mov    %eax,-0x458(%rbp)
cmpl   $0x7fff,-0x458(%rbp)
jl     168d <DSPEncodeFrame+0x57d>
mov    $0x7fff,%eax
mov    %eax,-0x4b4(%rbp)
jmp    16c5 <DSPEncodeFrame+0x5b5>
cmpl   $0xffff8000,-0x458(%rbp)
80 ff ff
jg     16ad <DSPEncodeFrame+0x59d>
mov    $0xffff8000,%eax
mov    %eax,-0x4b8(%rbp)
jmp    16b9 <DSPEncodeFrame+0x5a9>
mov    -0x458(%rbp),%eax
mov    %eax,-0x4b8(%rbp)
mov    -0x4b8(%rbp),%eax
mov    %eax,-0x4b4(%rbp)
mov    -0x4b4(%rbp),%edx
mov    %edx,-0x45c(%rbp)
movslq -0x454(%rbp),%rcx
lea    -0x220(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    -0x470(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x470(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
sub    -0x45c(%rbp),%eax
mov    %eax,-0x460(%rbp)
cvtsi2sdl -0x460(%rbp),%xmm0
ff
cvtsi2sdl -0x460(%rbp),%xmm2
ff
movslq -0x454(%rbp),%rax
movsd  -0x450(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x450(%rbp,%rax,8)
ff ff
mov    -0x470(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x470(%rbp)
jmp    143b <DSPEncodeFrame+0x32b>
mov    -0x468(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x474(%rbp)
cmpl   $0x100,-0x474(%rbp)
jle    17c5 <DSPEncodeFrame+0x6b5>
movslq -0x454(%rbp),%rcx
mov    -0x410(%rbp,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0x410(%rbp,%rcx,4)
cmp    $0xc,%eax
jl     17ac <DSPEncodeFrame+0x69c>
movslq -0x454(%rbp),%rax
movl   $0xb,-0x410(%rbp,%rax,4)
jmp    17b1 <DSPEncodeFrame+0x6a1>
mov    -0x474(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x474(%rbp)
jmp    1769 <DSPEncodeFrame+0x659>
jmp    17ca <DSPEncodeFrame+0x6ba>
movslq -0x454(%rbp),%rcx
xor    %eax,%eax
cmpl   $0xc,-0x410(%rbp,%rcx,4)
0c
mov    %al,-0x4b9(%rbp)
jge    17f7 <DSPEncodeFrame+0x6e7>
cmpl   $0x1,-0x468(%rbp)
setg   %al
mov    %al,-0x4b9(%rbp)
mov    -0x4b9(%rbp),%al
test   $0x1,%al
jne    13fc <DSPEncodeFrame+0x2ec>
jmp    180a <DSPEncodeFrame+0x6fa>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    113e <DSPEncodeFrame+0x2e>
mov    0x27bb(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x480(%rbp)
ff
movl   $0x0,-0x484(%rbp)
cmpl   $0x8,-0x484(%rbp)
jge    18a7 <DSPEncodeFrame+0x797>
movslq -0x484(%rbp),%rax
movsd  -0x450(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x480(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    188e <DSPEncodeFrame+0x77e>
movslq -0x484(%rbp),%rax
movsd  -0x450(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x480(%rbp)
ff
mov    -0x484(%rbp),%eax
mov    %eax,-0x3e4(%rbp)
jmp    1893 <DSPEncodeFrame+0x783>
mov    -0x484(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x484(%rbp)
jmp    183b <DSPEncodeFrame+0x72b>
movl   $0x0,-0x488(%rbp)
mov    -0x488(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    190f <DSPEncodeFrame+0x7ff>
movslq -0x3e4(%rbp),%rcx
lea    -0x220(%rbp),%rax
shl    $0x6,%rcx
add    %rcx,%rax
mov    -0x488(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %ax,%dx
mov    -0x8(%rbp),%rax
mov    -0x488(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x488(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x488(%rbp)
jmp    18b1 <DSPEncodeFrame+0x7a1>
mov    -0x3e4(%rbp),%eax
shl    $0x4,%eax
movslq -0x3e4(%rbp),%rcx
mov    -0x410(%rbp,%rcx,4),%ecx
and    $0xf,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0xc(%rbp),%eax
mov    %eax,-0x48c(%rbp)
cmpl   $0xe,-0x48c(%rbp)
jge    1980 <DSPEncodeFrame+0x870>
movslq -0x3e4(%rbp),%rcx
lea    -0x3e0(%rbp),%rax
imul   $0x38,%rcx,%rcx
add    %rcx,%rax
movslq -0x48c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x48c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48c(%rbp)
jmp    193c <DSPEncodeFrame+0x82c>
movl   $0x0,-0x490(%rbp)
cmpl   $0x7,-0x490(%rbp)
jge    1a13 <DSPEncodeFrame+0x903>
movslq -0x3e4(%rbp),%rcx
lea    -0x3e0(%rbp),%rax
imul   $0x38,%rcx,%rcx
add    %rcx,%rax
mov    -0x490(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x4,%eax
movslq -0x3e4(%rbp),%rdx
lea    -0x3e0(%rbp),%rcx
imul   $0x38,%rdx,%rdx
add    %rdx,%rcx
mov    -0x490(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%ecx
and    $0xf,%ecx
or     %ecx,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
mov    -0x490(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x490(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x490(%rbp)
jmp    198a <DSPEncodeFrame+0x87a>
add    $0x4c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<DSPEncodeFrame>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x468,%rsp
mov    %rcx,0x20(%rsp)
mov    %rdx,0x18(%rsp)
mov    %esi,%eax
lea    0x268(%rsp),%r12
mov    %rax,0x10(%rsp)
add    $0xffffffffffffffff,%rax
mov    %rax,0x30(%rsp)
lea    0xa0(%rsp),%r13
xor    %r10d,%r10d
mov    %esi,0x4(%rsp)
mov    %rdi,%r15
jmp    119b <DSPEncodeFrame+0x7b>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    %ecx,%eax
mov    %eax,0x40(%rsp,%r10,4)
movsd  %xmm0,0x60(%rsp,%r10,8)
add    $0x1,%r10
add    $0x40,%r12
add    $0x38,%r13
cmp    $0x8,%r10
mov    %r15,%rdi
je     1483 <DSPEncodeFrame+0x363>
mov    %r10,%rbx
shl    $0x6,%rbx
movswl (%rdi),%ecx
mov    %ecx,0x260(%rsp,%rbx,1)
movswl 0x2(%rdi),%eax
mov    %eax,0x264(%rsp,%rbx,1)
test   %esi,%esi
mov    %r10,0x8(%rsp)
jle    12c0 <DSPEncodeFrame+0x1a0>
mov    %rbx,0x28(%rsp)
xor    %ebx,%ebx
xor    %r14d,%r14d
xchg   %ax,%ax
movswl %cx,%ecx
mov    0x20(%rsp),%rsi
movswl 0x2(%rsi,%r10,4),%edx
imul   %ecx,%edx
cwtl
movswl (%rsi,%r10,4),%ecx
imul   %eax,%ecx
lea    (%rcx,%rdx,1),%eax
add    $0x7ff,%eax
add    %edx,%ecx
cmovns %ecx,%eax
sar    $0xb,%eax
mov    %eax,(%r12,%rbx,4)
movswl 0x4(%rdi,%rbx,2),%ebp
sub    %eax,%ebp
cmp    $0xffff8001,%ebp
jge    1212 <DSPEncodeFrame+0xf2>
mov    $0xffff8000,%ebp
cmp    $0x7fff,%ebp
jl     121f <DSPEncodeFrame+0xff>
mov    $0x7fff,%ebp
mov    %ebp,%edi
call   1030 <abs@plt>
mov    %rax,0x38(%rsp)
mov    %r14d,%edi
call   1030 <abs@plt>
cmp    %rax,0x38(%rsp)
jg     123d <DSPEncodeFrame+0x11d>
mov    %r14d,%ebp
cmp    %rbx,0x30(%rsp)
mov    0x8(%rsp),%r10
je     1270 <DSPEncodeFrame+0x150>
mov    %r15,%rdi
movzwl 0x2(%r15,%rbx,2),%ecx
movzwl 0x4(%r15,%rbx,2),%eax
add    $0x1,%rbx
mov    %ebp,%r14d
jmp    11d0 <DSPEncodeFrame+0xb0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,0x40(%rsp,%r10,4)
lea    -0x8(%rbp),%eax
cmp    $0xffffffef,%eax
mov    0x4(%rsp),%esi
mov    0x28(%rsp),%rbx
ja     12c9 <DSPEncodeFrame+0x1a9>
xor    %eax,%eax
nopl   0x0(%rax)
mov    %eax,%ecx
lea    0x1(%rcx),%eax
cmp    $0xb,%ecx
ja     12ad <DSPEncodeFrame+0x18d>
mov    %ebp,%ecx
shr    $0x1f,%ecx
add    %ebp,%ecx
sar    %ecx
lea    -0x8(%rcx),%edx
mov    %ecx,%ebp
cmp    $0xfffffff0,%edx
jb     1290 <DSPEncodeFrame+0x170>
cmp    $0x1,%eax
je     12c9 <DSPEncodeFrame+0x1a9>
add    $0xfffffffe,%eax
jmp    12ce <DSPEncodeFrame+0x1ae>
nopw   0x0(%rax,%rax,1)
movl   $0x0,0x40(%rsp,%r10,4)
mov    $0xffffffff,%eax
lea    (%rsp,%rbx,1),%r8
add    $0x260,%r8
mov    %eax,0x40(%rsp,%r10,4)
xchg   %ax,%ax
mov    %eax,%ecx
add    $0x1,%ecx
test   %esi,%esi
jle    1170 <DSPEncodeFrame+0x50>
mov    0x20(%rsp),%rdx
movswl 0x2(%rdx,%r10,4),%r9d
mov    $0x1,%eax
shl    %cl,%eax
movswl (%rdx,%r10,4),%r10d
cvtsi2sd %eax,%xmm1
mov    (%r8),%r14d
mov    0x4(%r8),%edx
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
xor    %r11d,%r11d
jmp    1387 <DSPEncodeFrame+0x267>
nopw   0x0(%rax,%rax,1)
mov    $0xfffffff8,%ebp
sub    %edx,%ebp
cmp    %ebp,%r11d
cmovl  %ebp,%r11d
mov    $0xfffffff8,%edx
mov    %edx,0x0(%r13,%rax,4)
shl    %cl,%edx
shl    $0xb,%edx
lea    (%rdx,%rdi,1),%ebp
add    %edi,%edx
add    $0x400,%edx
sar    $0xb,%edx
cmp    $0xfc000400,%ebp
mov    $0xffff8000,%edi
cmovl  %edi,%edx
cmp    $0x3fff400,%ebp
mov    $0x7fff,%edi
cmovge %edi,%edx
sub    %edx,%esi
xorps  %xmm2,%xmm2
cvtsi2sd %esi,%xmm2
mov    %edx,(%r12,%rax,4)
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm0
cmp    %rbx,0x10(%rsp)
je     1410 <DSPEncodeFrame+0x2f0>
mov    %rbx,%rax
mov    %r14d,%esi
mov    %edx,%r14d
imul   %r9d,%esi
mov    %edx,%edi
imul   %r10d,%edi
add    %esi,%edi
movswl 0x4(%r15,%rbx,2),%esi
mov    %esi,%edx
shl    $0xb,%edx
sub    %edi,%edx
xor    %ebx,%ebx
cmp    $0x800,%edx
setge  %bl
lea    0x7ff(%rdx),%ebp
test   %edx,%edx
cmovns %edx,%ebp
sar    $0xb,%ebp
xorps  %xmm2,%xmm2
cvtsi2sd %ebp,%xmm2
divsd  %xmm1,%xmm2
lea    0xc2c(%rip),%rdx
addsd  (%rdx,%rbx,8),%xmm2
lea    0x1(%rax),%rbx
cvttsd2si %xmm2,%edx
cmp    $0xfffffff7,%edx
jle    1320 <DSPEncodeFrame+0x200>
cmp    $0x8,%edx
jl     1333 <DSPEncodeFrame+0x213>
add    $0xfffffff9,%edx
cmp    %edx,%r11d
cmovl  %edx,%r11d
mov    $0x7,%edx
jmp    1333 <DSPEncodeFrame+0x213>
nopw   0x0(%rax,%rax,1)
cmp    $0xf9,%r11d
jl     1460 <DSPEncodeFrame+0x340>
lea    0x8(%r11),%edx
mov    %edx,%edi
mov    0x4(%rsp),%esi
mov    0x8(%rsp),%r10
mov    $0xb,%ebp
nopl   (%rax)
lea    0x1(%rcx),%eax
cmp    $0xb,%ecx
cmovge %ebp,%eax
shr    %edi
mov    %eax,%ecx
cmp    $0x201,%edx
mov    %edi,%edx
ja     1430 <DSPEncodeFrame+0x310>
cmp    $0xb,%eax
jle    1474 <DSPEncodeFrame+0x354>
jmp    1176 <DSPEncodeFrame+0x56>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,%eax
mov    0x4(%rsp),%esi
mov    0x8(%rsp),%r10
cmp    $0xb,%eax
jg     1176 <DSPEncodeFrame+0x56>
cmp    $0x1,%r11d
jg     12e0 <DSPEncodeFrame+0x1c0>
jmp    1176 <DSPEncodeFrame+0x56>
mov    0x2b56(%rip),%rax
movsd  0x60(%rsp),%xmm0
minsd  (%rax),%xmm0
movsd  0x68(%rsp),%xmm1
xor    %eax,%eax
ucomisd %xmm1,%xmm0
seta   %al
minsd  %xmm0,%xmm1
movsd  0x70(%rsp),%xmm0
ucomisd %xmm0,%xmm1
mov    $0x2,%ecx
cmovbe %eax,%ecx
minsd  %xmm1,%xmm0
movsd  0x78(%rsp),%xmm1
ucomisd %xmm1,%xmm0
mov    $0x3,%eax
cmovbe %ecx,%eax
minsd  %xmm0,%xmm1
movsd  0x80(%rsp),%xmm0
ucomisd %xmm0,%xmm1
mov    $0x4,%ecx
cmovbe %eax,%ecx
minsd  %xmm1,%xmm0
movsd  0x88(%rsp),%xmm1
ucomisd %xmm1,%xmm0
mov    $0x5,%eax
cmovbe %ecx,%eax
minsd  %xmm0,%xmm1
movsd  0x90(%rsp),%xmm0
ucomisd %xmm0,%xmm1
mov    $0x6,%ecx
cmovbe %eax,%ecx
minsd  %xmm1,%xmm0
ucomisd 0x98(%rsp),%xmm0
mov    $0x7,%ebp
cmovbe %ecx,%ebp
test   %esi,%esi
jle    1544 <DSPEncodeFrame+0x424>
cmp    $0x8,%esi
jae    155e <DSPEncodeFrame+0x43e>
xor    %eax,%eax
mov    0x10(%rsp),%r15
jmp    165d <DSPEncodeFrame+0x53d>
mov    %ebp,%eax
shl    $0x4,%eax
mov    0x40(%rsp,%rbp,4),%ecx
and    $0xf,%ecx
or     %eax,%ecx
mov    0x18(%rsp),%rbx
mov    %cl,(%rbx)
jmp    16a0 <DSPEncodeFrame+0x580>
mov    0x10(%rsp),%r15
mov    %r15d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1790 <DSPEncodeFrame+0x670>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    %rbp,%rcx
shl    $0x6,%rcx
lea    (%rsp,%rcx,1),%rbx
add    $0x260,%rbx
mov    $0x2,%ecx
nop
movdqu (%rbx,%rcx,4),%xmm0
movdqu 0x10(%rbx,%rcx,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdi,%rcx,2)
movdqu 0x20(%rbx,%rcx,4),%xmm0
movdqu 0x30(%rbx,%rcx,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,0x10(%rdi,%rcx,2)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    15a0 <DSPEncodeFrame+0x480>
test   $0x1,%dl
je     1658 <DSPEncodeFrame+0x538>
mov    %rbp,%rdx
shl    $0x6,%rdx
add    %rsp,%rdx
add    $0x260,%rdx
movdqu (%rdx,%rcx,4),%xmm0
movdqu 0x10(%rdx,%rcx,4),%xmm1
pshuflw $0xe8,%xmm0,%xmm0
pshufhw $0xe8,%xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pshuflw $0xe8,%xmm1,%xmm1
pshufhw $0xe8,%xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpcklqdq %xmm1,%xmm0
movdqu %xmm0,(%rdi,%rcx,2)
cmp    %r15,%rax
je     1682 <DSPEncodeFrame+0x562>
mov    %rbp,%rcx
shl    $0x6,%rcx
add    %rsp,%rcx
add    $0x268,%rcx
xchg   %ax,%ax
movzwl (%rcx,%rax,4),%edx
mov    %dx,0x4(%rdi,%rax,2)
add    $0x1,%rax
cmp    %rax,%r15
jne    1670 <DSPEncodeFrame+0x550>
mov    %ebp,%eax
shl    $0x4,%eax
mov    0x40(%rsp,%rbp,4),%ecx
and    $0xf,%ecx
or     %eax,%ecx
mov    0x18(%rsp),%rbx
mov    %cl,(%rbx)
mov    0x4(%rsp),%esi
cmp    $0xd,%esi
jg     16cb <DSPEncodeFrame+0x5ab>
movslq %esi,%rax
imul   $0x38,%rbp,%rcx
add    %rsp,%rcx
add    $0xa0,%rcx
lea    (%rcx,%rax,4),%rdi
mov    $0xd,%eax
sub    %esi,%eax
lea    0x4(,%rax,4),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
imul   $0x38,%rbp,%rax
mov    0xa0(%rsp,%rax,1),%ecx
mov    0xa4(%rsp,%rax,1),%edx
shl    $0x4,%ecx
and    $0xf,%edx
or     %ecx,%edx
mov    %dl,0x1(%rbx)
mov    0xa8(%rsp,%rax,1),%ecx
mov    0xac(%rsp,%rax,1),%edx
shl    $0x4,%ecx
and    $0xf,%edx
or     %ecx,%edx
mov    %dl,0x2(%rbx)
mov    0xb0(%rsp,%rax,1),%ecx
mov    0xb4(%rsp,%rax,1),%edx
shl    $0x4,%ecx
and    $0xf,%edx
or     %ecx,%edx
mov    %dl,0x3(%rbx)
mov    0xb8(%rsp,%rax,1),%ecx
mov    0xbc(%rsp,%rax,1),%edx
shl    $0x4,%ecx
and    $0xf,%edx
or     %ecx,%edx
mov    %dl,0x4(%rbx)
mov    0xc0(%rsp,%rax,1),%ecx
mov    0xc4(%rsp,%rax,1),%edx
shl    $0x4,%ecx
and    $0xf,%edx
or     %ecx,%edx
mov    %dl,0x5(%rbx)
mov    0xc8(%rsp,%rax,1),%ecx
mov    0xcc(%rsp,%rax,1),%edx
shl    $0x4,%ecx
and    $0xf,%edx
or     %ecx,%edx
mov    %dl,0x6(%rbx)
mov    0xd0(%rsp,%rax,1),%ecx
mov    0xd4(%rsp,%rax,1),%eax
shl    $0x4,%ecx
and    $0xf,%eax
or     %ecx,%eax
mov    %al,0x7(%rbx)
add    $0x468,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x2,%ecx
test   $0x1,%dl
jne    1615 <DSPEncodeFrame+0x4f5>
jmp    1658 <DSPEncodeFrame+0x538>

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

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