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

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ edct(float *, float *);
int error(char *);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ feof(int /*<<< orphan*/ *);
unsigned char fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fputc(int, int /*<<< orphan*/ *);
int enc(int argc, char *argv[]) {
  FILE *in;
  FILE *out;
  in = fopen(argv[2], "r");
  out = fopen(argv[3], "w");
  if (in == NULL)
    return error("Could not open input file");
  if (out == NULL)
    return error("Could not open output file");
  unsigned char buf[32 * 4];
  int iarr[32 * 2];
  float darr[32 * 2];
  float doutl[32];
  float doutr[32];
  int iout[32 * 2];
  while (!feof(in)) {
    for (int i = 0; i < 32 * 4; ++i) {
      buf[i] = fgetc(in);
    }
    for (int i = 0; i < 32; ++i) {
      int l = buf[i * 4];
      l += (buf[i * 4 + 1] & 0x7F) * 256;
      if (buf[i * 4 + 1] & 0x80)
        l = (0x8000 - l) * -1;
      iarr[i] = l;
      int r;
      r = 0;
      r |= buf[i * 4 + 2];
      r |= (buf[i * 4 + 3] & 0x7F) * 256;
      if (buf[i * 4 + 3] & 0x80) {
        r = (0x8000 - r) * -1;
      }
      iarr[i + 32] = r;
    }
    for (int i = 0; i < 32 * 2; ++i) {
      darr[i] = ((float)iarr[i]) / 32768.;
    }
    edct(darr, doutl);
    float *darrr = darr + 32;
    edct(darrr, doutr);
    for (int i = 0; i < 32; ++i) {
      iout[i * 2] = doutl[i] * 16;
      iout[i * 2 + 1] = doutr[i] * 16;
    }
    for (int i = 0; i < 32 * 2; i += 8) {
      char control = 0;
      if (iout[i] & 0xFF)
        control |= 128;
      if (iout[i + 1] & 0xFF)
        control |= 64;
      if (iout[i + 2] & 0xFF)
        control |= 32;
      if (iout[i + 3] & 0xFF)
        control |= 16;
      if (iout[i + 4] & 0xFF)
        control |= 8;
      if (iout[i + 5] & 0xFF)
        control |= 4;
      if (iout[i + 6] & 0xFF)
        control |= 2;
      if (iout[i + 7] & 0xFF)
        control |= 1;
      fputc(control, out);
      for (int j = 0; j < 8; ++j) {
        if (iout[i + j] & 0xFF)
          fputc(iout[i + j] & 0xFF, out);
      }
    }
  }
  fclose(in);
  fclose(out);
}


