// File: /workspace/github_c_makefile_star2_O3/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 $0x88, %rsp
incq 0x845c(%rip)            # 0x102e0
movl $0x70, %edi
callq 0x2270
testq %rax, %rax
je 0x85b3
movq %rax, %rbp
callq 0x79fa
movq 0x83da(%rip), %rdi      # 0x10280
testq %rdi, %rdi
setne %cl
movl 0x83c6(%rip), %eax      # 0x10278
testl %eax, %eax
setne %dl
orb %cl, %dl
je 0x7eca
testq %rdi, %rdi
je 0x7eea
callq 0x9fb3
xorl %r14d, %r14d
jmp 0x7f26
movq 0x839f(%rip), %rdi      # 0x10270
leaq 0x38dc(%rip), %rsi      # 0xb7b4
callq 0x769c
movq %rax, %r14
movq %rax, %rdi
callq 0x9fb3
jmp 0x7f26
movl 0x839c(%rip), %esi      # 0x1028c
testl %esi, %esi
je 0x7f0e
movzbl 0x838d(%rip), %ecx      # 0x10288
leal 0x3ea(,%rcx,2), %edi
rolw $0x8, %ax
movzwl %ax, %edx
xorl %r14d, %r14d
jmp 0x7f1f
rolw $0x8, %ax
movzwl %ax, %esi
xorl %r14d, %r14d
movl $0x3eb, %edi            # imm = 0x3EB
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x7b27
movl 0x830c(%rip), %edi      # 0x10238
testl %edi, %edi
js 0x7f42
movl $0xa, %esi
callq 0x22c0
movl 0x8304(%rip), %edi      # 0x10244
jmp 0x7fb3
movq %rbp, %rbx
testq %r14, %r14
je 0x7f64
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2140
movl %eax, %ebp
testl %eax, %eax
jns 0x7f66
movq %r14, %rdi
callq 0x2902
xorl %ebp, %ebp
leaq 0x10(%rsp), %rdi
callq 0x2280
testl %eax, %eax
jne 0x88be
callq 0x2080
movl %eax, 0x82b5(%rip)      # 0x10238
testl %eax, %eax
js 0x88c3
je 0x88c8
movl 0x14(%rsp), %edi
callq 0x23c0
testq %r14, %r14
je 0x7fa6
movl %ebp, %edi
callq 0x23c0
movl 0x10(%rsp), %edi
movl %edi, 0x8294(%rip)      # 0x10244
movq %rbx, %rbp
leaq 0x40(%rsp), %rsi
movl $0x28, %edx
callq 0x22e0
cmpq $0x28, %rax
jne 0x8634
movl $0x0, 0x4(%rbp)
movzbl 0x40(%rsp), %eax
movl %eax, 0xc(%rsp)
movl %eax, (%rbp)
movl 0x54(%rsp), %eax
movl %eax, 0x8(%rbp)
movq 0x48(%rsp), %r15
movq %r15, 0x10(%rbp)
movl 0x5c(%rsp), %r14d
movl %r14d, 0x28(%rbp)
movl 0x58(%rsp), %eax
movl %eax, 0x54(%rbp)
movl 0x60(%rsp), %eax
movl %eax, 0x38(%rbp)
movl 0x50(%rsp), %ebx
testq %rbx, %rbx
je 0x8044
leal 0x1(%rbx), %edi
callq 0x2270
testq %rax, %rax
je 0x87b7
movq %rax, %r12
movl 0x821b(%rip), %edi      # 0x10244
movq %rax, %rsi
movq %rbx, %rdx
callq 0x22e0
cmpq %rbx, %rax
jne 0x8835
movb $0x0, (%r12,%rbx)
jmp 0x8047
xorl %r12d, %r12d
movq %r12, 0x20(%rbp)
movl $0xffffffff, 0x50(%rbp) # imm = 0xFFFFFFFF
leaq (,%r14,4), %rdi
movq %rdi, 0x38(%rsp)
callq 0x2270
movq %rax, %rbx
movq %rax, 0x30(%rbp)
leaq (,%r14,8), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2270
movq %rax, %r13
movq %rax, 0x40(%rbp)
movl $0x1, %edi
movq %r14, %rsi
callq 0x2130
movq %rbp, 0x30(%rsp)
movq %rax, 0x48(%rbp)
movq %rbx, 0x18(%rsp)
testq %rbx, %rbx
je 0x8532
testq %r13, %r13
je 0x8532
testq %rax, %rax
je 0x8532
movq %rax, 0x20(%rsp)
movl 0x817f(%rip), %ebx      # 0x10244
movq %r14, (%rsp)
leal (,%r14,4), %r14d
xorl %ebp, %ebp
movq 0x18(%rsp), %r12
movl %r14d, %edx
movl %ebx, %edi
movq %r12, %rsi
callq 0x22e0
testl %eax, %eax
jle 0x80fd
addl %eax, %ebp
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %rcx, %r12
subl %eax, %r14d
jne 0x80d8
jmp 0x80ff
movl %eax, %ebp
movslq %ebp, %rax
cmpq %rax, 0x38(%rsp)
jne 0x86b5
cmpb $0x1, 0x817f(%rip)      # 0x10293
movq 0x30(%rsp), %r12
movq (%rsp), %rdx
movq 0x18(%rsp), %r14
jne 0x812f
movl 0xc(%rsp), %eax
andl $-0x9, %eax
movl %eax, (%r12)
movl %r15d, %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, %edi
shll $0x4, %edi
leaq 0x821d(%rip), %rsi      # 0x10360
movl 0x8(%rdi,%rsi), %ecx
testq %rcx, %rcx
je 0x8319
addq %rdi, %rsi
movq (%rsi), %rsi
xorl %edi, %edi
cmpq %r15, (%rsi,%rdi,8)
je 0x816b
incq %rdi
cmpq %rdi, %rcx
jne 0x8158
jmp 0x8319
shll $0x4, %eax
leaq 0x181eb(%rip), %rcx     # 0x20360
movq (%rax,%rcx), %rax
movq (%rax,%rdi,8), %rbx
testq %rbx, %rbx
je 0x8319
cmpq $0x0, 0x18(%rbx)
je 0x8319
movl 0x28(%rbx), %ecx
cmpl $0x0, 0xc(%rsp)
je 0x84a3
cmpl %ecx, %edx
ja 0x84ab
testq %rdx, %rdx
je 0x8499
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movabsq $0x4000000000000000, %r15 # imm = 0x4000000000000000
movb 0x80ca(%rip), %sil      # 0x10295
movb 0x80c2(%rip), %dil      # 0x10294
xorl %r8d, %r8d
movq 0x40(%rbx), %r9
cmpq %rax, (%r9,%r8,8)
jne 0x81e6
movq %rax, (%r13,%r8,8)
jmp 0x8211
movl $0x1, %r11d
testb $0x1, %sil
je 0x821e
movq %r11, (%r13,%r8,8)
movq (%r9,%r8,8), %rcx
testq %r11, %rcx
jne 0x8211
orq %r11, %rcx
movq %rcx, (%r9,%r8,8)
movq 0x20(%rsp), %rcx
movb $0x1, (%rcx,%r8)
incq %r8
cmpq %rdx, %r8
jne 0x81d5
jmp 0x8499
movl (%r14,%r8,4), %r10d
testb $0x1, %dil
je 0x826a
movl $0x80000000, %r11d      # imm = 0x80000000
testl %r10d, %r10d
je 0x81f2
js 0x82c9
movq %r15, %r11
cmpl $0x7fffffff, %r10d      # imm = 0x7FFFFFFF
je 0x81f2
movl $0x3d, %r11d
movq %r11, %rcx
cmpl $0x20, %ecx
je 0x82f7
leaq -0x20(%rcx), %r14
leaq -0x1(%rcx), %r11
btl %r14d, %r10d
jae 0x824b
jmp 0x82f7
testl %r10d, %r10d
js 0x81f2
je 0x830e
movl $0x4, %r11d
cmpl $0x80, %r10d
jb 0x81f2
movl $0x8, %r11d
cmpl $0x100, %r10d           # imm = 0x100
jb 0x81f2
movl $0x10, %r11d
cmpl $0x8000, %r10d          # imm = 0x8000
jb 0x81f2
xorl %r11d, %r11d
cmpl $0x10000, %r10d         # imm = 0x10000
setae %r11b
shll $0x5, %r11d
addq $0x20, %r11
jmp 0x81f2
negl %r10d
movl $0x1, %r11d
jo 0x81f2
movq $-0x2, %r11
movq %r11, %rcx
cmpl $-0x1f, %ecx
je 0x82f5
leaq 0x1f(%rcx), %r14
leaq -0x1(%rcx), %r11
btl %r14d, %r10d
jae 0x82df
negb %cl
movl $0x1, %r11d
shlq %cl, %r11
movq (%rsp), %rdx
movq 0x18(%rsp), %r14
jmp 0x81f2
movl $0x2, %r11d
jmp 0x81f2
testq %rdx, %rdx
je 0x8448
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movb 0x7f62(%rip), %r11b     # 0x10295
movb 0x7f5a(%rip), %sil      # 0x10294
xorl %edi, %edi
movl $0x1, %r9d
testb $0x1, %r11b
je 0x835a
movq %r9, (%r13,%rdi,8)
incq %rdi
cmpq %rdx, %rdi
jne 0x833c
jmp 0x8448
movl (%r14,%rdi,4), %r8d
testb $0x1, %sil
je 0x83a6
movl $0x80000000, %r9d       # imm = 0x80000000
testl %r8d, %r8d
je 0x8348
js 0x8401
movq %rax, %r9
cmpl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
je 0x8348
movl $0x3d, %r9d
movq %r9, %rcx
cmpl $0x20, %ecx
je 0x842f
leaq -0x20(%rcx), %r10
leaq -0x1(%rcx), %r9
btl %r10d, %r8d
jae 0x8387
jmp 0x842f
testl %r8d, %r8d
js 0x8348
je 0x843d
movl $0x4, %r9d
cmpl $0x80, %r8d
jb 0x8348
movl $0x8, %r9d
cmpl $0x100, %r8d            # imm = 0x100
jb 0x8348
movl $0x10, %r9d
cmpl $0x8000, %r8d           # imm = 0x8000
jb 0x8348
xorl %r9d, %r9d
cmpl $0x10000, %r8d          # imm = 0x10000
setae %r9b
shll $0x5, %r9d
addq $0x20, %r9
jmp 0x8348
negl %r8d
movl $0x1, %r9d
jo 0x8348
movq $-0x2, %r9
movq %r9, %rcx
cmpl $-0x1f, %ecx
je 0x842d
leaq 0x1f(%rcx), %r10
leaq -0x1(%rcx), %r9
btl %r10d, %r8d
jae 0x8417
negb %cl
movl $0x1, %r9d
shlq %cl, %r9
jmp 0x8348
movl $0x2, %r9d
jmp 0x8348
movq $0x0, 0x18(%r12)
movq 0x28(%rsp), %rax
leaq (%rax,%rax,2), %rsi
movl $0x1, %edi
callq 0x2130
movq %rax, 0x58(%r12)
testq %rax, %rax
je 0x8736
movl $0x0, 0x68(%r12)
movq $0x0, 0x60(%r12)
movq %r12, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x8e29
jmp 0x8451
cmpl %ecx, %edx
je 0x81a7
leaq 0x494d(%rip), %rdi      # 0xcdff
movq %r15, %rsi
xorl %eax, %eax
callq 0x2030
movq 0x7da5(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x84e1
movl 0x28(%rbx), %r8d
leaq 0x492c(%rip), %rsi      # 0xcdff
movq %r15, %rdx
movq (%rsp), %rcx
xorl %eax, %eax
callq 0x22d0
leaq 0x2d55(%rip), %rdi      # 0xb23d
leaq 0x4835(%rip), %rsi      # 0xcd24
leaq 0x2d57(%rip), %rdx      # 0xb24d
movl $0x2f0, %ecx            # imm = 0x2F0
xorl %eax, %eax
callq 0x2030
movq 0x7d5f(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x88b4
leaq 0x2d24(%rip), %rsi      # 0xb23d
leaq 0x4804(%rip), %rdx      # 0xcd24
leaq 0x2d26(%rip), %rcx      # 0xb24d
movl $0x2f0, %r8d            # imm = 0x2F0
jmp 0x88ad
leaq 0x305f(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x7d21(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x8562
leaq 0x3045(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2cd4(%rip), %rdi      # 0xb23d
leaq 0x47b4(%rip), %rsi      # 0xcd24
leaq 0x2cd6(%rip), %rdx      # 0xb24d
movl $0x2d9, %ecx            # imm = 0x2D9
xorl %eax, %eax
callq 0x2030
movq 0x7cde(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x88b4
leaq 0x2ca3(%rip), %rsi      # 0xb23d
leaq 0x4783(%rip), %rdx      # 0xcd24
leaq 0x2ca5(%rip), %rcx      # 0xb24d
movl $0x2d9, %r8d            # imm = 0x2D9
jmp 0x88ad
leaq 0x2fde(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x7ca0(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x85e3
leaq 0x2fc4(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2c53(%rip), %rdi      # 0xb23d
leaq 0x4733(%rip), %rsi      # 0xcd24
leaq 0x2c55(%rip), %rdx      # 0xb24d
movl $0x2ab, %ecx            # imm = 0x2AB
xorl %eax, %eax
callq 0x2030
movq 0x7c5d(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x88b4
leaq 0x2c22(%rip), %rsi      # 0xb23d
leaq 0x4702(%rip), %rdx      # 0xcd24
leaq 0x2c24(%rip), %rcx      # 0xb24d
movl $0x2ab, %r8d            # imm = 0x2AB
jmp 0x88ad
leaq 0x46f5(%rip), %rdi      # 0xcd30
xorl %eax, %eax
callq 0x2030
movq 0x7c1f(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x8664
leaq 0x46db(%rip), %rdi      # 0xcd30
movl $0x43, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2bd2(%rip), %rdi      # 0xb23d
leaq 0x46b2(%rip), %rsi      # 0xcd24
leaq 0x2bd4(%rip), %rdx      # 0xb24d
movl $0x2bd, %ecx            # imm = 0x2BD
xorl %eax, %eax
callq 0x2030
movq 0x7bdc(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x88b4
leaq 0x2ba1(%rip), %rsi      # 0xb23d
leaq 0x4681(%rip), %rdx      # 0xcd24
leaq 0x2ba3(%rip), %rcx      # 0xb24d
movl $0x2bd, %r8d            # imm = 0x2BD
jmp 0x88ad
leaq 0x46fe(%rip), %rdi      # 0xcdba
movq (%rsp), %rsi
xorl %eax, %eax
callq 0x2030
movq 0x7b9a(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x86e5
leaq 0x46e0(%rip), %rsi      # 0xcdba
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x22d0
leaq 0x2b51(%rip), %rdi      # 0xb23d
leaq 0x4631(%rip), %rsi      # 0xcd24
leaq 0x2b53(%rip), %rdx      # 0xb24d
movl $0x2dd, %ecx            # imm = 0x2DD
xorl %eax, %eax
callq 0x2030
movq 0x7b5b(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x88b4
leaq 0x2b20(%rip), %rsi      # 0xb23d
leaq 0x4600(%rip), %rdx      # 0xcd24
leaq 0x2b22(%rip), %rcx      # 0xb24d
movl $0x2dd, %r8d            # imm = 0x2DD
jmp 0x88ad
leaq 0x2e5b(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x7b1d(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x8766
leaq 0x2e41(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2ad0(%rip), %rdi      # 0xb23d
leaq 0x45b0(%rip), %rsi      # 0xcd24
leaq 0x2ad2(%rip), %rdx      # 0xb24d
movl $0x30c, %ecx            # imm = 0x30C
xorl %eax, %eax
callq 0x2030
movq 0x7ada(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x88b4
leaq 0x2a9f(%rip), %rsi      # 0xb23d
leaq 0x457f(%rip), %rdx      # 0xcd24
leaq 0x2aa1(%rip), %rcx      # 0xb24d
movl $0x30c, %r8d            # imm = 0x30C
jmp 0x88ad
leaq 0x2dda(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x7a9c(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x87e7
leaq 0x2dc0(%rip), %rdi      # 0xb598
movl $0x24, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x2a4f(%rip), %rdi      # 0xb23d
leaq 0x452f(%rip), %rsi      # 0xcd24
leaq 0x2a51(%rip), %rdx      # 0xb24d
movl $0x2ca, %ecx            # imm = 0x2CA
xorl %eax, %eax
callq 0x2030
movq 0x7a59(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x88b4
leaq 0x2a1e(%rip), %rsi      # 0xb23d
leaq 0x44fe(%rip), %rdx      # 0xcd24
leaq 0x2a20(%rip), %rcx      # 0xb24d
movl $0x2ca, %r8d            # imm = 0x2CA
jmp 0x88ad
leaq 0x4538(%rip), %rdi      # 0xcd74
xorl %eax, %eax
callq 0x2030
movq 0x7a1e(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x8865
leaq 0x451e(%rip), %rdi      # 0xcd74
movl $0x45, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x29d1(%rip), %rdi      # 0xb23d
leaq 0x44b1(%rip), %rsi      # 0xcd24
leaq 0x29d3(%rip), %rdx      # 0xb24d
movl $0x2cd, %ecx            # imm = 0x2CD
xorl %eax, %eax
callq 0x2030
movq 0x79db(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x88b4
leaq 0x29a4(%rip), %rsi      # 0xb23d
leaq 0x4484(%rip), %rdx      # 0xcd24
leaq 0x29a6(%rip), %rcx      # 0xb24d
movl $0x2cd, %r8d            # imm = 0x2CD
xorl %eax, %eax
callq 0x22d0
movl $0x1, %edi
callq 0x2230
callq 0x2997
callq 0x2c98
movq 0x79a1(%rip), %rdi      # 0x10270
leaq 0x46a9(%rip), %rsi      # 0xcf7f
callq 0x769c
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 0x4678(%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 0x14(%rsp), %edi
movl $0x63, %esi
callq 0x21b0
testl %eax, %eax
jns 0x894e
callq 0x2c08
movl 0x10(%rsp), %edi
callq 0x23c0
movl 0x14(%rsp), %edi
callq 0x23c0
testq %r14, %r14
jne 0x8a09
xorl %edi, %edi
callq 0x23c0
leaq 0x4617(%rip), %rdi      # 0xcf8e
xorl %esi, %esi
xorl %eax, %eax
callq 0x2140
testl %eax, %eax
je 0x8a22
leaq 0x4609(%rip), %rdi      # 0xcf98
xorl %eax, %eax
callq 0x2030
movq 0x78cb(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x89b8
leaq 0x45ef(%rip), %rdi      # 0xcf98
movl $0x37, %esi
movl $0x1, %edx
callq 0x23b0
leaq 0x287e(%rip), %rdi      # 0xb23d
leaq 0x4581(%rip), %rsi      # 0xcf47
leaq 0x2880(%rip), %rdx      # 0xb24d
movl $0x26c, %ecx            # imm = 0x26C
xorl %eax, %eax
callq 0x2030
movq 0x7888(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x88b4
leaq 0x284d(%rip), %rsi      # 0xb23d
leaq 0x4550(%rip), %rdx      # 0xcf47
leaq 0x284f(%rip), %rcx      # 0xb24d
movl $0x26c, %r8d            # imm = 0x26C
jmp 0x88ad
movl %ebp, %edi
xorl %esi, %esi
callq 0x21b0
testl %eax, %eax
jns 0x8a1b
callq 0x2a27
movl %ebp, %edi
callq 0x23c0
leaq 0x40(%rsp), %rdi
callq 0x2ab7