// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x80, %rsp
movq $0x0, -0x48(%rbp)
movq 0xa7c6(%rip), %rax      # 0x12350
addq $0x1, %rax
movq %rax, 0xa7bb(%rip)      # 0x12350
movl $0x70, %edi
callq 0x2280
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7c43
jmp 0x7bb0
jmp 0x7bb2
leaq 0x6953(%rip), %rdi      # 0xe50c
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa710(%rip)      # 0x122d8
je 0x7bdf
movq 0xa707(%rip), %rdi      # 0x122d8
leaq 0x6934(%rip), %rsi      # 0xe50c
movb $0x0, %al
callq 0x22d0
jmp 0x7be1
jmp 0x7be3
leaq 0x65c7(%rip), %rdi      # 0xe1b1
leaq 0x80a9(%rip), %rsi      # 0xfc9a
leaq 0x65c9(%rip), %rdx      # 0xe1c1
movl $0x2ab, %ecx            # imm = 0x2AB
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa6cc(%rip)      # 0x122d8
je 0x7c37
movq 0xa6c3(%rip), %rdi      # 0x122d8
leaq 0x6595(%rip), %rsi      # 0xe1b1
leaq 0x8077(%rip), %rdx      # 0xfc9a
leaq 0x6597(%rip), %rcx      # 0xe1c1
movl $0x2ab, %r8d            # imm = 0x2AB
movb $0x0, %al
callq 0x22d0
jmp 0x7c39
movl $0x1, %edi
callq 0x2250
callq 0x72e0
cmpq $0x0, 0xa6a0(%rip)      # 0x122f0
jne 0x7c80
cmpl $0x0, 0xa68f(%rip)      # 0x122e8
jne 0x7c80
movq 0xa67e(%rip), %rdi      # 0x122e0
leaq 0x6abf(%rip), %rsi      # 0xe728
callq 0x7010
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xb480
jmp 0x7d06
cmpq $0x0, 0xa668(%rip)      # 0x122f0
je 0x7c98
movq 0xa65f(%rip), %rdi      # 0x122f0
callq 0xb480
jmp 0x7d04
cmpl $0x0, 0xa65d(%rip)      # 0x122fc
jne 0x7cc2
movl 0xa641(%rip), %eax      # 0x122e8
movzwl %ax, %edi
callq 0x2050
movzwl %ax, %esi
movl $0x3eb, %edi            # imm = 0x3EB
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x7590
jmp 0x7d02
movl 0xa630(%rip), %edx      # 0x122f8
movl $0x3ea, %eax            # imm = 0x3EA
movl $0x3ec, %ecx            # imm = 0x3EC
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x60(%rbp)
movl 0xa61b(%rip), %eax      # 0x122fc
movl %eax, -0x5c(%rbp)
movl 0xa5fe(%rip), %eax      # 0x122e8
movzwl %ax, %edi
callq 0x2050
movl -0x60(%rbp), %edi
movl -0x5c(%rbp), %esi
movzwl %ax, %edx
xorl %ecx, %ecx
callq 0x7590
jmp 0x7d04
jmp 0x7d06
cmpl $0x0, 0xa527(%rip)      # 0x12234
jge 0x7d1a
movq -0x48(%rbp), %rdi
callq 0xb770
jmp 0x7d2a
movl 0xa514(%rip), %edi      # 0x12234
movl $0xa, %esi
callq 0x22c0
movl 0xa584(%rip), %edi      # 0x122b4
leaq -0x38(%rbp), %rsi
movl $0x28, %edx
callq 0x22e0
cmpq $0x28, %rax
je 0x7ddd
jmp 0x7d4a
jmp 0x7d4c
leaq 0x7f53(%rip), %rdi      # 0xfca6
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa576(%rip)      # 0x122d8
je 0x7d79
movq 0xa56d(%rip), %rdi      # 0x122d8
leaq 0x7f34(%rip), %rsi      # 0xfca6
movb $0x0, %al
callq 0x22d0
jmp 0x7d7b
jmp 0x7d7d
leaq 0x642d(%rip), %rdi      # 0xe1b1
leaq 0x7f0f(%rip), %rsi      # 0xfc9a
leaq 0x642f(%rip), %rdx      # 0xe1c1
movl $0x2bd, %ecx            # imm = 0x2BD
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa532(%rip)      # 0x122d8
je 0x7dd1
movq 0xa529(%rip), %rdi      # 0x122d8
leaq 0x63fb(%rip), %rsi      # 0xe1b1
leaq 0x7edd(%rip), %rdx      # 0xfc9a
leaq 0x63fd(%rip), %rcx      # 0xe1c1
movl $0x2bd, %r8d            # imm = 0x2BD
movb $0x0, %al
callq 0x22d0
jmp 0x7dd3
movl $0x1, %edi
callq 0x2250
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movzbl -0x38(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movl -0x24(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movl -0x20(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x54(%rax)
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
cmpl $0x0, -0x28(%rbp)
je 0x7fb1
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x2280
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x7ee3
jmp 0x7e50
jmp 0x7e52
leaq 0x66b3(%rip), %rdi      # 0xe50c
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa470(%rip)      # 0x122d8
je 0x7e7f
movq 0xa467(%rip), %rdi      # 0x122d8
leaq 0x6694(%rip), %rsi      # 0xe50c
movb $0x0, %al
callq 0x22d0
jmp 0x7e81
jmp 0x7e83
leaq 0x6327(%rip), %rdi      # 0xe1b1
leaq 0x7e09(%rip), %rsi      # 0xfc9a
leaq 0x6329(%rip), %rdx      # 0xe1c1
movl $0x2ca, %ecx            # imm = 0x2CA
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa42c(%rip)      # 0x122d8
je 0x7ed7
movq 0xa423(%rip), %rdi      # 0x122d8
leaq 0x62f5(%rip), %rsi      # 0xe1b1
leaq 0x7dd7(%rip), %rdx      # 0xfc9a
leaq 0x62f7(%rip), %rcx      # 0xe1c1
movl $0x2ca, %r8d            # imm = 0x2CA
movb $0x0, %al
callq 0x22d0
jmp 0x7ed9
movl $0x1, %edi
callq 0x2250
movl 0xa3cb(%rip), %edi      # 0x122b4
movq -0x50(%rbp), %rsi
movl -0x28(%rbp), %eax
movl %eax, %edx
callq 0x22e0
movl -0x28(%rbp), %ecx
cmpq %rcx, %rax
je 0x7f98
jmp 0x7f05
jmp 0x7f07
leaq 0x7ddc(%rip), %rdi      # 0xfcea
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa3bb(%rip)      # 0x122d8
je 0x7f34
movq 0xa3b2(%rip), %rdi      # 0x122d8
leaq 0x7dbd(%rip), %rsi      # 0xfcea
movb $0x0, %al
callq 0x22d0
jmp 0x7f36
jmp 0x7f38
leaq 0x6272(%rip), %rdi      # 0xe1b1
leaq 0x7d54(%rip), %rsi      # 0xfc9a
leaq 0x6274(%rip), %rdx      # 0xe1c1
movl $0x2cd, %ecx            # imm = 0x2CD
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa377(%rip)      # 0x122d8
je 0x7f8c
movq 0xa36e(%rip), %rdi      # 0x122d8
leaq 0x6240(%rip), %rsi      # 0xe1b1
leaq 0x7d22(%rip), %rdx      # 0xfc9a
leaq 0x6242(%rip), %rcx      # 0xe1c1
movl $0x2cd, %r8d            # imm = 0x2CD
movb $0x0, %al
callq 0x22d0
jmp 0x7f8e
movl $0x1, %edi
callq 0x2250
movq -0x50(%rbp), %rax
movl -0x28(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq -0x50(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x7fbd
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x50(%rax) # imm = 0xFFFFFFFF
movl -0x1c(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2280
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %edi
shlq $0x3, %rdi
callq 0x2280
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %esi
shlq $0x0, %rsi
movl $0x1, %edi
callq 0x2140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x803d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x803d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x80d2
jmp 0x803f
jmp 0x8041
leaq 0x64c4(%rip), %rdi      # 0xe50c
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa281(%rip)      # 0x122d8
je 0x806e
movq 0xa278(%rip), %rdi      # 0x122d8
leaq 0x64a5(%rip), %rsi      # 0xe50c
movb $0x0, %al
callq 0x22d0
jmp 0x8070
jmp 0x8072
leaq 0x6138(%rip), %rdi      # 0xe1b1
leaq 0x7c1a(%rip), %rsi      # 0xfc9a
leaq 0x613a(%rip), %rdx      # 0xe1c1
movl $0x2d9, %ecx            # imm = 0x2D9
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa23d(%rip)      # 0x122d8
je 0x80c6
movq 0xa234(%rip), %rdi      # 0x122d8
leaq 0x6106(%rip), %rsi      # 0xe1b1
leaq 0x7be8(%rip), %rdx      # 0xfc9a
leaq 0x6108(%rip), %rcx      # 0xe1c1
movl $0x2d9, %r8d            # imm = 0x2D9
movb $0x0, %al
callq 0x22d0
jmp 0x80c8
movl $0x1, %edi
callq 0x2250
movl 0xa1dc(%rip), %edi      # 0x122b4
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
movl -0x1c(%rbp), %eax
shlq $0x2, %rax
movl %eax, %edx
callq 0xbe50
cltq
movl -0x1c(%rbp), %ecx
shlq $0x2, %rcx
cmpq %rcx, %rax
je 0x819b
jmp 0x8102
jmp 0x8104
movl -0x1c(%rbp), %esi
leaq 0x7c22(%rip), %rdi      # 0xfd30
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa1bb(%rip)      # 0x122d8
je 0x8137
movq 0xa1b2(%rip), %rdi      # 0x122d8
movl -0x1c(%rbp), %edx
leaq 0x7c00(%rip), %rsi      # 0xfd30
movb $0x0, %al
callq 0x22d0
jmp 0x8139
jmp 0x813b
leaq 0x606f(%rip), %rdi      # 0xe1b1
leaq 0x7b51(%rip), %rsi      # 0xfc9a
leaq 0x6071(%rip), %rdx      # 0xe1c1
movl $0x2dd, %ecx            # imm = 0x2DD
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa174(%rip)      # 0x122d8
je 0x818f
movq 0xa16b(%rip), %rdi      # 0x122d8
leaq 0x603d(%rip), %rsi      # 0xe1b1
leaq 0x7b1f(%rip), %rdx      # 0xfc9a
leaq 0x603f(%rip), %rcx      # 0xe1c1
movl $0x2dd, %r8d            # imm = 0x2DD
movb $0x0, %al
callq 0x22d0
jmp 0x8191
movl $0x1, %edi
callq 0x2250
cmpb $0x0, 0xa161(%rip)      # 0x12303
je 0x81af
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $-0x9, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xbed0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x83eb
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x83eb
cmpb $0x0, -0x38(%rbp)
jne 0x81ec
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x8209
movzbl -0x38(%rbp), %eax
cmpl $0x0, %eax
je 0x82c3
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jbe 0x82c3
jmp 0x820b
jmp 0x820d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %ecx
leaq 0x7b4f(%rip), %rdi      # 0xfd75
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa0a3(%rip)      # 0x122d8
je 0x825f
movq 0xa09a(%rip), %rdi      # 0x122d8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl 0x28(%rax), %r8d
leaq 0x7b1d(%rip), %rsi      # 0xfd75
movb $0x0, %al
callq 0x22d0
jmp 0x8261
jmp 0x8263
leaq 0x5f47(%rip), %rdi      # 0xe1b1
leaq 0x7a29(%rip), %rsi      # 0xfc9a
leaq 0x5f49(%rip), %rdx      # 0xe1c1
movl $0x2f0, %ecx            # imm = 0x2F0
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0xa04c(%rip)      # 0x122d8
je 0x82b7
movq 0xa043(%rip), %rdi      # 0x122d8
leaq 0x5f15(%rip), %rsi      # 0xe1b1
leaq 0x79f7(%rip), %rdx      # 0xfc9a
leaq 0x5f17(%rip), %rcx      # 0xe1c1
movl $0x2f0, %r8d            # imm = 0x2F0
movb $0x0, %al
callq 0x22d0
jmp 0x82b9
movl $0x1, %edi
callq 0x2250
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x83dd
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x3c(%rbp), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
cmpq %rdx, (%rax,%rcx,8)
je 0x83b3
movzbl 0xa008(%rip), %eax      # 0x12305
cmpl $0x0, %eax
je 0x830d
movl $0x1, %eax
movq %rax, -0x68(%rbp)
jmp 0x8353
movzbl 0x9ff0(%rip), %eax      # 0x12304
cmpl $0x0, %eax
je 0x8333
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0xbf70
movq %rax, -0x70(%rbp)
jmp 0x834b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0xc080
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x3c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
andq -0x58(%rbp), %rax
cmpq $0x0, %rax
jne 0x83b1
movq -0x58(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x3c(%rbp), %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x3c(%rbp), %rcx
movb $0x1, (%rax,%rcx)
jmp 0x83cd
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x3c(%rbp), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movq %rdx, (%rax,%rcx,8)
jmp 0x83cf
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x82ca
movq -0x8(%rbp), %rdi
callq 0x8b20
jmp 0x8485
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x8479
movzbl 0x9f04(%rip), %eax      # 0x12305
cmpl $0x0, %eax
je 0x8411
movl $0x1, %eax
movq %rax, -0x78(%rbp)
jmp 0x8457
movzbl 0x9eec(%rip), %eax      # 0x12304
cmpl $0x0, %eax
je 0x8437
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0xbf70
movq %rax, -0x80(%rbp)
jmp 0x844f
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0xc080
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x3c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x83f2
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movl -0x1c(%rbp), %eax
imulq $0x18, %rax, %rsi
movl $0x1, %edi
callq 0x2140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x8545
jmp 0x84b2
jmp 0x84b4
leaq 0x6051(%rip), %rdi      # 0xe50c
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0x9e0e(%rip)      # 0x122d8
je 0x84e1
movq 0x9e05(%rip), %rdi      # 0x122d8
leaq 0x6032(%rip), %rsi      # 0xe50c
movb $0x0, %al
callq 0x22d0
jmp 0x84e3
jmp 0x84e5
leaq 0x5cc5(%rip), %rdi      # 0xe1b1
leaq 0x77a7(%rip), %rsi      # 0xfc9a
leaq 0x5cc7(%rip), %rdx      # 0xe1c1
movl $0x30c, %ecx            # imm = 0x30C
movb $0x0, %al
callq 0x2030
cmpq $0x0, 0x9dca(%rip)      # 0x122d8
je 0x8539
movq 0x9dc1(%rip), %rdi      # 0x122d8
leaq 0x5c93(%rip), %rsi      # 0xe1b1
leaq 0x7775(%rip), %rdx      # 0xfc9a
leaq 0x5c95(%rip), %rcx      # 0xe1c1
movl $0x30c, %r8d            # imm = 0x30C
movb $0x0, %al
callq 0x22d0
jmp 0x853b
movl $0x1, %edi
callq 0x2250
movq -0x8(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)