x86 assembly (clang, -O0):
<enc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4d0,%rsp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
lea    0xe7f(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
lea    0xe69(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    11d1 <enc+0x61>
lea    0xe50(%rip),%rdi
call   1080 <error@plt>
mov    %eax,-0x4(%rbp)
jmp    172c <enc+0x5bc>
cmpq   $0x0,-0x20(%rbp)
jne    11f0 <enc+0x80>
lea    0xe4b(%rip),%rdi
call   1080 <error@plt>
mov    %eax,-0x4(%rbp)
jmp    172c <enc+0x5bc>
jmp    11f5 <enc+0x85>
mov    -0x18(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1213 <enc+0xa3>
jmp    171a <enc+0x5aa>
movl   $0x0,-0x4a4(%rbp)
cmpl   $0x80,-0x4a4(%rbp)
jge    125a <enc+0xea>
mov    -0x18(%rbp),%rdi
call   1040 <fgetc@plt>
mov    %al,%cl
movslq -0x4a4(%rbp),%rax
mov    %cl,-0xa0(%rbp,%rax,1)
mov    -0x4a4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4a4(%rbp)
jmp    121d <enc+0xad>
movl   $0x0,-0x4a8(%rbp)
cmpl   $0x20,-0x4a8(%rbp)
jge    13b6 <enc+0x246>
mov    -0x4a8(%rbp),%eax
shl    $0x2,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
mov    %eax,-0x4ac(%rbp)
mov    -0x4a8(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
and    $0x7f,%eax
shl    $0x8,%eax
add    -0x4ac(%rbp),%eax
mov    %eax,-0x4ac(%rbp)
mov    -0x4a8(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
and    $0x80,%eax
cmp    $0x0,%eax
je     12ea <enc+0x17a>
mov    $0x8000,%eax
sub    -0x4ac(%rbp),%eax
imul   $0xffffffff,%eax,%eax
mov    %eax,-0x4ac(%rbp)
mov    -0x4ac(%rbp),%ecx
movslq -0x4a8(%rbp),%rax
mov    %ecx,-0x1a0(%rbp,%rax,4)
movl   $0x0,-0x4b0(%rbp)
mov    -0x4a8(%rbp),%eax
shl    $0x2,%eax
add    $0x2,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
or     -0x4b0(%rbp),%eax
mov    %eax,-0x4b0(%rbp)
mov    -0x4a8(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
and    $0x7f,%eax
shl    $0x8,%eax
or     -0x4b0(%rbp),%eax
mov    %eax,-0x4b0(%rbp)
mov    -0x4a8(%rbp),%eax
shl    $0x2,%eax
add    $0x3,%eax
cltq
movzbl -0xa0(%rbp,%rax,1),%eax
ff
and    $0x80,%eax
cmp    $0x0,%eax
je     138a <enc+0x21a>
mov    $0x8000,%eax
sub    -0x4b0(%rbp),%eax
imul   $0xffffffff,%eax,%eax
mov    %eax,-0x4b0(%rbp)
mov    -0x4b0(%rbp),%ecx
mov    -0x4a8(%rbp),%eax
add    $0x20,%eax
cltq
mov    %ecx,-0x1a0(%rbp,%rax,4)
mov    -0x4a8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4a8(%rbp)
jmp    1264 <enc+0xf4>
movl   $0x0,-0x4b4(%rbp)
cmpl   $0x40,-0x4b4(%rbp)
jge    1415 <enc+0x2a5>
movslq -0x4b4(%rbp),%rax
cvtsi2ssl -0x1a0(%rbp,%rax,4),%xmm0
ff ff
cvtss2sd %xmm0,%xmm0
movsd  0xc1f(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x4b4(%rbp),%rax
movss  %xmm0,-0x2a0(%rbp,%rax,4)
ff ff
mov    -0x4b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4b4(%rbp)
jmp    13c0 <enc+0x250>
lea    -0x2a0(%rbp),%rdi
lea    -0x320(%rbp),%rsi
call   1070 <edct@plt>
lea    -0x2a0(%rbp),%rax
add    $0x80,%rax
mov    %rax,-0x4c0(%rbp)
mov    -0x4c0(%rbp),%rdi
lea    -0x3a0(%rbp),%rsi
call   1070 <edct@plt>
movl   $0x0,-0x4c4(%rbp)
cmpl   $0x20,-0x4c4(%rbp)
jge    14d9 <enc+0x369>
movslq -0x4c4(%rbp),%rax
movss  0xb8b(%rip),%xmm0
mulss  -0x320(%rbp,%rax,4),%xmm0
ff ff
cvttss2si %xmm0,%ecx
mov    -0x4c4(%rbp),%eax
shl    $0x1,%eax
cltq
mov    %ecx,-0x4a0(%rbp,%rax,4)
movslq -0x4c4(%rbp),%rax
movss  0xb5d(%rip),%xmm0
mulss  -0x3a0(%rbp,%rax,4),%xmm0
ff ff
cvttss2si %xmm0,%ecx
mov    -0x4c4(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
mov    %ecx,-0x4a0(%rbp,%rax,4)
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    1459 <enc+0x2e9>
movl   $0x0,-0x4c8(%rbp)
cmpl   $0x40,-0x4c8(%rbp)
jge    1715 <enc+0x5a5>
movb   $0x0,-0x4c9(%rbp)
movslq -0x4c8(%rbp),%rax
mov    -0x4a0(%rbp,%rax,4),%eax
and    $0xff,%eax
cmp    $0x0,%eax
je     1525 <enc+0x3b5>
movsbl -0x4c9(%rbp),%eax
or     $0x80,%eax
mov    %al,-0x4c9(%rbp)
mov    -0x4c8(%rbp),%eax
add    $0x1,%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%eax
and    $0xff,%eax
cmp    $0x0,%eax
je     1555 <enc+0x3e5>
movsbl -0x4c9(%rbp),%eax
or     $0x40,%eax
mov    %al,-0x4c9(%rbp)
mov    -0x4c8(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%eax
and    $0xff,%eax
cmp    $0x0,%eax
je     1585 <enc+0x415>
movsbl -0x4c9(%rbp),%eax
or     $0x20,%eax
mov    %al,-0x4c9(%rbp)
mov    -0x4c8(%rbp),%eax
add    $0x3,%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%eax
and    $0xff,%eax
cmp    $0x0,%eax
je     15b5 <enc+0x445>
movsbl -0x4c9(%rbp),%eax
or     $0x10,%eax
mov    %al,-0x4c9(%rbp)
mov    -0x4c8(%rbp),%eax
add    $0x4,%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%eax
and    $0xff,%eax
cmp    $0x0,%eax
je     15e5 <enc+0x475>
movsbl -0x4c9(%rbp),%eax
or     $0x8,%eax
mov    %al,-0x4c9(%rbp)
mov    -0x4c8(%rbp),%eax
add    $0x5,%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%eax
and    $0xff,%eax
cmp    $0x0,%eax
je     1615 <enc+0x4a5>
movsbl -0x4c9(%rbp),%eax
or     $0x4,%eax
mov    %al,-0x4c9(%rbp)
mov    -0x4c8(%rbp),%eax
add    $0x6,%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%eax
and    $0xff,%eax
cmp    $0x0,%eax
je     1645 <enc+0x4d5>
movsbl -0x4c9(%rbp),%eax
or     $0x2,%eax
mov    %al,-0x4c9(%rbp)
mov    -0x4c8(%rbp),%eax
add    $0x7,%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%eax
and    $0xff,%eax
cmp    $0x0,%eax
je     1675 <enc+0x505>
movsbl -0x4c9(%rbp),%eax
or     $0x1,%eax
mov    %al,-0x4c9(%rbp)
movsbl -0x4c9(%rbp),%edi
mov    -0x20(%rbp),%rsi
call   1050 <fputc@plt>
movl   $0x0,-0x4d0(%rbp)
cmpl   $0x8,-0x4d0(%rbp)
jge    16fc <enc+0x58c>
mov    -0x4c8(%rbp),%eax
add    -0x4d0(%rbp),%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%eax
and    $0xff,%eax
cmp    $0x0,%eax
je     16e3 <enc+0x573>
mov    -0x4c8(%rbp),%eax
add    -0x4d0(%rbp),%eax
cltq
mov    -0x4a0(%rbp,%rax,4),%edi
and    $0xff,%edi
mov    -0x20(%rbp),%rsi
call   1050 <fputc@plt>
jmp    16e8 <enc+0x578>
mov    -0x4d0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4d0(%rbp)
jmp    168f <enc+0x51f>
jmp    1701 <enc+0x591>
mov    -0x4c8(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x4c8(%rbp)
jmp    14e3 <enc+0x373>
jmp    11f5 <enc+0x85>
mov    -0x18(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x20(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x4(%rbp),%eax
add    $0x4d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<enc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x488,%rsp
mov    %rsi,%rbx
mov    0x10(%rsi),%rdi
lea    0xee1(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,%r14
mov    0x18(%rbx),%rdi
lea    0xed0(%rip),%rsi
call   1090 <fopen@plt>
test   %r14,%r14
je     11e2 <enc+0x72>
mov    %rax,%rbx
test   %rax,%rax
je     11eb <enc+0x7b>
mov    %r14,%rdi
call   1060 <feof@plt>
test   %eax,%eax
je     1208 <enc+0x98>
mov    %r14,%rdi
call   1030 <fclose@plt>
mov    %rbx,%rdi
call   1030 <fclose@plt>
add    $0x488,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xe8b(%rip),%rdi
jmp    11f2 <enc+0x82>
lea    0xe9c(%rip),%rdi
add    $0x488,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1080 <error@plt>
xor    %ebp,%ebp
lea    0x300(%rsp),%r13
jmp    1231 <enc+0xc1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14,%rdi
call   1060 <feof@plt>
mov    $0x0,%ebp
test   %eax,%eax
jne    11c0 <enc+0x50>
mov    %r14,%rdi
call   1040 <fgetc@plt>
mov    %al,0x400(%rsp,%rbp,1)
add    $0x1,%rbp
cmp    $0x80,%rbp
jne    1231 <enc+0xc1>
xor    %eax,%eax
movdqa 0xda9(%rip),%xmm4
movdqa 0xdb1(%rip),%xmm5
movdqa 0xdb9(%rip),%xmm6
movdqa 0xdc1(%rip),%xmm7
nop
movdqa 0x400(%rsp,%rax,4),%xmm0
movdqa %xmm0,%xmm1
pand   %xmm4,%xmm1
movdqa %xmm0,%xmm2
psrlw  $0x8,%xmm2
movdqa %xmm2,%xmm3
pand   %xmm4,%xmm3
pslld  $0x8,%xmm3
pand   %xmm5,%xmm3
por    %xmm1,%xmm3
pslld  $0x18,%xmm2
psrad  $0x1f,%xmm2
movdqa %xmm2,%xmm1
pandn  %xmm3,%xmm1
por    %xmm6,%xmm3
pand   %xmm2,%xmm3
por    %xmm1,%xmm3
movdqa %xmm3,0x100(%rsp,%rax,4)
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pand   %xmm7,%xmm1
psrld  $0x18,%xmm0
pslld  $0x18,%xmm0
psrad  $0x1f,%xmm0
movdqa %xmm0,%xmm2
pandn  %xmm1,%xmm2
por    %xmm6,%xmm1
pand   %xmm0,%xmm1
por    %xmm2,%xmm1
movdqa %xmm1,0x180(%rsp,%rax,4)
add    $0x4,%rax
cmp    $0x20,%rax
jne    1270 <enc+0x100>
cvtdq2ps 0x100(%rsp),%xmm0
movaps 0xd24(%rip),%xmm1
mulps  %xmm1,%xmm0
movaps %xmm0,(%rsp)
cvtdq2ps 0x110(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0x10(%rsp)
cvtdq2ps 0x120(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0x20(%rsp)
cvtdq2ps 0x130(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0x30(%rsp)
cvtdq2ps 0x140(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0x40(%rsp)
cvtdq2ps 0x150(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0x50(%rsp)
cvtdq2ps 0x160(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0x60(%rsp)
cvtdq2ps 0x170(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0x70(%rsp)
cvtdq2ps 0x180(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0x80(%rsp)
cvtdq2ps 0x190(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0x90(%rsp)
cvtdq2ps 0x1a0(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0xa0(%rsp)
cvtdq2ps 0x1b0(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0xb0(%rsp)
cvtdq2ps 0x1c0(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0xc0(%rsp)
cvtdq2ps 0x1d0(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0xd0(%rsp)
cvtdq2ps 0x1e0(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0xe0(%rsp)
cvtdq2ps 0x1f0(%rsp),%xmm0
mulps  %xmm1,%xmm0
movaps %xmm0,0xf0(%rsp)
mov    %rsp,%rdi
lea    0x380(%rsp),%rsi
call   1070 <edct@plt>
lea    0x80(%rsp),%rdi
mov    %r13,%rsi
call   1070 <edct@plt>
xor    %eax,%eax
movaps 0xbfc(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x380(%rsp,%rax,4),%xmm0
movsd  0x388(%rsp,%rax,4),%xmm1
mulps  %xmm4,%xmm0
cvttps2dq %xmm0,%xmm0
movsd  0x300(%rsp,%rax,4),%xmm2
movsd  0x308(%rsp,%rax,4),%xmm3
mulps  %xmm4,%xmm2
cvttps2dq %xmm2,%xmm2
punpckldq %xmm2,%xmm0
movdqa %xmm0,0x200(%rsp,%rax,8)
mulps  %xmm4,%xmm1
cvttps2dq %xmm1,%xmm0
mulps  %xmm4,%xmm3
cvttps2dq %xmm3,%xmm1
punpckldq %xmm1,%xmm0
movdqa %xmm0,0x210(%rsp,%rax,8)
add    $0x4,%rax
cmp    $0x20,%rax
jne    1460 <enc+0x2f0>
mov    $0xfffffffffffffff8,%r12
jmp    14de <enc+0x36e>
nopl   (%rax)
add    $0x8,%r12
cmp    $0x38,%r12
jae    1220 <enc+0xb0>
movzbl 0x220(%rsp,%r12,4),%r15d
test   %r15d,%r15d
setne  %al
shl    $0x7,%al
lea    0x40(%rax),%ecx
cmpb   $0x0,0x224(%rsp,%r12,4)
movzbl %al,%eax
movzbl %cl,%ecx
cmove  %eax,%ecx
cmpb   $0x0,0x228(%rsp,%r12,4)
lea    0x20(%rcx),%eax
movzbl %al,%eax
cmove  %ecx,%eax
mov    %eax,%ecx
or     $0x10,%cl
movdqu 0x22c(%rsp,%r12,4),%xmm0
pand   0xad2(%rip),%xmm0
pcmpeqd 0xb2a(%rip),%xmm0
movmskps %xmm0,%edx
movzbl %cl,%ecx
test   $0x1,%dl
cmovne %eax,%ecx
mov    %ecx,%eax
or     $0x8,%al
movzbl %al,%eax
test   $0x2,%dl
cmovne %ecx,%eax
mov    %eax,%ecx
or     $0x4,%cl
movzbl %cl,%ecx
test   $0x4,%dl
cmovne %eax,%ecx
mov    %ecx,%eax
or     $0x2,%al
movzbl %al,%eax
test   $0x8,%dl
cmovne %ecx,%eax
cmpb   $0x0,0x23c(%rsp,%r12,4)
setne  %cl
or     %al,%cl
movsbl %cl,%edi
mov    %rbx,%rsi
call   1050 <fputc@plt>
test   %r15d,%r15d
je     1593 <enc+0x423>
mov    %r15d,%edi
mov    %rbx,%rsi
call   1050 <fputc@plt>
movzbl 0x224(%rsp,%r12,4),%edi
test   %edi,%edi
je     15a8 <enc+0x438>
mov    %rbx,%rsi
call   1050 <fputc@plt>
movzbl 0x228(%rsp,%r12,4),%edi
test   %edi,%edi
je     15bd <enc+0x44d>
mov    %rbx,%rsi
call   1050 <fputc@plt>
movzbl 0x22c(%rsp,%r12,4),%edi
test   %edi,%edi
je     15d2 <enc+0x462>
mov    %rbx,%rsi
call   1050 <fputc@plt>
movzbl 0x230(%rsp,%r12,4),%edi
test   %edi,%edi
je     15e7 <enc+0x477>
mov    %rbx,%rsi
call   1050 <fputc@plt>
movzbl 0x234(%rsp,%r12,4),%edi
test   %edi,%edi
je     15fc <enc+0x48c>
mov    %rbx,%rsi
call   1050 <fputc@plt>
movzbl 0x238(%rsp,%r12,4),%edi
test   %edi,%edi
je     1611 <enc+0x4a1>
mov    %rbx,%rsi
call   1050 <fputc@plt>
movzbl 0x23c(%rsp,%r12,4),%edi
test   %edi,%edi
je     14d0 <enc+0x360>
mov    %rbx,%rsi
call   1050 <fputc@plt>
jmp    14d0 <enc+0x360>

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

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