// File: /workspace/github_c_makefile_star2_O2/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 0x8e57(%rip)            # 0x102e0
pushq $0x70
popq %rdi
callq 0x2270
testq %rax, %rax
je 0x7a0d
movq %rax, %r13
callq 0x6f18
movq 0x8dd7(%rip), %rdi      # 0x10280
testq %rdi, %rdi
setne %cl
movl 0x8dc3(%rip), %eax      # 0x10278
testl %eax, %eax
setne %dl
orb %cl, %dl
je 0x74cd
testq %rdi, %rdi
je 0x74ed
callq 0x96f7
xorl %r14d, %r14d
jmp 0x7529
movq 0x8d9c(%rip), %rdi      # 0x10270
leaq 0x42d9(%rip), %rsi      # 0xb7b4
callq 0x6b44
movq %rax, %r14
movq %rax, %rdi
callq 0x96f7
jmp 0x7529
movl 0x8d99(%rip), %esi      # 0x1028c
testl %esi, %esi
je 0x7511
movzbl 0x8d8a(%rip), %ecx      # 0x10288
leal 0x3ea(,%rcx,2), %edi
rolw $0x8, %ax
movzwl %ax, %edx
xorl %r14d, %r14d
jmp 0x7522
rolw $0x8, %ax
movzwl %ax, %esi
xorl %r14d, %r14d
movl $0x3eb, %edi            # imm = 0x3EB
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x713e
movl 0x8d09(%rip), %edi      # 0x10238
testl %edi, %edi
js 0x7546
pushq $0xa
popq %rsi
callq 0x22c0
movl 0x8d03(%rip), %edi      # 0x10244
jmp 0x7630
testq %r14, %r14
je 0x75e4
movq %r14, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x2140
movl %eax, %ebp
testl %eax, %eax
jns 0x75e6
leaq 0x59a7(%rip), %rdi      # 0xcf13
movq %r14, %rsi
xorl %eax, %eax
callq 0x2030
movq 0x8ceb(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7593
leaq 0x598a(%rip), %rsi      # 0xcf13
movq %r14, %rdx
xorl %eax, %eax
callq 0x22d0
leaq 0x3ca3(%rip), %rdi      # 0xb23d
leaq 0x59a6(%rip), %rsi      # 0xcf47
leaq 0x3ca5(%rip), %rdx      # 0xb24d
movl $0x246, %ecx            # imm = 0x246
xorl %eax, %eax
callq 0x2030
movq 0x8cad(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x817c
leaq 0x3c72(%rip), %rsi      # 0xb23d
leaq 0x5975(%rip), %rdx      # 0xcf47
leaq 0x3c74(%rip), %rcx      # 0xb24d
movl $0x246, %r8d            # imm = 0x246
jmp 0x8175
xorl %ebp, %ebp
leaq 0x20(%rsp), %rdi
callq 0x2280
testl %eax, %eax
jne 0x7d03
callq 0x2080
movl %eax, 0x8c35(%rip)      # 0x10238
testl %eax, %eax
js 0x7d80
je 0x7dfd
movl 0x24(%rsp), %edi
callq 0x23c0
testq %r14, %r14
je 0x7626
movl %ebp, %edi
callq 0x23c0
movl 0x20(%rsp), %edi
movl %edi, 0x8c14(%rip)      # 0x10244
leaq 0x40(%rsp), %rsi
pushq $0x28
popq %rdx
callq 0x22e0
cmpq $0x28, %rax
jne 0x7a8a
andl $0x0, 0x4(%r13)
movzbl 0x40(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl %eax, (%r13)
movl 0x54(%rsp), %eax
movl %eax, 0x8(%r13)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x10(%r13)
movl 0x5c(%rsp), %r14d
movl %r14d, 0x28(%r13)
movl 0x58(%rsp), %eax
movl %eax, 0x54(%r13)
movl 0x60(%rsp), %eax
movl %eax, 0x38(%r13)
movl 0x50(%rsp), %ebx
testq %rbx, %rbx
je 0x76c6
leal 0x1(%rbx), %edi
callq 0x2270
testq %rax, %rax
je 0x7c05
movq %rax, %r15
movl 0x8b99(%rip), %edi      # 0x10244
movq %rax, %rsi
movq %rbx, %rdx
callq 0x22e0
cmpq %rbx, %rax
jne 0x7c7f
movb $0x0, (%r15,%rbx)
jmp 0x76c9
xorl %r15d, %r15d
movq %r15, 0x20(%r13)
orl $-0x1, 0x50(%r13)
leaq (,%r14,4), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2270
movq %rax, %rbx
movq %rax, 0x30(%r13)
leaq (,%r14,8), %rdi
callq 0x2270
movq %rax, %r12
movq %rax, 0x40(%r13)
pushq $0x1
popq %rdi
movq %r14, %rsi
callq 0x2130
movq %r13, 0x28(%rsp)
movq %rax, 0x38(%rsp)
movq %rax, 0x48(%r13)
movq %rbx, 0x30(%rsp)
testq %rbx, %rbx
je 0x7990
testq %r12, %r12
je 0x7990
cmpq $0x0, 0x38(%rsp)
je 0x7990
movl 0x8b02(%rip), %r13d     # 0x10244
leal (,%r14,4), %ebp
xorl %ebx, %ebx
movq 0x30(%rsp), %r15
movl %ebp, %edx
movl %r13d, %edi
movq %r15, %rsi
callq 0x22e0
testl %eax, %eax
jle 0x7775
addl %eax, %ebx
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %rcx, %r15
subl %eax, %ebp
jne 0x7751
jmp 0x7777
movl %eax, %ebx
movslq %ebx, %rax
cmpq %rax, 0x8(%rsp)
movq %r14, 0x8(%rsp)
jne 0x7b07
cmpb $0x1, 0x8b02(%rip)      # 0x10293
jne 0x77a1
movl 0x1c(%rsp), %eax
andl $-0x9, %eax
movq 0x28(%rsp), %rcx
movl %eax, (%rcx)
movq 0x10(%rsp), %rdi
callq 0x997d
testq %rax, %rax
je 0x7863
movq %rax, %rbp
cmpq $0x0, 0x18(%rax)
je 0x7863
movl 0x28(%rbp), %ecx
cmpl $0x0, 0x1c(%rsp)
je 0x78f8
cmpl %ecx, %r14d
ja 0x7901
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
movb 0x8aab(%rip), %r15b     # 0x10295
movb 0x8aa4(%rip), %al       # 0x10294
movb %al, 0x10(%rsp)
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x78b4
movq 0x40(%rbp), %r13
cmpq %rsi, (%r13,%rbx,8)
jne 0x7810
movq %rsi, (%r12,%rbx,8)
jmp 0x785e
pushq $0x1
popq %rax
testb $0x1, %r15b
jne 0x783f
movq %rsi, %r14
movq 0x30(%rsp), %rax
movl (%rax,%rbx,4), %edi
testb $0x1, 0x10(%rsp)
je 0x7832
callq 0x99c7
jmp 0x7837
callq 0x9a29
movq %r14, %rsi
movq 0x8(%rsp), %r14
movq %rax, (%r12,%rbx,8)
movq (%r13,%rbx,8), %rcx
testq %rax, %rcx
jne 0x785e
orq %rax, %rcx
movq %rcx, (%r13,%rbx,8)
movq 0x38(%rsp), %rax
movb $0x1, (%rax,%rbx)
incq %rbx
jmp 0x77f6
movb 0x8a2c(%rip), %bl       # 0x10295
movb 0x8a24(%rip), %bpl      # 0x10294
xorl %r15d, %r15d
pushq $0x1
popq %r13
cmpq %r15, %r14
je 0x78a8
movq %r13, %rax
testb $0x1, %bl
jne 0x789f
movq 0x30(%rsp), %rax
movl (%rax,%r15,4), %edi
testb $0x1, %bpl
je 0x789a
callq 0x99c7
jmp 0x789f
callq 0x9a29
movq %rax, (%r12,%r15,8)
incq %r15
jmp 0x7877
movq 0x28(%rsp), %rbx
andq $0x0, 0x18(%rbx)
jmp 0x78c1
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x8552
imulq $0x18, %r14, %rsi
pushq $0x1
popq %rdi
callq 0x2130
movq %rax, 0x58(%rbx)
testq %rax, %rax
je 0x7b88
andl $0x0, 0x68(%rbx)
andq $0x0, 0x60(%rbx)
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl %ecx, %r14d
je 0x77d9
leaq 0x54f7(%rip), %rdi      # 0xcdff
movq 0x10(%rsp), %rsi
movl %r14d, %edx
xorl %eax, %eax
callq 0x2030
movq 0x894a(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x793f
movl 0x28(%rbp), %r8d
leaq 0x54d1(%rip), %rsi      # 0xcdff
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
xorl %eax, %eax
callq 0x22d0
leaq 0x38f7(%rip), %rdi      # 0xb23d
leaq 0x53d7(%rip), %rsi      # 0xcd24
leaq 0x38f9(%rip), %rdx      # 0xb24d
movl $0x2f0, %ecx            # imm = 0x2F0
xorl %eax, %eax
callq 0x2030
movq 0x8901(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8188
leaq 0x38c6(%rip), %rsi      # 0xb23d
leaq 0x53a6(%rip), %rdx      # 0xcd24
leaq 0x38c8(%rip), %rcx      # 0xb24d
movl $0x2f0, %r8d            # imm = 0x2F0
jmp 0x7cf7
leaq 0x3c01(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x88c3(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x79bc
leaq 0x3be7(%rip), %rdi      # 0xb598
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x387a(%rip), %rdi      # 0xb23d
leaq 0x535a(%rip), %rsi      # 0xcd24
leaq 0x387c(%rip), %rdx      # 0xb24d
movl $0x2d9, %ecx            # imm = 0x2D9
xorl %eax, %eax
callq 0x2030
movq 0x8884(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8188
leaq 0x3849(%rip), %rsi      # 0xb23d
leaq 0x5329(%rip), %rdx      # 0xcd24
leaq 0x384b(%rip), %rcx      # 0xb24d
movl $0x2d9, %r8d            # imm = 0x2D9
jmp 0x7cf7
leaq 0x3b84(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x8846(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7a39
leaq 0x3b6a(%rip), %rdi      # 0xb598
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x37fd(%rip), %rdi      # 0xb23d
leaq 0x52dd(%rip), %rsi      # 0xcd24
leaq 0x37ff(%rip), %rdx      # 0xb24d
movl $0x2ab, %ecx            # imm = 0x2AB
xorl %eax, %eax
callq 0x2030
movq 0x8807(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8188
leaq 0x37cc(%rip), %rsi      # 0xb23d
leaq 0x52ac(%rip), %rdx      # 0xcd24
leaq 0x37ce(%rip), %rcx      # 0xb24d
movl $0x2ab, %r8d            # imm = 0x2AB
jmp 0x7cf7
leaq 0x529f(%rip), %rdi      # 0xcd30
xorl %eax, %eax
callq 0x2030
movq 0x87c9(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7ab6
leaq 0x5285(%rip), %rdi      # 0xcd30
pushq $0x43
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x3780(%rip), %rdi      # 0xb23d
leaq 0x5260(%rip), %rsi      # 0xcd24
leaq 0x3782(%rip), %rdx      # 0xb24d
movl $0x2bd, %ecx            # imm = 0x2BD
xorl %eax, %eax
callq 0x2030
movq 0x878a(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8188
leaq 0x374f(%rip), %rsi      # 0xb23d
leaq 0x522f(%rip), %rdx      # 0xcd24
leaq 0x3751(%rip), %rcx      # 0xb24d
movl $0x2bd, %r8d            # imm = 0x2BD
jmp 0x7cf7
leaq 0x52ac(%rip), %rdi      # 0xcdba
movl %r14d, %esi
xorl %eax, %eax
callq 0x2030
movq 0x8749(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x7b37
leaq 0x528f(%rip), %rsi      # 0xcdba
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq 0x22d0
leaq 0x36ff(%rip), %rdi      # 0xb23d
leaq 0x51df(%rip), %rsi      # 0xcd24
leaq 0x3701(%rip), %rdx      # 0xb24d
movl $0x2dd, %ecx            # imm = 0x2DD
xorl %eax, %eax
callq 0x2030
movq 0x8709(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8188
leaq 0x36ce(%rip), %rsi      # 0xb23d
leaq 0x51ae(%rip), %rdx      # 0xcd24
leaq 0x36d0(%rip), %rcx      # 0xb24d
movl $0x2dd, %r8d            # imm = 0x2DD
jmp 0x7cf7
leaq 0x3a09(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x86cb(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7bb4
leaq 0x39ef(%rip), %rdi      # 0xb598
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x3682(%rip), %rdi      # 0xb23d
leaq 0x5162(%rip), %rsi      # 0xcd24
leaq 0x3684(%rip), %rdx      # 0xb24d
movl $0x30c, %ecx            # imm = 0x30C
xorl %eax, %eax
callq 0x2030
movq 0x868c(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8188
leaq 0x3651(%rip), %rsi      # 0xb23d
leaq 0x5131(%rip), %rdx      # 0xcd24
leaq 0x3653(%rip), %rcx      # 0xb24d
movl $0x30c, %r8d            # imm = 0x30C
jmp 0x7cf7
leaq 0x398c(%rip), %rdi      # 0xb598
xorl %eax, %eax
callq 0x2030
movq 0x864e(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7c31
leaq 0x3972(%rip), %rdi      # 0xb598
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x3605(%rip), %rdi      # 0xb23d
leaq 0x50e5(%rip), %rsi      # 0xcd24
leaq 0x3607(%rip), %rdx      # 0xb24d
movl $0x2ca, %ecx            # imm = 0x2CA
xorl %eax, %eax
callq 0x2030
movq 0x860f(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8188
leaq 0x35d4(%rip), %rsi      # 0xb23d
leaq 0x50b4(%rip), %rdx      # 0xcd24
leaq 0x35d6(%rip), %rcx      # 0xb24d
movl $0x2ca, %r8d            # imm = 0x2CA
jmp 0x7cf7
leaq 0x50ee(%rip), %rdi      # 0xcd74
xorl %eax, %eax
callq 0x2030
movq 0x85d4(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7cab
leaq 0x50d4(%rip), %rdi      # 0xcd74
pushq $0x45
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x358b(%rip), %rdi      # 0xb23d
leaq 0x506b(%rip), %rsi      # 0xcd24
leaq 0x358d(%rip), %rdx      # 0xb24d
movl $0x2cd, %ecx            # imm = 0x2CD
xorl %eax, %eax
callq 0x2030
movq 0x8595(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8188
leaq 0x355a(%rip), %rsi      # 0xb23d
leaq 0x503a(%rip), %rdx      # 0xcd24
leaq 0x355c(%rip), %rcx      # 0xb24d
movl $0x2cd, %r8d            # imm = 0x2CD
xorl %eax, %eax
callq 0x22d0
jmp 0x8188
leaq 0x5249(%rip), %rdi      # 0xcf53
xorl %eax, %eax
callq 0x2030
movq 0x8550(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7d2f
leaq 0x522f(%rip), %rdi      # 0xcf53
pushq $0x2b
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x3507(%rip), %rdi      # 0xb23d
leaq 0x520a(%rip), %rsi      # 0xcf47
leaq 0x3509(%rip), %rdx      # 0xb24d
movl $0x249, %ecx            # imm = 0x249
xorl %eax, %eax
callq 0x2030
movq 0x8511(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x817c
leaq 0x34d6(%rip), %rsi      # 0xb23d
leaq 0x51d9(%rip), %rdx      # 0xcf47
leaq 0x34d8(%rip), %rcx      # 0xb24d
movl $0x249, %r8d            # imm = 0x249
jmp 0x8175
leaq 0x4538(%rip), %rdi      # 0xc2bf
xorl %eax, %eax
callq 0x2030
movq 0x84d3(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7dac
leaq 0x451e(%rip), %rdi      # 0xc2bf
pushq $0x36
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x348a(%rip), %rdi      # 0xb23d
leaq 0x518d(%rip), %rsi      # 0xcf47
leaq 0x348c(%rip), %rdx      # 0xb24d
movl $0x24c, %ecx            # imm = 0x24C
xorl %eax, %eax
callq 0x2030
movq 0x8494(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x817c
leaq 0x3459(%rip), %rsi      # 0xb23d
leaq 0x515c(%rip), %rdx      # 0xcf47
leaq 0x345b(%rip), %rcx      # 0xb24d
movl $0x24c, %r8d            # imm = 0x24C
jmp 0x8175
movq 0x846c(%rip), %rdi      # 0x10270
leaq 0x5174(%rip), %rsi      # 0xcf7f
callq 0x6b44
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
pushq $0x2
popq %rsi
movl %eax, %edi
callq 0x21b0
movl %ebx, %edi
callq 0x23c0
leaq 0x5145(%rip), %rdi      # 0xcf8e
pushq $0x1
popq %rbx
movl %ebx, %esi
xorl %eax, %eax
callq 0x2140
movl %eax, %r15d
movl %eax, %edi
movl %ebx, %esi
callq 0x21b0
movl %r15d, %edi
callq 0x23c0
movl 0x24(%rsp), %edi
pushq $0x63
popq %rsi
callq 0x21b0
testl %eax, %eax
jns 0x7ef6
leaq 0x4485(%rip), %rdi      # 0xc305
xorl %eax, %eax
callq 0x2030
movq 0x83da(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7ea5
leaq 0x446b(%rip), %rdi      # 0xc305
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x3391(%rip), %rdi      # 0xb23d
leaq 0x5094(%rip), %rsi      # 0xcf47
leaq 0x3393(%rip), %rdx      # 0xb24d
movl $0x262, %ecx            # imm = 0x262
xorl %eax, %eax
callq 0x2030
movq 0x839b(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x817c
leaq 0x3360(%rip), %rsi      # 0xb23d
leaq 0x5063(%rip), %rdx      # 0xcf47
leaq 0x3362(%rip), %rcx      # 0xb24d
movl $0x262, %r8d            # imm = 0x262
jmp 0x8175
movl 0x20(%rsp), %edi
callq 0x23c0
movl 0x24(%rsp), %edi
callq 0x23c0
testq %r14, %r14
jne 0x7fad
xorl %edi, %edi
callq 0x23c0
leaq 0x506f(%rip), %rdi      # 0xcf8e
xorl %esi, %esi
xorl %eax, %eax
callq 0x2140
testl %eax, %eax
je 0x803e
leaq 0x5061(%rip), %rdi      # 0xcf98
xorl %eax, %eax
callq 0x2030
movq 0x8323(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7f5c
leaq 0x5047(%rip), %rdi      # 0xcf98
pushq $0x37
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x32da(%rip), %rdi      # 0xb23d
leaq 0x4fdd(%rip), %rsi      # 0xcf47
leaq 0x32dc(%rip), %rdx      # 0xb24d
movl $0x26c, %ecx            # imm = 0x26C
xorl %eax, %eax
callq 0x2030
movq 0x82e4(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x8188
leaq 0x32a9(%rip), %rsi      # 0xb23d
leaq 0x4fac(%rip), %rdx      # 0xcf47
leaq 0x32ab(%rip), %rcx      # 0xb24d
movl $0x26c, %r8d            # imm = 0x26C
jmp 0x7cf7
movl %ebp, %edi
xorl %esi, %esi
callq 0x21b0
testl %eax, %eax
jns 0x8037
leaq 0x4344(%rip), %rdi      # 0xc305
xorl %eax, %eax
callq 0x2030
movq 0x8299(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x7fe6
leaq 0x432a(%rip), %rdi      # 0xc305
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x3250(%rip), %rdi      # 0xb23d
leaq 0x4f53(%rip), %rsi      # 0xcf47
leaq 0x3252(%rip), %rdx      # 0xb24d
movl $0x267, %ecx            # imm = 0x267
xorl %eax, %eax
callq 0x2030
movq 0x825a(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x817c
leaq 0x321f(%rip), %rsi      # 0xb23d
leaq 0x4f22(%rip), %rdx      # 0xcf47
leaq 0x3221(%rip), %rcx      # 0xb24d
movl $0x267, %r8d            # imm = 0x267
jmp 0x8175
movl %ebp, %edi
callq 0x23c0
movl 0x81b8(%rip), %edx      # 0x101fc
leaq 0x3432(%rip), %r15      # 0xb47d
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2050
leaq 0x4f6c(%rip), %rdi      # 0xcfd0
pushq $0x1
popq %rbx
movq %r14, %rsi
movl %ebx, %edx
callq 0x2310
movl 0x8181(%rip), %edx      # 0x101f8
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2050
leaq 0x4f53(%rip), %rdi      # 0xcfde
movq %r14, %rsi
movl %ebx, %edx
callq 0x2310
movl 0x817d(%rip), %edx      # 0x10218
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2050
leaq 0x4f3e(%rip), %rdi      # 0xcfed
movq %r14, %rsi
movl %ebx, %edx
callq 0x2310
leaq 0x4f3b(%rip), %rdi      # 0xcffb
leaq 0x4f44(%rip), %rsi      # 0xd00b
movl %ebx, %edx
callq 0x2310
leaq 0x4f6c(%rip), %rdi      # 0xd041
movl %ebx, %esi
callq 0x2380
movq 0x81ed(%rip), %rsi      # 0x102d0
testl %eax, %eax
jne 0x80f5
leaq 0x4f21(%rip), %rdi      # 0xd00f
callq 0x2190
jmp 0x8101
leaq 0x4f45(%rip), %rdi      # 0xd041
callq 0x2160
leaq 0x4f14(%rip), %rdi      # 0xd01c
xorl %eax, %eax
callq 0x2030
movq 0x8152(%rip), %rcx      # 0x10268
testq %rcx, %rcx
je 0x812d
leaq 0x4efa(%rip), %rdi      # 0xd01c
pushq $0x2f
popq %rsi
pushq $0x1
popq %rdx
callq 0x23b0
leaq 0x3109(%rip), %rdi      # 0xb23d
leaq 0x4e0c(%rip), %rsi      # 0xcf47
leaq 0x310b(%rip), %rdx      # 0xb24d
movl $0x282, %ecx            # imm = 0x282
xorl %eax, %eax
callq 0x2030
movq 0x8113(%rip), %rdi      # 0x10268
testq %rdi, %rdi
je 0x817c
leaq 0x30dc(%rip), %rsi      # 0xb23d
leaq 0x4ddf(%rip), %rdx      # 0xcf47
leaq 0x30de(%rip), %rcx      # 0xb24d
movl $0x282, %r8d            # imm = 0x282
xorl %eax, %eax
callq 0x22d0
leaq 0x3eb9(%rip), %rdi      # 0xc03c
callq 0x2170
pushq $0x1
popq %rdi
callq 0x2230