// File: /workspace/github_c_makefile_star2_O1/mabdi[P]bunney/bunny-main.c
// Function: run_program
static struct bunny_traceitem* run_program(void) {
  struct bunny_traceitem *ret, *ref;
  struct bunny_tracedesc btd;
  _s32 i;
  _u8* infn = 0;
    
  exec_cnt++;
  ret = malloc(sizeof(struct bunny_traceitem));
  if (!ret) fatal("out of memory");

  purge_outflow();
  
  /* Produce input for the traced application. Note that TCP connect()
     will loop until next command on connection refused, so we're cool. */

  if (!write_file && !write_port) {
    infn = N(out_dir,".fake-pipe");
    flow_savefile(infn);
  } else if (write_file)  flow_savefile(write_file);
    else if (!write_host) flow_command(FLOW_TCP_ACCEPT, htons(write_port), 0, 0);
    else flow_command(use_udp ? FLOW_UDP_SEND : FLOW_TCP_CONNECT, write_host, htons(write_port), 0);
  
  if (exec_pid < 0) launch_exec(infn);
    else kill(exec_pid,SIGUSR1);
  
  if (read(exec_pipe_ret,&btd,sizeof(struct bunny_tracedesc)) != sizeof(struct bunny_tracedesc))
    fatal("short trace struct read (see bunny-exec.out)");

  ret->fuzzable     = 0;    
  ret->exit_status  = btd.exit_status;
  ret->thread_count = btd.thread_count;
  ret->exec_cksum   = btd.exec_cksum;
  ret->param_count  = btd.param_count;
  ret->func_count   = btd.func_count;
  ret->func_skip    = btd.func_skip;
  
  /* Grab fault function name, if any */
  if (btd.fault_len) {
    _u8* tmp = malloc(btd.fault_len + 1);
    if (!tmp) fatal("out of memory");
    
    if (read(exec_pipe_ret,tmp,btd.fault_len) != btd.fault_len)
      fatal("short fault location read (see bunny-exec.out)");
      
    tmp[btd.fault_len]  = 0;
    ret->fault_loc      = tmp;
  } else ret->fault_loc = 0;
  
  ret->eff_lwarn    = 0xFFFFFFFF;

  ret->param_data   = malloc(btd.param_count * sizeof(_u32));
  ret->param_range  = malloc(btd.param_count * sizeof(_u64));
  ret->param_chgmap = calloc(1,btd.param_count * sizeof(_u8)); /* zero */

  if (!ret->param_data || !ret->param_range || !ret->param_chgmap) fatal("out of memory");
  
  if (sure_read(exec_pipe_ret,ret->param_data,btd.param_count * sizeof(_u32)) 
      != btd.param_count * sizeof(_u32))
    fatal("short param read, len %u (see bunny-exec.out)",btd.param_count);

  if (allow_dummy)  ret->exit_status &= ~EXITF_NOCALLS;

  ref = lookup_exec(ret->exec_cksum);

  /* If we can look up reference data for checksumming, use it and calculate
     a parameter checksum, also updating the known range for reference
     path; otherwise, just map arguments and default to checksum of 0. */

  if (ref && ref->param_cksum) {

    /* If we're dealing with a crash / stall, and the trace is shorter than
       expected, cut the traced application some slack - on timeouts, there
       is no guarantee that all SHM writes were completed. */

    if ((!btd.exit_status && btd.param_count != ref->param_count) || 
        (btd.exit_status && btd.param_count > ref->param_count))
      fatal("parameter count varies for a known call path %016llx (%u != %u) - bad use of BunnySnoop?", 
        ret->exec_cksum, btd.param_count, ref->param_count);

    for (i=0;i<btd.param_count;i++)
      if (ref->param_range[i] != RANGE64_VOLATILE) {
        _u64 nr = zero_range ? 1 : (full_range ? RANGE64(ret->param_data[i]) : RANGE8(ret->param_data[i]));

        /* Update both the reference data and the current checksum */
        ret->param_range[i]  = nr;

        if (!(ref->param_range[i] & nr)) {
          ref->param_range[i] |= nr;
          ret->param_chgmap[i] = 1;
        }

      } else ret->param_range[i] = RANGE64_VOLATILE;

    do_param_cksum(ret);

  } else {

    for (i=0;i<btd.param_count;i++)
      ret->param_range[i] = zero_range ? 1 : (full_range ? RANGE64(ret->param_data[i]) : RANGE8(ret->param_data[i]));
    
    ret->param_cksum = 0;

  }

