#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 */
struct timespec {
  int dummy;
};

/* Variables and functions */
int /*<<< orphan*/ CLOCK_REALTIME;
int /*<<< orphan*/ clock_gettime(int /*<<< orphan*/, struct timespec *);
int /*<<< orphan*/ write08(char *, unsigned int, int);
int /*<<< orphan*/ write16(char *, unsigned int, int);
int /*<<< orphan*/ write32(char *, unsigned int, unsigned int);
int _config_GC4016(char *BASE1, int print, unsigned long *GC4016_addrs,
                   int *resampcoeffs, unsigned int *resampratio) {
  int i = 0, j, k;
  unsigned int GC314FS_GCoffset[3] = {0x800, 0x1000, 0x1800};
  unsigned int chan_control_map[4] = {0x00, 0x80, 0x100, 0x180};
  struct timespec start, stop;
  unsigned int *to_write;
  clock_gettime(CLOCK_REALTIME, &start);
  for (k = 0; k < 3; k++) {
    write08(BASE1, GC314FS_GCoffset[k] + 0x444, 0x00);
    write08(BASE1, GC314FS_GCoffset[k] + 0x400, 0x2f);
    write08(BASE1, GC314FS_GCoffset[k] + 0x45c, 0x02);
    write08(BASE1, GC314FS_GCoffset[k] + 0x401, 0x07);
    write08(BASE1, GC314FS_GCoffset[k] + 0x402, 0xe4);
    write08(BASE1, GC314FS_GCoffset[k] + 0x403, 0x17);
    write08(BASE1, GC314FS_GCoffset[k] + 0x404, 0xe4);
    write08(BASE1, GC314FS_GCoffset[k] + 0x405, 0x70);
    write08(BASE1, GC314FS_GCoffset[k] + 0x406, 0x00);
    write08(BASE1, GC314FS_GCoffset[k] + 0x407, 0xe4);
    write32(BASE1, GC314FS_GCoffset[k] + 0x410, resampratio[0]);
    write32(BASE1, GC314FS_GCoffset[k] + 0x414, resampratio[1]);
    write32(BASE1, GC314FS_GCoffset[k] + 0x418, resampratio[2]);
    write32(BASE1, GC314FS_GCoffset[k] + 0x41c, resampratio[3]);
    write08(BASE1, GC314FS_GCoffset[k] + 0x444, 0x00);
    write08(BASE1, GC314FS_GCoffset[k] + 0x445, 0x00);
    write16(BASE1, GC314FS_GCoffset[k] + 0x446, 0xffff);
    write08(BASE1, GC314FS_GCoffset[k] + 0x450, 0xff);
    write08(BASE1, GC314FS_GCoffset[k] + 0x451, 0x4e);
    write08(BASE1, GC314FS_GCoffset[k] + 0x452, 0x6c);
    write08(BASE1, GC314FS_GCoffset[k] + 0x453, 0xc0);
    write08(BASE1, GC314FS_GCoffset[k] + 0x454, 0xe8);
    write08(BASE1, GC314FS_GCoffset[k] + 0x455, 0x03);
    write08(BASE1, GC314FS_GCoffset[k] + 0x456, 0xe4);
    write08(BASE1, GC314FS_GCoffset[k] + 0x457, 0x10);
    write08(BASE1, GC314FS_GCoffset[k] + 0x458, 0x32);
    write08(BASE1, GC314FS_GCoffset[k] + 0x459, 0x54);
    write08(BASE1, GC314FS_GCoffset[k] + 0x45a, 0x76);
    for (i = 0; i < 128; i++) {
      *((unsigned int *)(BASE1 + GC314FS_GCoffset[k] + 0x200 + 4 * i)) =
          resampcoeffs[i];
    }
    for (i = 0; i < 4; i++) {
      to_write = (unsigned int *)GC4016_addrs[i];
      for (j = 0; j < 32; j++) {
        *((unsigned int *)(BASE1 + GC314FS_GCoffset[k] + chan_control_map[i] +
                           4 * j)) = to_write[j];
      }
      write08(BASE1, GC314FS_GCoffset[k] + chan_control_map[i] + 0x7b,
              k | 0x10);
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<_config_GC4016>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    0xe97(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xe95(%rip),%eax
mov    %eax,-0x38(%rbp)
mov    0xe93(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    0xe90(%rip),%rax
mov    %rax,-0x48(%rbp)
mov    0x2e4d(%rip),%rax
mov    (%rax),%edi
lea    -0x58(%rbp),%rsi
call   1040 <clock_gettime@plt>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    15ba <_config_GC4016+0x47a>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x444,%esi
xor    %edx,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x400,%esi
mov    $0x2f,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x45c,%esi
mov    $0x2,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x401,%esi
mov    $0x7,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x402,%esi
mov    $0xe4,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x403,%esi
mov    $0x17,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x404,%esi
mov    $0xe4,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x405,%esi
mov    $0x70,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x406,%esi
xor    %edx,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x407,%esi
mov    $0xe4,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x410,%esi
mov    -0x28(%rbp),%rax
mov    (%rax),%edx
call   1030 <write32@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x414,%esi
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%edx
call   1030 <write32@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x418,%esi
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%edx
call   1030 <write32@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x41c,%esi
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%edx
call   1030 <write32@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x444,%esi
xor    %edx,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x445,%esi
xor    %edx,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x446,%esi
mov    $0xffff,%edx
call   1060 <write16@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x450,%esi
mov    $0xff,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x451,%esi
mov    $0x4e,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x452,%esi
mov    $0x6c,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x453,%esi
mov    $0xc0,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x454,%esi
mov    $0xe8,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x455,%esi
mov    $0x3,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x456,%esi
mov    $0xe4,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x457,%esi
mov    $0x10,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x458,%esi
mov    $0x32,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x459,%esi
mov    $0x54,%edx
call   1050 <write08@plt>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
add    $0x45a,%esi
mov    $0x76,%edx
call   1050 <write08@plt>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x80,-0x2c(%rbp)
jge    1506 <_config_GC4016+0x3c6>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    -0x40(%rbp,%rcx,4),%ecx
add    %rcx,%rax
mov    -0x2c(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,0x200(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14c1 <_config_GC4016+0x381>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x4,-0x2c(%rbp)
jge    15a7 <_config_GC4016+0x467>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x30(%rbp)
cmpl   $0x20,-0x30(%rbp)
jge    1577 <_config_GC4016+0x437>
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    -0x40(%rbp,%rcx,4),%ecx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    -0x50(%rbp,%rcx,4),%ecx
add    %rcx,%rax
mov    -0x30(%rbp),%ecx
shl    $0x2,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    152e <_config_GC4016+0x3ee>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
mov    -0x40(%rbp,%rax,4),%esi
movslq -0x2c(%rbp),%rax
add    -0x50(%rbp,%rax,4),%esi
add    $0x7b,%esi
mov    -0x34(%rbp),%edx
or     $0x10,%edx
call   1050 <write08@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    150d <_config_GC4016+0x3cd>
jmp    15ac <_config_GC4016+0x46c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a5 <_config_GC4016+0x65>
mov    $0x1,%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_config_GC4016>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,0x30(%rsp)
mov    %rcx,%rbx
mov    %rdx,0x28(%rsp)
mov    %rdi,%r15
mov    0x2e7b(%rip),%rax
mov    (%rax),%edi
lea    0x40(%rsp),%rsi
call   1040 <clock_gettime@plt>
lea    0x200(%r15),%rax
mov    %rax,0x18(%rsp)
lea    0x400(%r15),%rax
mov    %rax,0x8(%rsp)
lea    0x200(%rbx),%rax
mov    %rax,0x10(%rsp)
lea    0x20c(%r15),%rax
mov    %rax,(%rsp)
xor    %r12d,%r12d
mov    %rbx,0x20(%rsp)
nopl   0x0(%rax,%rax,1)
lea    0xe49(%rip),%rax
mov    (%rax,%r12,4),%r13d
lea    0x444(%r13),%r14d
mov    %r15,%rdi
mov    %r14d,%esi
xor    %edx,%edx
call   1050 <write08@plt>
lea    0x400(%r13),%esi
mov    %r15,%rdi
mov    $0x2f,%edx
call   1050 <write08@plt>
lea    0x45c(%r13),%esi
mov    %r15,%rdi
mov    $0x2,%edx
call   1050 <write08@plt>
lea    0x401(%r13),%esi
mov    %r15,%rdi
mov    $0x7,%edx
call   1050 <write08@plt>
lea    0x402(%r13),%esi
mov    %r15,%rdi
mov    $0xe4,%edx
call   1050 <write08@plt>
lea    0x403(%r13),%esi
mov    %r15,%rdi
mov    $0x17,%edx
call   1050 <write08@plt>
lea    0x404(%r13),%esi
mov    %r15,%rdi
mov    $0xe4,%edx
call   1050 <write08@plt>
lea    0x405(%r13),%esi
mov    %r15,%rdi
mov    $0x70,%edx
call   1050 <write08@plt>
lea    0x406(%r13),%esi
mov    %r15,%rdi
xor    %edx,%edx
call   1050 <write08@plt>
lea    0x407(%r13),%esi
mov    %r15,%rdi
mov    $0xe4,%edx
call   1050 <write08@plt>
lea    0x410(%r13),%esi
mov    0x30(%rsp),%rbp
mov    0x0(%rbp),%edx
mov    %r15,%rdi
call   1030 <write32@plt>
lea    0x414(%r13),%esi
mov    0x4(%rbp),%edx
mov    %r15,%rdi
call   1030 <write32@plt>
lea    0x418(%r13),%esi
mov    0x8(%rbp),%edx
mov    %r15,%rdi
call   1030 <write32@plt>
lea    0x41c(%r13),%esi
mov    0xc(%rbp),%edx
mov    %r15,%rdi
call   1030 <write32@plt>
mov    %r15,%rdi
mov    %r14d,%esi
xor    %edx,%edx
call   1050 <write08@plt>
lea    0x445(%r13),%esi
mov    %r15,%rdi
xor    %edx,%edx
call   1050 <write08@plt>
lea    0x446(%r13),%esi
mov    %r15,%rdi
mov    $0xffff,%edx
call   1060 <write16@plt>
lea    0x450(%r13),%esi
mov    %r15,%rdi
mov    $0xff,%edx
call   1050 <write08@plt>
lea    0x451(%r13),%esi
mov    %r15,%rdi
mov    $0x4e,%edx
call   1050 <write08@plt>
lea    0x452(%r13),%esi
mov    %r15,%rdi
mov    $0x6c,%edx
call   1050 <write08@plt>
lea    0x453(%r13),%esi
mov    %r15,%rdi
mov    $0xc0,%edx
call   1050 <write08@plt>
lea    0x454(%r13),%esi
mov    %r15,%rdi
mov    $0xe8,%edx
call   1050 <write08@plt>
lea    0x455(%r13),%esi
mov    %r15,%rdi
mov    $0x3,%edx
call   1050 <write08@plt>
lea    0x456(%r13),%esi
mov    %r15,%rdi
mov    $0xe4,%edx
call   1050 <write08@plt>
lea    0x457(%r13),%esi
mov    %r15,%rdi
mov    $0x10,%edx
call   1050 <write08@plt>
lea    0x458(%r13),%esi
mov    %r15,%rdi
mov    $0x32,%edx
call   1050 <write08@plt>
lea    0x459(%r13),%esi
mov    %r15,%rdi
mov    $0x54,%edx
call   1050 <write08@plt>
lea    0x45a(%r13),%esi
mov    %r15,%rdi
mov    $0x76,%edx
call   1050 <write08@plt>
mov    0x18(%rsp),%rax
add    %r13,%rax
cmp    0x10(%rsp),%rax
jae    1430 <_config_GC4016+0x2f0>
mov    0x8(%rsp),%rcx
add    %r13,%rcx
cmp    %rbx,%rcx
jbe    1430 <_config_GC4016+0x2f0>
mov    (%rsp),%rax
add    %r13,%rax
xor    %ecx,%ecx
mov    (%rbx,%rcx,4),%edx
mov    %edx,-0xc(%rax,%rcx,4)
mov    0x4(%rbx,%rcx,4),%edx
mov    %edx,-0x8(%rax,%rcx,4)
mov    0x8(%rbx,%rcx,4),%edx
mov    %edx,-0x4(%rax,%rcx,4)
mov    0xc(%rbx,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
add    $0x4,%rcx
cmp    $0x80,%rcx
jne    1400 <_config_GC4016+0x2c0>
jmp    15be <_config_GC4016+0x47e>
movups (%rbx),%xmm0
movups 0x10(%rbx),%xmm1
movups %xmm0,(%rax)
movups %xmm1,0x10(%rax)
movups 0x20(%rbx),%xmm0
movups 0x30(%rbx),%xmm1
movups %xmm0,0x20(%rax)
movups %xmm1,0x30(%rax)
movups 0x40(%rbx),%xmm0
movups 0x50(%rbx),%xmm1
movups %xmm0,0x40(%rax)
movups %xmm1,0x50(%rax)
movups 0x60(%rbx),%xmm0
movups 0x70(%rbx),%xmm1
movups %xmm0,0x60(%rax)
movups %xmm1,0x70(%rax)
movups 0x80(%rbx),%xmm0
movups 0x90(%rbx),%xmm1
movups %xmm0,0x80(%rax)
movups %xmm1,0x90(%rax)
movups 0xa0(%rbx),%xmm0
movups 0xb0(%rbx),%xmm1
movups %xmm0,0xa0(%rax)
movups %xmm1,0xb0(%rax)
movups 0xc0(%rbx),%xmm0
movups 0xd0(%rbx),%xmm1
movups %xmm0,0xc0(%rax)
movups %xmm1,0xd0(%rax)
movups 0xe0(%rbx),%xmm0
movups 0xf0(%rbx),%xmm1
movups %xmm0,0xe0(%rax)
movups %xmm1,0xf0(%rax)
movups 0x100(%rbx),%xmm0
movups 0x110(%rbx),%xmm1
movups %xmm0,0x100(%rax)
movups %xmm1,0x110(%rax)
movups 0x120(%rbx),%xmm0
movups 0x130(%rbx),%xmm1
movups %xmm0,0x120(%rax)
movups %xmm1,0x130(%rax)
movups 0x140(%rbx),%xmm0
movups 0x150(%rbx),%xmm1
movups %xmm0,0x140(%rax)
movups %xmm1,0x150(%rax)
movups 0x160(%rbx),%xmm0
movups 0x170(%rbx),%xmm1
movups %xmm0,0x160(%rax)
movups %xmm1,0x170(%rax)
movups 0x180(%rbx),%xmm0
movups 0x190(%rbx),%xmm1
movups %xmm0,0x180(%rax)
movups %xmm1,0x190(%rax)
movups 0x1a0(%rbx),%xmm0
movups 0x1b0(%rbx),%xmm1
movups %xmm0,0x1a0(%rax)
movups %xmm1,0x1b0(%rax)
movups 0x1c0(%rbx),%xmm0
movups 0x1d0(%rbx),%xmm1
movups %xmm0,0x1c0(%rax)
movups %xmm1,0x1d0(%rax)
movups 0x1e0(%rbx),%xmm0
movups 0x1f0(%rbx),%xmm1
movups %xmm0,0x1e0(%rax)
movups %xmm1,0x1f0(%rax)
mov    %r13d,%eax
add    %r15,%r13
lea    0x7b(%rax),%r14d
mov    %r12,0x38(%rsp)
mov    %r12d,%ebp
or     $0x10,%ebp
mov    %r15,%rbx
xor    %r15d,%r15d
mov    0x28(%rsp),%r12
lea    0xa2b(%rip),%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12,%r15,2),%rcx
mov    (%r15,%rax,1),%eax
mov    (%rcx),%edx
mov    %edx,0x0(%r13,%rax,1)
mov    0x4(%rcx),%edx
mov    %edx,0x4(%r13,%rax,1)
mov    0x8(%rcx),%edx
mov    %edx,0x8(%r13,%rax,1)
mov    0xc(%rcx),%edx
mov    %edx,0xc(%r13,%rax,1)
mov    0x10(%rcx),%edx
mov    %edx,0x10(%r13,%rax,1)
mov    0x14(%rcx),%edx
mov    %edx,0x14(%r13,%rax,1)
mov    0x18(%rcx),%edx
mov    %edx,0x18(%r13,%rax,1)
mov    0x1c(%rcx),%edx
mov    %edx,0x1c(%r13,%rax,1)
mov    0x20(%rcx),%edx
mov    %edx,0x20(%r13,%rax,1)
mov    0x24(%rcx),%edx
mov    %edx,0x24(%r13,%rax,1)
mov    0x28(%rcx),%edx
mov    %edx,0x28(%r13,%rax,1)
mov    0x2c(%rcx),%edx
mov    %edx,0x2c(%r13,%rax,1)
mov    0x30(%rcx),%edx
mov    %edx,0x30(%r13,%rax,1)
mov    0x34(%rcx),%edx
mov    %edx,0x34(%r13,%rax,1)
mov    0x38(%rcx),%edx
mov    %edx,0x38(%r13,%rax,1)
mov    0x3c(%rcx),%edx
mov    %edx,0x3c(%r13,%rax,1)
mov    0x40(%rcx),%edx
mov    %edx,0x40(%r13,%rax,1)
mov    0x44(%rcx),%edx
mov    %edx,0x44(%r13,%rax,1)
mov    0x48(%rcx),%edx
mov    %edx,0x48(%r13,%rax,1)
mov    0x4c(%rcx),%edx
mov    %edx,0x4c(%r13,%rax,1)
mov    0x50(%rcx),%edx
mov    %edx,0x50(%r13,%rax,1)
mov    0x54(%rcx),%edx
mov    %edx,0x54(%r13,%rax,1)
mov    0x58(%rcx),%edx
mov    %edx,0x58(%r13,%rax,1)
mov    0x5c(%rcx),%edx
mov    %edx,0x5c(%r13,%rax,1)
mov    0x60(%rcx),%edx
mov    %edx,0x60(%r13,%rax,1)
mov    0x64(%rcx),%edx
mov    %edx,0x64(%r13,%rax,1)
mov    0x68(%rcx),%edx
mov    %edx,0x68(%r13,%rax,1)
mov    0x6c(%rcx),%edx
mov    %edx,0x6c(%r13,%rax,1)
mov    0x70(%rcx),%edx
mov    %edx,0x70(%r13,%rax,1)
mov    0x74(%rcx),%edx
mov    %edx,0x74(%r13,%rax,1)
mov    0x78(%rcx),%edx
mov    %edx,0x78(%r13,%rax,1)
mov    0x7c(%rcx),%ecx
mov    %ecx,0x7c(%r13,%rax,1)
lea    (%r14,%rax,1),%esi
mov    %rbx,%rdi
mov    %ebp,%edx
call   1050 <write08@plt>
lea    0x904(%rip),%rax
add    $0x4,%r15
cmp    $0x10,%r15
jne    15f0 <_config_GC4016+0x4b0>
mov    0x38(%rsp),%r12
add    $0x1,%r12
cmp    $0x3,%r12
mov    %rbx,%r15
mov    0x20(%rsp),%rbx
jne    11b0 <_config_GC4016+0x70>
mov    $0x1,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.timespec = type { i32 }
@__const._config_GC4016.GC314FS_GCoffset = [3 x i32] [i32 2048, i32 4096, i32 6144]
@__const._config_GC4016.chan_control_map = [4 x i32] [i32 0, i32 128, i32 256, i32 384]
@CLOCK_REALTIME = global i32 0
define i32 @_config_GC4016(i8* %0, i32 %1, i64* %2, i32* %3, i32* %4) {
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i64*
%9 = alloca i32*
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [3 x i32]
%15 = alloca [4 x i32]
%16 = alloca %struct.timespec
%17 = alloca %struct.timespec
%18 = alloca i32*
store i8* %0, i8** %6
store i32 %1, i32* %7
store i64* %2, i64** %8
store i32* %3, i32** %9
store i32* %4, i32** %10
store i32 0, i32* %11
%19 = bitcast [3 x i32]* %14 to i8*
%20 = bitcast [4 x i32]* %15 to i8*
%21 = load i32, i32* @CLOCK_REALTIME
%22 = call i32 @clock_gettime(i32 %21, %struct.timespec* %16)
store i32 0, i32* %13
br label %23
23: ; preds = %320, %5
%24 = load i32, i32* %13
%25 = icmp slt i32 %24, 3
br i1 %25, label %26, label %323
26: ; preds = %23
%27 = load i8*, i8** %6
%28 = load i32, i32* %13
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %29
%31 = load i32, i32* %30
%32 = add i32 %31, 1092
%33 = call i32 @write08(i8* %27, i32 %32, i32 0)
%34 = load i8*, i8** %6
%35 = load i32, i32* %13
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %36
%38 = load i32, i32* %37
%39 = add i32 %38, 1024
%40 = call i32 @write08(i8* %34, i32 %39, i32 47)
%41 = load i8*, i8** %6
%42 = load i32, i32* %13
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %43
%45 = load i32, i32* %44
%46 = add i32 %45, 1116
%47 = call i32 @write08(i8* %41, i32 %46, i32 2)
%48 = load i8*, i8** %6
%49 = load i32, i32* %13
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %50
%52 = load i32, i32* %51
%53 = add i32 %52, 1025
%54 = call i32 @write08(i8* %48, i32 %53, i32 7)
%55 = load i8*, i8** %6
%56 = load i32, i32* %13
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %57
%59 = load i32, i32* %58
%60 = add i32 %59, 1026
%61 = call i32 @write08(i8* %55, i32 %60, i32 228)
%62 = load i8*, i8** %6
%63 = load i32, i32* %13
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %64
%66 = load i32, i32* %65
%67 = add i32 %66, 1027
%68 = call i32 @write08(i8* %62, i32 %67, i32 23)
%69 = load i8*, i8** %6
%70 = load i32, i32* %13
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %71
%73 = load i32, i32* %72
%74 = add i32 %73, 1028
%75 = call i32 @write08(i8* %69, i32 %74, i32 228)
%76 = load i8*, i8** %6
%77 = load i32, i32* %13
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = add i32 %80, 1029
%82 = call i32 @write08(i8* %76, i32 %81, i32 112)
%83 = load i8*, i8** %6
%84 = load i32, i32* %13
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %85
%87 = load i32, i32* %86
%88 = add i32 %87, 1030
%89 = call i32 @write08(i8* %83, i32 %88, i32 0)
%90 = load i8*, i8** %6
%91 = load i32, i32* %13
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %92
%94 = load i32, i32* %93
%95 = add i32 %94, 1031
%96 = call i32 @write08(i8* %90, i32 %95, i32 228)
%97 = load i8*, i8** %6
%98 = load i32, i32* %13
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %99
%101 = load i32, i32* %100
%102 = add i32 %101, 1040
%103 = load i32*, i32** %10
%104 = getelementptr inbounds i32, i32* %103, i64 0
%105 = load i32, i32* %104
%106 = call i32 @write32(i8* %97, i32 %102, i32 %105)
%107 = load i8*, i8** %6
%108 = load i32, i32* %13
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %109
%111 = load i32, i32* %110
%112 = add i32 %111, 1044
%113 = load i32*, i32** %10
%114 = getelementptr inbounds i32, i32* %113, i64 1
%115 = load i32, i32* %114
%116 = call i32 @write32(i8* %107, i32 %112, i32 %115)
%117 = load i8*, i8** %6
%118 = load i32, i32* %13
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %119
%121 = load i32, i32* %120
%122 = add i32 %121, 1048
%123 = load i32*, i32** %10
%124 = getelementptr inbounds i32, i32* %123, i64 2
%125 = load i32, i32* %124
%126 = call i32 @write32(i8* %117, i32 %122, i32 %125)
%127 = load i8*, i8** %6
%128 = load i32, i32* %13
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %129
%131 = load i32, i32* %130
%132 = add i32 %131, 1052
%133 = load i32*, i32** %10
%134 = getelementptr inbounds i32, i32* %133, i64 3
%135 = load i32, i32* %134
%136 = call i32 @write32(i8* %127, i32 %132, i32 %135)
%137 = load i8*, i8** %6
%138 = load i32, i32* %13
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %139
%141 = load i32, i32* %140
%142 = add i32 %141, 1092
%143 = call i32 @write08(i8* %137, i32 %142, i32 0)
%144 = load i8*, i8** %6
%145 = load i32, i32* %13
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %146
%148 = load i32, i32* %147
%149 = add i32 %148, 1093
%150 = call i32 @write08(i8* %144, i32 %149, i32 0)
%151 = load i8*, i8** %6
%152 = load i32, i32* %13
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %153
%155 = load i32, i32* %154
%156 = add i32 %155, 1094
%157 = call i32 @write16(i8* %151, i32 %156, i32 65535)
%158 = load i8*, i8** %6
%159 = load i32, i32* %13
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %160
%162 = load i32, i32* %161
%163 = add i32 %162, 1104
%164 = call i32 @write08(i8* %158, i32 %163, i32 255)
%165 = load i8*, i8** %6
%166 = load i32, i32* %13
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %167
%169 = load i32, i32* %168
%170 = add i32 %169, 1105
%171 = call i32 @write08(i8* %165, i32 %170, i32 78)
%172 = load i8*, i8** %6
%173 = load i32, i32* %13
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %174
%176 = load i32, i32* %175
%177 = add i32 %176, 1106
%178 = call i32 @write08(i8* %172, i32 %177, i32 108)
%179 = load i8*, i8** %6
%180 = load i32, i32* %13
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %181
%183 = load i32, i32* %182
%184 = add i32 %183, 1107
%185 = call i32 @write08(i8* %179, i32 %184, i32 192)
%186 = load i8*, i8** %6
%187 = load i32, i32* %13
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %188
%190 = load i32, i32* %189
%191 = add i32 %190, 1108
%192 = call i32 @write08(i8* %186, i32 %191, i32 232)
%193 = load i8*, i8** %6
%194 = load i32, i32* %13
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %195
%197 = load i32, i32* %196
%198 = add i32 %197, 1109
%199 = call i32 @write08(i8* %193, i32 %198, i32 3)
%200 = load i8*, i8** %6
%201 = load i32, i32* %13
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %202
%204 = load i32, i32* %203
%205 = add i32 %204, 1110
%206 = call i32 @write08(i8* %200, i32 %205, i32 228)
%207 = load i8*, i8** %6
%208 = load i32, i32* %13
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %209
%211 = load i32, i32* %210
%212 = add i32 %211, 1111
%213 = call i32 @write08(i8* %207, i32 %212, i32 16)
%214 = load i8*, i8** %6
%215 = load i32, i32* %13
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %216
%218 = load i32, i32* %217
%219 = add i32 %218, 1112
%220 = call i32 @write08(i8* %214, i32 %219, i32 50)
%221 = load i8*, i8** %6
%222 = load i32, i32* %13
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %223
%225 = load i32, i32* %224
%226 = add i32 %225, 1113
%227 = call i32 @write08(i8* %221, i32 %226, i32 84)
%228 = load i8*, i8** %6
%229 = load i32, i32* %13
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %230
%232 = load i32, i32* %231
%233 = add i32 %232, 1114
%234 = call i32 @write08(i8* %228, i32 %233, i32 118)
store i32 0, i32* %11
br label %235
235: ; preds = %257, %26
%236 = load i32, i32* %11
%237 = icmp slt i32 %236, 128
br i1 %237, label %238, label %260
238: ; preds = %235
%239 = load i32*, i32** %9
%240 = load i32, i32* %11
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32, i32* %239, i64 %241
%243 = load i32, i32* %242
%244 = load i8*, i8** %6
%245 = load i32, i32* %13
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %246
%248 = load i32, i32* %247
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds i8, i8* %244, i64 %249
%251 = getelementptr inbounds i8, i8* %250, i64 512
%252 = load i32, i32* %11
%253 = mul nsw i32 4, %252
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i8, i8* %251, i64 %254
%256 = bitcast i8* %255 to i32*
store i32 %243, i32* %256
br label %257
257: ; preds = %238
%258 = load i32, i32* %11
%259 = add nsw i32 %258, 1
store i32 %259, i32* %11
br label %235
260: ; preds = %235
store i32 0, i32* %11
br label %261
261: ; preds = %316, %260
%262 = load i32, i32* %11
%263 = icmp slt i32 %262, 4
br i1 %263, label %264, label %319
264: ; preds = %261
%265 = load i64*, i64** %8
%266 = load i32, i32* %11
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i64, i64* %265, i64 %267
%269 = load i64, i64* %268
%270 = inttoptr i64 %269 to i32*
store i32* %270, i32** %18
store i32 0, i32* %12
br label %271
271: ; preds = %298, %264
%272 = load i32, i32* %12
%273 = icmp slt i32 %272, 32
br i1 %273, label %274, label %301
274: ; preds = %271
%275 = load i32*, i32** %18
%276 = load i32, i32* %12
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds i32, i32* %275, i64 %277
%279 = load i32, i32* %278
%280 = load i8*, i8** %6
%281 = load i32, i32* %13
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %282
%284 = load i32, i32* %283
%285 = zext i32 %284 to i64
%286 = getelementptr inbounds i8, i8* %280, i64 %285
%287 = load i32, i32* %11
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds [4 x i32], [4 x i32]* %15, i64 0, i64 %288
%290 = load i32, i32* %289
%291 = zext i32 %290 to i64
%292 = getelementptr inbounds i8, i8* %286, i64 %291
%293 = load i32, i32* %12
%294 = mul nsw i32 4, %293
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i8, i8* %292, i64 %295
%297 = bitcast i8* %296 to i32*
store i32 %279, i32* %297
br label %298
298: ; preds = %274
%299 = load i32, i32* %12
%300 = add nsw i32 %299, 1
store i32 %300, i32* %12
br label %271
301: ; preds = %271
%302 = load i8*, i8** %6
%303 = load i32, i32* %13
%304 = sext i32 %303 to i64
%305 = getelementptr inbounds [3 x i32], [3 x i32]* %14, i64 0, i64 %304
%306 = load i32, i32* %305
%307 = load i32, i32* %11
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds [4 x i32], [4 x i32]* %15, i64 0, i64 %308
%310 = load i32, i32* %309
%311 = add i32 %306, %310
%312 = add i32 %311, 123
%313 = load i32, i32* %13
%314 = or i32 %313, 16
%315 = call i32 @write08(i8* %302, i32 %312, i32 %314)
br label %316
316: ; preds = %301
%317 = load i32, i32* %11
%318 = add nsw i32 %317, 1
store i32 %318, i32* %11
br label %261
319: ; preds = %261
br label %320
320: ; preds = %319
%321 = load i32, i32* %13
%322 = add nsw i32 %321, 1
store i32 %322, i32* %13
br label %23
323: ; preds = %23
ret i32 1
}

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