  ret->eff  = calloc(1, btd.param_count * sizeof(struct naive_list_int2)); /* zero */
  if (!ret->eff) fatal("out of memory");

  ret->has_eff.c = 0;
  ret->has_eff.v = 0;

  return ret;
  
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
incq 0x84ef(%rip)            # 0x102e0
movl $0x70, %edi
callq 0x2270
testq %rax, %rax
je 0x84a9
movq %rax, %rbx
callq 0x796a
movq 0x846d(%rip), %rdi      # 0x10280
testq %rdi, %rdi
setne %cl
movl 0x8459(%rip), %eax      # 0x10278
testl %eax, %eax
setne %dl
orb %cl, %dl
je 0x7e37
testq %rdi, %rdi
je 0x7e57
callq 0x9f87
xorl %r14d, %r14d
jmp 0x7e93
movq 0x8432(%rip), %rdi      # 0x10270
leaq 0x396f(%rip), %rsi      # 0xb7b4
callq 0x760a
movq %rax, %r14
movq %rax, %rdi
callq 0x9f87
jmp 0x7e93
movl 0x842f(%rip), %esi      # 0x1028c
testl %esi, %esi
je 0x7e7b
movzbl 0x8420(%rip), %ecx      # 0x10288
leal 0x3ea(,%rcx,2), %edi
rolw $0x8, %ax
movzwl %ax, %edx
xorl %r14d, %r14d
jmp 0x7e8c
rolw $0x8, %ax
movzwl %ax, %esi
xorl %r14d, %r14d
movl $0x3eb, %edi            # imm = 0x3EB
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7a97
movl 0x839f(%rip), %edi      # 0x10238
testl %edi, %edi
js 0x7ea9
movl $0xa, %esi
callq 0x22c0
jmp 0x7f14
testq %r14, %r14
je 0x7ec8
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2140
movl %eax, %ebp
testl %eax, %eax
jns 0x7eca
movq %r14, %rdi
callq 0x2902
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x2280
testl %eax, %eax
jne 0x8847
callq 0x2080
movl %eax, 0x8351(%rip)      # 0x10238
testl %eax, %eax
js 0x884c
je 0x8851
movl 0xc(%rsp), %edi
callq 0x23c0
testq %r14, %r14
je 0x7f0a
movl %ebp, %edi
callq 0x23c0
movl 0x8(%rsp), %eax
movl %eax, 0x8330(%rip)      # 0x10244
movl 0x832a(%rip), %edi      # 0x10244
leaq 0x10(%rsp), %rsi
movl $0x28, %edx
callq 0x22e0
cmpq $0x28, %rax
jne 0x852a
movl $0x0, 0x4(%rbx)
movzbl 0x10(%rsp), %eax
movl %eax, (%rbx)
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
movl 0x2c(%rsp), %r14d
movl %r14d, 0x28(%rbx)
movl 0x28(%rsp), %eax
movl %eax, 0x54(%rbx)
movl 0x30(%rsp), %eax
movl %eax, 0x38(%rbx)
movl 0x20(%rsp), %r15d
testq %r15, %r15
je 0x7fa8
leal 0x1(%r15), %edi
callq 0x2270
testq %rax, %rax
je 0x86ae
movq %rax, %r12
movl 0x82b7(%rip), %edi      # 0x10244
movq %rax, %rsi
movq %r15, %rdx
callq 0x22e0
cmpq %r15, %rax
jne 0x872f
movb $0x0, (%r12,%r15)
jmp 0x7fab
xorl %r12d, %r12d
movq %r12, 0x20(%rbx)
movl $0xffffffff, 0x50(%rbx) # imm = 0xFFFFFFFF
leaq (,%r14,4), %rdi
movq %rdi, 0x60(%rsp)
callq 0x2270
movq %rax, %r12
movq %rax, 0x30(%rbx)
leaq (,%r14,8), %rdi
callq 0x2270
movq %rax, %r13
movq %rax, 0x40(%rbx)
movl $0x1, %edi
movq %r14, %rsi
callq 0x2130
movq %rax, 0x48(%rbx)
testq %r12, %r12
je 0x8428
testq %r13, %r13
je 0x8428
testq %rax, %rax
je 0x8428
movl 0x822f(%rip), %ebp      # 0x10244
movq %r14, 0x58(%rsp)
leal (,%r14,4), %r15d
xorl %r13d, %r13d
movl %r15d, %edx
movl %ebp, %edi
movq %r12, %rsi
callq 0x22e0
testl %eax, %eax
jle 0x8049
addl %eax, %r13d
subl %eax, %r15d
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %rcx, %r12
jmp 0x804c
movl %eax, %r14d
testl %eax, %eax
jle 0x8057
testl %r15d, %r15d
jne 0x8025
jmp 0x805a
movl %r14d, %r13d
movslq %r13d, %rax
cmpq %rax, 0x60(%rsp)
jne 0x85ab
cmpb $0x1, 0x8224(%rip)      # 0x10293
jne 0x8074
andb $-0x9, (%rbx)
movq 0x10(%rbx), %r14
movl %r14d, %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, %edx
shll $0x4, %edx
leaq 0x82d4(%rip), %rsi      # 0x10360
movl 0x8(%rdx,%rsi), %ecx
testq %rcx, %rcx
je 0x80b0
addq %rdx, %rsi
movq (%rsi), %rsi
xorl %r15d, %r15d
xorl %edx, %edx
cmpq %r14, (%rsi,%rdx,8)
je 0x80b5
incq %rdx
cmpq %rdx, %rcx
jne 0x80a0
jmp 0x80c7
xorl %r15d, %r15d
jmp 0x80c7
shll $0x4, %eax
leaq 0x182a1(%rip), %rcx     # 0x20360
movq (%rax,%rcx), %rax
movq (%rax,%rdx,8), %r15
testq %r15, %r15
je 0x8288
cmpq $0x0, 0x18(%r15)
je 0x8288
movb 0x10(%rsp), %al
testb %al, %al
jne 0x80f5
movl 0x2c(%rsp), %ecx
cmpl 0x28(%r15), %ecx
jne 0x87b0
testb %al, %al
je 0x8103
movl 0x2c(%rsp), %eax
cmpl 0x28(%r15), %eax
ja 0x87b0
movl 0x2c(%rsp), %eax
testq %rax, %rax
je 0x83dc
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movabsq $0x4000000000000000, %rsi # imm = 0x4000000000000000
movb 0x816a(%rip), %dil      # 0x10295
movb 0x8162(%rip), %r8b      # 0x10294
xorl %r9d, %r9d
movq 0x40(%r15), %r10
cmpq %rdx, (%r10,%r9,8)
jne 0x8149
movq 0x40(%rbx), %rcx
movq %rdx, (%rcx,%r9,8)
jmp 0x8176
movl $0x1, %r14d
testb $0x1, %dil
je 0x8183
movq 0x40(%rbx), %rcx
movq %r14, (%rcx,%r9,8)
movq (%r10,%r9,8), %rcx
testq %r14, %rcx
jne 0x8176
orq %r14, %rcx
movq %rcx, (%r10,%r9,8)
movq 0x48(%rbx), %rcx
movb $0x1, (%rcx,%r9)
incq %r9
cmpq %rax, %r9
jne 0x8135
jmp 0x83dc
movq 0x30(%rbx), %rcx
movl (%rcx,%r9,4), %r11d
testb $0x1, %r8b
je 0x81d1
movl $0x80000000, %r14d      # imm = 0x80000000
testl %r11d, %r11d
je 0x8155
js 0x8230
movq %rsi, %r14
cmpl $0x7fffffff, %r11d      # imm = 0x7FFFFFFF
je 0x8155
movl $0x1d, %ebp
movl $0x1d, %ecx
subl $0x1, %ecx
jb 0x8266
btl %ebp, %r11d
movl %ecx, %ebp
jae 0x81b8
addl $0x2, %ecx
jmp 0x826b
testl %r11d, %r11d
js 0x8155
je 0x825b
movl $0x4, %r14d
cmpl $0x80, %r11d
jl 0x8155
movl $0x8, %r14d
cmpl $0x100, %r11d           # imm = 0x100
jl 0x8155
movl $0x10, %r14d
cmpl $0x8000, %r11d          # imm = 0x8000
jl 0x8155
xorl %r14d, %r14d
cmpl $0x10000, %r11d         # imm = 0x10000
setge %r14b
shll $0x5, %r14d
addq $0x20, %r14
jmp 0x8155
negl %r11d
movl $0x1, %r14d
jo 0x8155
movl $0x1d, %ebp
movl $0x1d, %ecx
subl $0x1, %ecx
jb 0x8270
btl %ebp, %r11d
movl %ecx, %ebp
jae 0x8249
addl $0x2, %ecx
jmp 0x8275
movl $0x2, %r14d
jmp 0x8155
movl $0x1, %ecx
addb $0x1f, %cl
jmp 0x827a
movl $0x1, %ecx
addl $0x20, %ecx
negl %ecx
movl $0x1, %r14d
shlq %cl, %r14
jmp 0x8155
movl 0x2c(%rsp), %eax
testq %rax, %rax
je 0x83d2
movabsq $0x4000000000000000, %rdx # imm = 0x4000000000000000
movb 0x7fef(%rip), %sil      # 0x10295
movb 0x7fe7(%rip), %dil      # 0x10294
movq 0x40(%rbx), %r8
xorl %r9d, %r9d
movl $0x1, %r11d
testb $0x1, %sil
je 0x82d1
movq %r11, (%r8,%r9,8)
incq %r9
cmpq %rax, %r9
jne 0x82b4
jmp 0x83d2
movq 0x30(%rbx), %rcx
movl (%rcx,%r9,4), %r10d
testb $0x1, %dil
je 0x8321
movl $0x80000000, %r11d      # imm = 0x80000000
testl %r10d, %r10d
je 0x82c0
js 0x8378
movq %rdx, %r11
cmpl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
je 0x82c0
movl $0x1d, %r11d
movl $0x1d, %ecx
subl $0x1, %ecx
jb 0x83b0
btl %r11d, %r10d
movl %ecx, %r11d
jae 0x8307
addl $0x2, %ecx
jmp 0x83b5
testl %r10d, %r10d
js 0x82c0
je 0x83a5
movl $0x4, %r11d
cmpl $0x80, %r10d
jl 0x82c0
movl $0x8, %r11d
cmpl $0x100, %r10d           # imm = 0x100
jl 0x82c0
movl $0x10, %r11d
cmpl $0x8000, %r10d          # imm = 0x8000
jl 0x82c0
xorl %r11d, %r11d
cmpl $0x10000, %r10d         # imm = 0x10000
setge %r11b
shll $0x5, %r11d
addq $0x20, %r11
jmp 0x82c0
negl %r10d
movl $0x1, %r11d
jo 0x82c0
movl $0x1d, %r11d
movl $0x1d, %ecx
subl $0x1, %ecx
jb 0x83ba
btl %r11d, %r10d
movl %ecx, %r11d
jae 0x8392
addl $0x2, %ecx
jmp 0x83bf
movl $0x2, %r11d
jmp 0x82c0
movl $0x1, %ecx
addb $0x1f, %cl
jmp 0x83c4
movl $0x1, %ecx
addl $0x20, %ecx
negl %ecx
movl $0x1, %r11d
shlq %cl, %r11
jmp 0x82c0
movq $0x0, 0x18(%rbx)
jmp 0x83e4
movq %rbx, %rdi
callq 0x8db1
movl 0x2c(%rsp), %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x1, %edi
callq 0x2130
movq %rax, 0x58(%rbx)
testq %rax, %rax
je 0x862d
movl $0x0, 0x68(%rbx)
movq $0x0, 0x60(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3169(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x7e2b(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x8458
leaq 0x314f(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2dde(%rip), %rdi      # 0xb23d
leaq 0x48be(%rip), %rsi      # 0xcd24
leaq 0x2de0(%rip), %rdx      # 0xb24d
movl $0x2d9, %ecx            # imm = 0x2D9
xorl %eax, %eax
callq 0x2030
movq 0x7de8(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x883d
leaq 0x2dad(%rip), %rsi      # 0xb23d
leaq 0x488d(%rip), %rdx      # 0xcd24
leaq 0x2daf(%rip), %rcx      # 0xb24d
movl $0x2d9, %r8d            # imm = 0x2D9
jmp 0x8836
leaq 0x30e8(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x7daa(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x84d9
leaq 0x30ce(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2d5d(%rip), %rdi      # 0xb23d
leaq 0x483d(%rip), %rsi      # 0xcd24
leaq 0x2d5f(%rip), %rdx      # 0xb24d
movl $0x2ab, %ecx            # imm = 0x2AB
xorl %eax, %eax
callq 0x2030
movq 0x7d67(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x883d
leaq 0x2d2c(%rip), %rsi      # 0xb23d
leaq 0x480c(%rip), %rdx      # 0xcd24
leaq 0x2d2e(%rip), %rcx      # 0xb24d
movl $0x2ab, %r8d            # imm = 0x2AB
jmp 0x8836
leaq 0x47ff(%rip), %rdi      # 0xcd30
xorl %eax, %eax
callq 0x2030
movq 0x7d29(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x855a
leaq 0x47e5(%rip), %rdi      # 0xcd30
movl $0x43, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2cdc(%rip), %rdi      # 0xb23d
leaq 0x47bc(%rip), %rsi      # 0xcd24
leaq 0x2cde(%rip), %rdx      # 0xb24d
movl $0x2bd, %ecx            # imm = 0x2BD
xorl %eax, %eax
callq 0x2030
movq 0x7ce6(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x883d
leaq 0x2cab(%rip), %rsi      # 0xb23d
leaq 0x478b(%rip), %rdx      # 0xcd24
leaq 0x2cad(%rip), %rcx      # 0xb24d
movl $0x2bd, %r8d            # imm = 0x2BD
jmp 0x8836
leaq 0x4808(%rip), %rdi      # 0xcdba
movq 0x58(%rsp), %rsi
xorl %eax, %eax
callq 0x2030
movq 0x7ca3(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x85dc
movl 0x2c(%rsp), %edx
leaq 0x47e5(%rip), %rsi      # 0xcdba
xorl %eax, %eax
callq 0x22d0
leaq 0x2c5a(%rip), %rdi      # 0xb23d
leaq 0x473a(%rip), %rsi      # 0xcd24
leaq 0x2c5c(%rip), %rdx      # 0xb24d
movl $0x2dd, %ecx            # imm = 0x2DD
xorl %eax, %eax
callq 0x2030
movq 0x7c64(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x883d
leaq 0x2c29(%rip), %rsi      # 0xb23d
leaq 0x4709(%rip), %rdx      # 0xcd24
leaq 0x2c2b(%rip), %rcx      # 0xb24d
movl $0x2dd, %r8d            # imm = 0x2DD
jmp 0x8836
leaq 0x2f64(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x7c26(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x865d
leaq 0x2f4a(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2bd9(%rip), %rdi      # 0xb23d
leaq 0x46b9(%rip), %rsi      # 0xcd24
leaq 0x2bdb(%rip), %rdx      # 0xb24d
movl $0x30c, %ecx            # imm = 0x30C
xorl %eax, %eax
callq 0x2030
movq 0x7be3(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x883d
leaq 0x2ba8(%rip), %rsi      # 0xb23d
leaq 0x4688(%rip), %rdx      # 0xcd24
leaq 0x2baa(%rip), %rcx      # 0xb24d
movl $0x30c, %r8d            # imm = 0x30C
jmp 0x8836
leaq 0x2ee3(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x7ba5(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x86de
leaq 0x2ec9(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2b58(%rip), %rdi      # 0xb23d
leaq 0x4638(%rip), %rsi      # 0xcd24
leaq 0x2b5a(%rip), %rdx      # 0xb24d
movl $0x2ca, %ecx            # imm = 0x2CA
xorl %eax, %eax
callq 0x2030
movq 0x7b62(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x883d
leaq 0x2b27(%rip), %rsi      # 0xb23d
leaq 0x4607(%rip), %rdx      # 0xcd24
leaq 0x2b29(%rip), %rcx      # 0xb24d
movl $0x2ca, %r8d            # imm = 0x2CA
jmp 0x8836
leaq 0x463e(%rip), %rdi      # 0xcd74
xorl %eax, %eax
callq 0x2030
movq 0x7b24(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x875f
leaq 0x4624(%rip), %rdi      # 0xcd74
movl $0x45, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2ad7(%rip), %rdi      # 0xb23d
leaq 0x45b7(%rip), %rsi      # 0xcd24
leaq 0x2ad9(%rip), %rdx      # 0xb24d
movl $0x2cd, %ecx            # imm = 0x2CD
xorl %eax, %eax
callq 0x2030
movq 0x7ae1(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x883d
leaq 0x2aa6(%rip), %rsi      # 0xb23d
leaq 0x4586(%rip), %rdx      # 0xcd24
leaq 0x2aa8(%rip), %rcx      # 0xb24d
movl $0x2cd, %r8d            # imm = 0x2CD
jmp 0x8836
movl 0x2c(%rsp), %ebx
movl 0x28(%r15), %ecx
leaq 0x4640(%rip), %rdi      # 0xcdff
movq %r14, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x2030
movq 0x7a96(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x87ee
movl 0x28(%r15), %r8d
leaq 0x461d(%rip), %rsi      # 0xcdff
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x22d0
leaq 0x2a48(%rip), %rdi      # 0xb23d
leaq 0x4528(%rip), %rsi      # 0xcd24
leaq 0x2a4a(%rip), %rdx      # 0xb24d
movl $0x2f0, %ecx            # imm = 0x2F0
xorl %eax, %eax
callq 0x2030
movq 0x7a52(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x883d
leaq 0x2a1b(%rip), %rsi      # 0xb23d
leaq 0x44fb(%rip), %rdx      # 0xcd24
leaq 0x2a1d(%rip), %rcx      # 0xb24d
movl $0x2f0, %r8d            # imm = 0x2F0
xorl %eax, %eax
callq 0x22d0
movl $0x1, %edi
callq 0x2230
callq 0x2997
callq 0x2c98
movq 0x7a18(%rip), %rdi      # 0x10270
leaq 0x4720(%rip), %rsi      # 0xcf7f
callq 0x760a
movq %rax, %rbx
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
movl $0xc1, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x2140
movl %eax, %ebx
movl %eax, %edi
movl $0x2, %esi
callq 0x21b0
movl %ebx, %edi
callq 0x23c0
leaq 0x46ef(%rip), %rdi      # 0xcf8e
movl $0x1, %esi
xorl %eax, %eax
callq 0x2140
movl %eax, %ebx
movl %eax, %edi
movl $0x1, %esi
callq 0x21b0
movl %ebx, %edi
callq 0x23c0
movl 0xc(%rsp), %edi
movl $0x63, %esi
callq 0x21b0
testl %eax, %eax
jns 0x88d7
callq 0x2c08
movl 0x8(%rsp), %edi
callq 0x23c0
movl 0xc(%rsp), %edi
callq 0x23c0
testq %r14, %r14
jne 0x8992
xorl %edi, %edi
callq 0x23c0
leaq 0x468e(%rip), %rdi      # 0xcf8e
xorl %esi, %esi
xorl %eax, %eax
callq 0x2140
testl %eax, %eax
je 0x89ab
leaq 0x4680(%rip), %rdi      # 0xcf98
xorl %eax, %eax
callq 0x2030
movq 0x7942(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x8941
leaq 0x4666(%rip), %rdi      # 0xcf98
movl $0x37, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x28f5(%rip), %rdi      # 0xb23d
leaq 0x45f8(%rip), %rsi      # 0xcf47
leaq 0x28f7(%rip), %rdx      # 0xb24d
movl $0x26c, %ecx            # imm = 0x26C
xorl %eax, %eax
callq 0x2030
movq 0x78ff(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x883d
leaq 0x28c4(%rip), %rsi      # 0xb23d
leaq 0x45c7(%rip), %rdx      # 0xcf47
leaq 0x28c6(%rip), %rcx      # 0xb24d
movl $0x26c, %r8d            # imm = 0x26C
jmp 0x8836
movl %ebp, %edi
xorl %esi, %esi
callq 0x21b0
testl %eax, %eax
jns 0x89a4
callq 0x2a27
movl %ebp, %edi
callq 0x23c0
leaq 0x10(%rsp), %rdi
callq 0x2ab7