LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/jondurbin[P]dre2/src/dre2_match.c
// Function: dre2_expanded_match
struct dre2_match_value dre2_expanded_match( struct dre2 *graph, unsigned char *input, int length, int *r_temp, int *reachable, int *state, struct dre2_match_value *original_match )
{
  unsigned char *pch;
  struct dre2_single_match result;
  struct dre2_match_value ret_val;

  ret_val.start_pos = original_match->start_pos;
  ret_val.matched = true;
  pch = input + original_match->start_pos;
  result = dre2_matcher( graph, input + original_match->start_pos, pch, 0, DRE2_RIGHT, length, r_temp, reachable, state );
  if ( result.match != NULL )
    ret_val.end_pos = result.match - input + 1;
  return ret_val;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movq 0xb0(%rsp), %rax
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movl %edx, 0x7c(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movq %r9, 0x60(%rsp)
movq 0xb0(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x98(%rsp)
movl $0x1, 0x90(%rsp)
movq 0x80(%rsp), %rax
movq 0xb0(%rsp), %rcx
movslq 0x8(%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x58(%rsp)
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0xb0(%rsp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rdx
movq 0x58(%rsp), %rcx
movl 0x7c(%rsp), %ebx
movq 0x70(%rsp), %r11
movq 0x68(%rsp), %r10
movq 0x60(%rsp), %rax
leaq 0x28(%rsp), %rdi
xorl %r8d, %r8d
movl $0x1, %r9d
movl %ebx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x2270
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0xb559
movq 0x50(%rsp), %rax
movq 0x80(%rsp), %rcx
subq %rcx, %rax
addq $0x1, %rax
movl %eax, 0x9c(%rsp)
movq 0x90(%rsp), %rax
movq 0x98(%rsp), %rdx
addq $0xa0, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keiranrowan[P]tiny-core/./src/sleep.c
// Function: main
int main(int argc, char **argv) {
	if (argc > 1) {
#ifdef _WIN32
		Sleep(atoi(argv[1]));
		return 0;
#else
		sleep(atoi(argv[1]));
		return 0;
#endif
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0x1189
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movl %eax, %edi
callq 0x1040
movl $0x0, -0x4(%rbp)
jmp 0x1190
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_text
static int parser_text(const char bytes[], size_t len, void *user)
{
  unsigned char *b = (unsigned char *)bytes;

  int i;
  for(i = 0; i < len; /* none */) {
    if(b[i] < 0x20)        // C0
      break;
    else if(b[i] < 0x80)   // ASCII
      i++;
    else if(b[i] < 0xa0)   // C1
      break;
    else if(b[i] < 0xc0)   // UTF-8 continuation
      break;
    else if(b[i] < 0xe0) { // UTF-8 2-byte
      // 2-byte UTF-8
      if(len < i+2) break;
      i += 2;
    }
    else if(b[i] < 0xf0) { // UTF-8 3-byte
      if(len < i+3) break;
      i += 3;
    }
    else if(b[i] < 0xf8) { // UTF-8 4-byte
      if(len < i+4) break;
      i += 4;
    }
    else                   // otherwise invalid
      break;
  }

  printf("%.*s", i, b);
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2554
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jge 0x2457
jmp 0x2554
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x80, %eax
jge 0x2478
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x254d
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xa0, %eax
jge 0x2490
jmp 0x2554
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xc0, %eax
jge 0x24a8
jmp 0x2554
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xe0, %eax
jge 0x24dd
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x24d2
jmp 0x2554
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x24(%rbp)
jmp 0x2547
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xf0, %eax
jge 0x250f
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x2504
jmp 0x2554
movl -0x24(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x24(%rbp)
jmp 0x2545
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xf8, %eax
jge 0x2541
movq -0x10(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jae 0x2536
jmp 0x2554
movl -0x24(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x24(%rbp)
jmp 0x2543
jmp 0x2554
jmp 0x2545
jmp 0x2547
jmp 0x2549
jmp 0x254b
jmp 0x254d
jmp 0x254f
jmp 0x2433
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq 0xcaf(%rip), %rdi       # 0x3211
movb $0x0, %al
callq 0x2080
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_control
static int parser_control(unsigned char control, void *user)
{
  if(control < 0x20)
    printf("%s%s%s", special_begin, name_c0[control], special_end);
  else if(control == 0x7f)
    printf("%s%s%s", special_begin, "DEL", special_end);
  else if(control >= 0x80 && control < 0xa0 && name_c1[control - 0x80])
    printf("%s%s%s", special_begin, name_c1[control - 0x80], special_end);
  else
    printf("%sCONTROL 0x%02x%s", special_begin, control, special_end);

  if(control == 0x0a)
    printf("\n");
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x20, %eax
jge 0x25cd
movq 0x2b0e(%rip), %rsi      # 0x50b0
movzbl -0x1(%rbp), %eax
movl %eax, %ecx
leaq 0x2b61(%rip), %rax      # 0x5110
movq (%rax,%rcx,8), %rdx
movq 0x2afe(%rip), %rcx      # 0x50b8
leaq 0xa69(%rip), %rdi       # 0x302a
movb $0x0, %al
callq 0x2080
jmp 0x2687
movzbl -0x1(%rbp), %eax
cmpl $0x7f, %eax
jne 0x25fe
movq 0x2ad3(%rip), %rsi      # 0x50b0
movq 0x2ad4(%rip), %rcx      # 0x50b8
leaq 0xa3f(%rip), %rdi       # 0x302a
leaq 0xa3f(%rip), %rdx       # 0x3031
movb $0x0, %al
callq 0x2080
jmp 0x2685
movzbl -0x1(%rbp), %eax
cmpl $0x80, %eax
jl 0x2663
movzbl -0x1(%rbp), %eax
cmpl $0xa0, %eax
jge 0x2663
movzbl -0x1(%rbp), %eax
subl $0x80, %eax
movslq %eax, %rcx
leaq 0x2be9(%rip), %rax      # 0x5210
cmpq $0x0, (%rax,%rcx,8)
je 0x2663
movq 0x2a7b(%rip), %rsi      # 0x50b0
movzbl -0x1(%rbp), %eax
subl $0x80, %eax
movslq %eax, %rcx
leaq 0x2bc8(%rip), %rax      # 0x5210
movq (%rax,%rcx,8), %rdx
movq 0x2a65(%rip), %rcx      # 0x50b8
leaq 0x9d0(%rip), %rdi       # 0x302a
movb $0x0, %al
callq 0x2080
jmp 0x2683
movq 0x2a46(%rip), %rsi      # 0x50b0
movzbl -0x1(%rbp), %edx
movq 0x2a43(%rip), %rcx      # 0x50b8
leaq 0x9b9(%rip), %rdi       # 0x3035
movb $0x0, %al
callq 0x2080
jmp 0x2685
jmp 0x2687
movzbl -0x1(%rbp), %eax
cmpl $0xa, %eax
jne 0x269e
leaq 0x984(%rip), %rdi       # 0x301b
movb $0x0, %al
callq 0x2080
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_escape
static int parser_escape(const char bytes[], size_t len, void *user)
{
  if(bytes[0] >= 0x20 && bytes[0] < 0x30) {
    if(len < 2)
      return -1;
    len = 2;
  }
  else {
    len = 1;
  }

  printf("%sESC %.*s%s", special_begin, (int)len, bytes, special_end);

  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jl 0x26f6
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jge 0x26f6
cmpq $0x2, -0x18(%rbp)
jae 0x26ec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x272b
movq $0x2, -0x18(%rbp)
jmp 0x26fe
movq $0x1, -0x18(%rbp)
movq 0x29ab(%rip), %rsi      # 0x50b0
movq -0x18(%rbp), %rax
movl %eax, %edx
movq -0x10(%rbp), %rcx
movq 0x29a2(%rip), %r8       # 0x50b8
leaq 0x9ff(%rip), %rdi       # 0x311c
movb $0x0, %al
callq 0x2080
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_osc
static int parser_osc(int command, VTermStringFragment frag, void *user)
{
  if(frag.initial) {
    if(command == -1)
      printf("%sOSC ", special_begin);
    else
      printf("%sOSC %d;", special_begin, command);
  }

  printf("%.*s", (int)frag.len, frag.str);

  if(frag.final)
    printf("%s", special_end);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x8(%rbp), %eax
shrl $0x1e, %eax
andl $0x1, %eax
testl $0x1, %eax
je 0x2a2e
cmpl $-0x1, -0x14(%rbp)
jne 0x2a14
movq 0x26ac(%rip), %rsi      # 0x50b0
leaq 0x7ef(%rip), %rdi       # 0x31fa
movb $0x0, %al
callq 0x2080
jmp 0x2a2c
movq 0x2695(%rip), %rsi      # 0x50b0
movl -0x14(%rbp), %edx
leaq 0x7dc(%rip), %rdi       # 0x3201
movb $0x0, %al
callq 0x2080
jmp 0x2a2e
movl -0x8(%rbp), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, %eax
movl %eax, %esi
movq -0x10(%rbp), %rdx
leaq 0x7cc(%rip), %rdi       # 0x3211
movb $0x0, %al
callq 0x2080
movl -0x8(%rbp), %eax
shrl $0x1f, %eax
testl $0x1, %eax
je 0x2a6e
movq 0x2658(%rip), %rsi      # 0x50b8
leaq 0x6d7(%rip), %rdi       # 0x313e
movb $0x0, %al
callq 0x2080
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/bin/vterm-dump.c
// Function: parser_dcs
static int parser_dcs(const char *command, size_t commandlen, VTermStringFragment frag, void *user)
{
  if(frag.initial)
    printf("%sDCS %.*s", special_begin, (int)commandlen, command);

  printf("%.*s", (int)frag.len, frag.str);

  if(frag.final)
    printf("%s", special_end);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0x8(%rbp), %eax
shrl $0x1e, %eax
andl $0x1, %eax
testl $0x1, %eax
je 0x2acb
movq 0x25fd(%rip), %rsi      # 0x50b0
movq -0x20(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rcx
leaq 0x747(%rip), %rdi       # 0x320b
movb $0x0, %al
callq 0x2080
movl -0x8(%rbp), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, %eax
movl %eax, %esi
movq -0x10(%rbp), %rdx
leaq 0x72f(%rip), %rdi       # 0x3211
movb $0x0, %al
callq 0x2080
movl -0x8(%rbp), %eax
shrl $0x1f, %eax
testl $0x1, %eax
je 0x2b0b
movq 0x25bb(%rip), %rsi      # 0x50b8
leaq 0x63a(%rip), %rdi       # 0x313e
movb $0x0, %al
callq 0x2080
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/google[P]multichase/multiload.c
// Function: load_memset_libc
static void load_memset_libc(per_thread_t *t) {
#define LOOP_OPS 1
  uint64_t load_bites = t->x.load_total_memory * LOOP_OPS;
  register char *a = (char *)t->x.load_arena;

  LOAD_MEMORY_INIT_MIBPS
  do {
    memset((void *)a, 0xdeadbeef, load_bites);
    LOAD_MEMORY_SAMPLE_MIBPS
  } while (1);
#undef LOOP_OPS
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $-0x1, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
callq 0x404250
movq %rax, %xmm0
movaps 0xcc39a(%rip), %xmm1    # 0x4dc050
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xcc39e(%rip), %xmm1    # 0x4dc060
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xef, %esi
callq 0x4010b0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x40fe35
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, %rax
jne 0x40fe35
callq 0x404250
movq %rax, %xmm0
movaps 0xcc31c(%rip), %xmm2    # 0x4dc050
movaps %xmm2, -0x80(%rbp)
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xcc31c(%rip), %xmm1    # 0x4dc060
movaps %xmm1, -0x70(%rbp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm3
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm3, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq %rcx, %rax
movq %rax, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x50(%rbp), %xmm0
movsd 0xcc283(%rip), %xmm1    # 0x4dc028
mulsd %xmm1, %xmm0
movsd -0x48(%rbp), %xmm1
movsd 0xcc28a(%rip), %xmm2    # 0x4dc040
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x8(%rbp), %rax
movsd -0x58(%rbp), %xmm0
movsd 0xcc270(%rip), %xmm2    # 0x4dc048
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rdx
cvttsd2si %xmm0, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
andq %rsi, %rdx
orq %rdx, %rcx
lock
addq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x404250
movaps -0x80(%rbp), %xmm2
movaps -0x70(%rbp), %xmm1
movq %rax, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x40fe37
movb $0x1, %al
testb $0x1, %al
jne 0x40fcd6
jmp 0x40fe43
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/google[P]multichase/multiload.c
// Function: load_memsetz_libc
static void load_memsetz_libc(per_thread_t *t) {
#define LOOP_OPS 1
  uint64_t load_bites = t->x.load_total_memory * LOOP_OPS;
  register char *a = (char *)t->x.load_arena;

  LOAD_MEMORY_INIT_MIBPS
  do {
    memset((void *)a, 0, load_bites);
    LOAD_MEMORY_SAMPLE_MIBPS
  } while (1);
#undef LOOP_OPS
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $-0x1, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
callq 0x404250
movq %rax, %xmm0
movaps 0xcc19a(%rip), %xmm1    # 0x4dc050
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xcc19e(%rip), %xmm1    # 0x4dc060
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x4010b0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x410032
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, %rax
jne 0x410032
callq 0x404250
movq %rax, %xmm0
movaps 0xcc11f(%rip), %xmm2    # 0x4dc050
movaps %xmm2, -0x80(%rbp)
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0xcc11f(%rip), %xmm1    # 0x4dc060
movaps %xmm1, -0x70(%rbp)
subpd %xmm1, %xmm0
movaps %xmm0, %xmm3
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm3, %xmm0
movsd %xmm0, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
imulq %rcx, %rax
movq %rax, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x50(%rbp), %xmm0
movsd 0xcc086(%rip), %xmm1    # 0x4dc028
mulsd %xmm1, %xmm0
movsd -0x48(%rbp), %xmm1
movsd 0xcc08d(%rip), %xmm2    # 0x4dc040
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x8(%rbp), %rax
movsd -0x58(%rbp), %xmm0
movsd 0xcc073(%rip), %xmm2    # 0x4dc048
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rdx
cvttsd2si %xmm0, %rcx
movq %rcx, %rsi
sarq $0x3f, %rsi
andq %rsi, %rdx
orq %rdx, %rcx
lock
addq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x404250
movaps -0x80(%rbp), %xmm2
movaps -0x70(%rbp), %xmm1
movq %rax, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x410034
movb $0x1, %al
testb $0x1, %al
jne 0x40fed6
jmp 0x410040
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/uno_local.c
// Function: split_filename
static void
split_filename(const char *f)
{	char *last_slash;

	cur_path = (char *) emalloc(strlen (f) + 1);
	strcpy(cur_path, f);

	last_slash = strrchr(f, '/');
#ifdef PC
	if (!last_slash)
	{	last_slash = strrchr(f, '\\');
		if (!last_slash)
			last_slash = strrchr(f, ':');
	}
#endif
	if (!last_slash)
	{	cur_dir =".";  /* to make sure we get a valid pathname */
		cur_file = cur_path;
	} else
	{	size_t dirlen = last_slash - f;
		cur_dir = (char *) emalloc(dirlen + 1);
		strncpy(cur_dir, f, dirlen);    /* cur_dir has a zero afterward */
		cur_file = &cur_path[dirlen+1];
	}
	if (Verbose > 1) fprintf(stderr, "FILE %s -> '%s/%s'\n", f, cur_dir, cur_file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, 0x49f18(%rip)     # 0x4e3d0
movq 0x49f11(%rip), %rdi     # 0x4e3d0
movq -0x8(%rbp), %rsi
callq 0x3080
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x3110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x44ff
leaq 0x30d33(%rip), %rax     # 0x3521b
movq %rax, 0x49c61(%rip)     # 0x4e150
movq 0x49eda(%rip), %rax     # 0x4e3d0
movq %rax, 0x49e4b(%rip)     # 0x4e348
jmp 0x454f
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, 0x49c2e(%rip)     # 0x4e150
movq 0x49c27(%rip), %rdi     # 0x4e150
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3060
movq 0x49e93(%rip), %rax     # 0x4e3d0
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
addq %rcx, %rax
movq %rax, 0x49df9(%rip)     # 0x4e348
cmpl $0x1, 0x49e22(%rip)     # 0x4e378
jle 0x4582
movq 0x49a99(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq 0x49be3(%rip), %rcx     # 0x4e150
movq 0x49dd4(%rip), %r8      # 0x4e348
leaq 0x30701(%rip), %rsi     # 0x34c7c
movb $0x0, %al
callq 0x3170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/heap.c
// Function: CreateHeap
Heap *
CreateHeap(unsigned int chunk_size, unsigned int chnk_hunk_ratio )
{	Heap    *heap;
	unsigned int     unit;

	heap = (Heap *) emalloc(sizeof(Heap));

	unit  = max(chunk_size, MIN_SZE);
	if (unit % ALGN_SZE != 0)
		unit += ALGN_SZE - (unit % ALGN_SZE);
	heap->chnk_sze = unit;

	if (chnk_hunk_ratio)
		heap->ch_ratio = chnk_hunk_ratio; 
	else
		heap->ch_ratio = DEFLT_RATIO;

	heap->num_alloc = 0; 
	heap->num_free  = 0; 
	heap->num_hunks = 0; 

	heap->next_chunk = 0;
	heap->hunk_array_sze = MIN_HUNK_ARRY;
	heap->free_list = (void *) NULL;

	heap->hunks = (void **) emalloc(MIN_HUNK_ARRY * PNTR_SZE);

	return(heap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x30, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
cmpq $0x8, %rax
jb 0x4f0e
movl -0x4(%rbp), %eax
movq %rax, -0x20(%rbp)
jmp 0x4f19
movl $0x8, %eax
movq %rax, -0x20(%rbp)
jmp 0x4f19
movq -0x20(%rbp), %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x4f45
movl -0x14(%rbp), %eax
andq $0x7, %rax
movl $0x8, %ecx
subq %rax, %rcx
movl -0x14(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x8(%rbp)
je 0x4f60
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x4f6b
movq -0x10(%rbp), %rax
movl $0x100, 0x4(%rax)       # imm = 0x100
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x8, 0x14(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movl $0x40, %edi
callq 0x54c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/heap.c
// Function: rel_chunk
void
rel_chunk(void *x)
{	FC *y;

#ifdef DEBUG
	if (!check_chunks(x)) return;
#endif
	memset(x, 0, MX_NODE_SZE);
	y = (FC *) x;
	y->fc.nxt = free_chunks;
	free_chunks = y;

#ifdef DEBUG
	printf("++ %p	-- %d\n", x, ++gh_sz);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x3140
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x493dd(%rip), %rcx     # 0x4e3d8
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x493cb(%rip)     # 0x4e3d8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: emalloc
void *
emalloc(size_t m)
{	char *tmp;
	long n = m + ALGN;	/* for possible alignment */

	assert(m != 0);

#ifdef DEBUG
	tmp = calloc(n/ALGN, ALGN);
	if (!tmp)
	{	fprintf(stderr, "%s: out of memory\n", progname);
		exit(1);
	}
#else
	tmp = not_malloc(n);

	if (((unsigned long) tmp)&(ALGN-1))
	{	tmp += (long) (ALGN  - (((unsigned long) tmp)&(ALGN-1)));
		memwaste += ALGN;
	} else
	{	left += ALGN;	/* return the extra bytes */
		have -= ALGN;
	}
#endif

	memcnt += m;

	return (void *) tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54e1
jmp 0x5500
leaq 0x2f7c8(%rip), %rdi     # 0x34cb0
leaq 0x2f7c8(%rip), %rsi     # 0x34cb7
movl $0x5b, %edx
leaq 0x2f7c5(%rip), %rcx     # 0x34cc0
callq 0x3120
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x5590
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x5549
movq -0x10(%rbp), %rcx
andq $0x7, %rcx
movl $0x8, %eax
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x4ae9c(%rip), %rax     # 0x503d8
addq $0x8, %rax
movq %rax, 0x4ae91(%rip)     # 0x503d8
jmp 0x556b
movl 0x4ae91(%rip), %eax     # 0x503e0
addq $0x8, %rax
movl %eax, 0x4ae87(%rip)     # 0x503e0
movq 0x4ae88(%rip), %rax     # 0x503e8
addq $-0x8, %rax
movq %rax, 0x4ae7d(%rip)     # 0x503e8
movq -0x8(%rbp), %rax
addq 0x4ae7a(%rip), %rax     # 0x503f0
movq %rax, 0x4ae73(%rip)     # 0x503f0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: not_malloc
static char *
not_malloc(unsigned int n)
{	char *tmp;

	if (left < n)
	{	unsigned int grow = (n < CHUNK) ? CHUNK : n;
		have = (char *) malloc(grow);
		if (!have)
		{	fprintf(stderr, "%s: out of memory\n", progname);
			exit(1);
		}
		memset(have, 0, grow);
		left = grow;
	}
	tmp = have;
	have += n;
	left -= n;

	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl 0x4ae3f(%rip), %eax     # 0x503e0
cmpl -0x4(%rbp), %eax
jae 0x562c
cmpl $0x100000, -0x4(%rbp)   # imm = 0x100000
jae 0x55bd
movl $0x100000, %eax         # imm = 0x100000
movl %eax, -0x18(%rbp)
jmp 0x55c3
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x31a0
movq %rax, 0x4ae0e(%rip)     # 0x503e8
cmpq $0x0, 0x4ae06(%rip)     # 0x503e8
jne 0x5610
movq 0x48a0d(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
leaq 0x48b63(%rip), %rax     # 0x4e158
movq (%rax), %rdx
leaq 0x2f7db(%rip), %rsi     # 0x34dda
movb $0x0, %al
callq 0x3170
movl $0x1, %edi
callq 0x3230
movq 0x4add1(%rip), %rdi     # 0x503e8
movl -0x14(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x3140
movl -0x14(%rbp), %eax
movl %eax, 0x4adb4(%rip)     # 0x503e0
movq 0x4adb5(%rip), %rax     # 0x503e8
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq 0x4ada7(%rip), %rax     # 0x503e8
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x4ad9b(%rip)     # 0x503e8
movl -0x4(%rbp), %ecx
movl 0x4ad8a(%rip), %eax     # 0x503e0
subl %ecx, %eax
movl %eax, 0x4ad82(%rip)     # 0x503e0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: new_symentry
symentry_t *
new_symentry(void)
{	symentry_t *that;

	if (fses)
	{	that = fses;
		fses = fses->next;
		memset(that, 0, sizeof(symentry_t));
	} else
		that = (symentry_t *) emalloc(sizeof(symentry_t));

	that->ln = current_linenumber();	/* gjh */
	that->fn = current_filename();		/* gjh */
	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x4ad18(%rip)     # 0x503f8
je 0x5711
movq 0x4ad0f(%rip), %rax     # 0x503f8
movq %rax, -0x8(%rbp)
movq 0x4ad04(%rip), %rax     # 0x503f8
movq 0x38(%rax), %rax
movq %rax, 0x4acf9(%rip)     # 0x503f8
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3140
jmp 0x571f
movl $0x40, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
callq 0x19d10
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
callq 0x19d40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: new_hashtab
hashtab_t *
new_hashtab(void)
{	hashtab_t *that;

	if (freehtab)
	{	that = freehtab;
		freehtab = that->nxt;
		if (that->tsize != INIT_HASHTAB_SIZE)
		{	fprintf(stderr, "cannot happen nht\n");
			exit(1);
		}
		memset(that->tab, 0, sizeof(symentry_t*) * that->tsize);
	} else
	{	that = (hashtab_t *) emalloc(sizeof(hashtab_t));
		that->tsize = INIT_HASHTAB_SIZE;
		that->tab = (symentry_t **) emalloc( sizeof(symentry_t*) * that->tsize );
	}
	that->nent = 0;

	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x4aa70(%rip)     # 0x50400
je 0x59f3
movq 0x4aa67(%rip), %rax     # 0x50400
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x4aa54(%rip)     # 0x50400
movq -0x8(%rbp), %rax
cmpl $0x11, (%rax)
je 0x59d7
movq 0x4863c(%rip), %rax     # 0x4dff8
movq (%rax), %rdi
leaq 0x2f352(%rip), %rsi     # 0x34d18
movb $0x0, %al
callq 0x3170
movl $0x1, %edi
callq 0x3230
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x3140
jmp 0x5a26
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x11, (%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: show_symentry
static void
show_symentry(symentry_t *that, int tabs, FILE *fp)
{
	dotabs(tabs+1, fp);
	fprintf(fp, "%s", that->nme->str);
	print_frag(that->node, fp);
	if (that->node
	&&  that->node->hdr.type != TN_FUNC_DEF
	&& !that->used)
		fprintf(fp, " unused");
	fprintf(fp, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edi
addl $0x1, %edi
movq -0x18(%rbp), %rsi
callq 0x6e60
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x3fee9(%rip), %rsi     # 0x45b22
movb $0x0, %al
callq 0x3170
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6eb0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5c87
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, 0x1c(%rax)
je 0x5c87
movq -0x8(%rbp), %rax
cmpw $0x0, 0x22(%rax)
jne 0x5c87
movq -0x18(%rbp), %rdi
leaq 0x2f16d(%rip), %rsi     # 0x34ded
movb $0x0, %al
callq 0x3170
movq -0x18(%rbp), %rdi
leaq 0x3eaad(%rip), %rsi     # 0x4473f
movb $0x0, %al
callq 0x3170
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: new_scopetab
scopetab_t*
new_scopetab(scopetab_t *mom)
{	scopetab_t *that;

	if (freestab)
	{	that = freestab;
		freestab = that->parent;
		memset(that, 0, sizeof(scopetab_t));
	} else
		that = (scopetab_t *) emalloc(sizeof(scopetab_t));

	if (0)
	printf("new scope tab %p, level %d\n", that, mom?mom->level+1:EXTERN_SCOPE);

	that->size = INIT_CHILD_SIZE;

	that->children = getscoop(that->size);

	that->parent = mom;
	if (mom)
		that->level = mom->level + 1;
	else
		that->level = EXTERN_SCOPE;

	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x4a684(%rip)     # 0x50418
je 0x5dc2
movq 0x4a67b(%rip), %rax     # 0x50418
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x4a668(%rip)     # 0x50418
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x3140
jmp 0x5dd0
movl $0x38, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x4, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %edi
callq 0x5ca0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x5e18
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x5e23
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: check_struct_use
void
check_struct_use(FILE *fd, scopetab_t *that)
{	scopetab_t *z;
	symentry_t *x;
	int mustcheck, j;

	vis_p = 1;
	if (that->htab)
	{	mustcheck = 0;
		for (z = that; z; z = z->parent)
			if (z->owner
			&&  strcmp(z->owner, "-") != 0)
			{	if (z->owner_t == TN_OBJ_DEF)
					mustcheck = 1;
				break;
			}

		if (mustcheck)
		for (j = 0; j < that->htab->tsize; j++)
		for (x = that->htab->tab[j]; x; x = x->next)
		{
#if DBG
			printf("%s (%u)	is %sused, owner:	%s	type: %d\n",
				x->nme->str, x, x->used?"":"un",
				that->owner?that->owner:"--",
				that->owner_t);
#endif
			if (!uno_ignore(x))	/* unused field */
			{	fprintf(fd, "%s\t%s\t%s\t%d\n",
					(x->used)?"y":"z",	/* set in dflow.c */
					x->nme->str,
					x->node->hdr.fnm,
					x->node->hdr.line);
			}
		}
	}

	for (j = 0; j < that->nchild; j++)
		check_struct_use(fd, that->children[j]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, 0x49f56(%rip)     # 0x50420
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x65fe
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6536
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6526
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x2ed03(%rip), %rsi     # 0x3520c
callq 0x3160
cmpl $0x0, %eax
je 0x6526
movq -0x18(%rbp), %rax
cmpl $0x18, 0x20(%rax)
jne 0x6524
movl $0x1, -0x24(%rbp)
jmp 0x6536
jmp 0x6528
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x64e8
cmpl $0x0, -0x24(%rbp)
je 0x65fc
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x65fa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x65ea
movq -0x20(%rbp), %rdi
callq 0x1fe30
cmpl $0x0, %eax
jne 0x65da
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movswl 0x22(%rax), %ecx
leaq 0x2e829(%rip), %rdx     # 0x34dc3
leaq 0x2e5e8(%rip), %rax     # 0x34b89
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %r8
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x10(%rax), %r9d
leaq 0x2e7e3(%rip), %rsi     # 0x34db6
movb $0x0, %al
callq 0x3170
jmp 0x65dc
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6572
jmp 0x65ec
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6547
jmp 0x65fc
jmp 0x65fe
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x6635
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x64b0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6605
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: name_scope
void
name_scope(context_t *q, char *s, int tp)
{	symtab_t *p = q->syms;

	if (0) printf("name_scope %p -- owner=%s (owner_t=%d) clevel %d, level %d\n",
		p->current,
		s, tp,
		p->clevel,
		p->current->level);

	set_owner(p->current, s, tp);

	if (Verbose&2)
	printf("SET level %d,%d, %s\n",
		p->clevel,  p->current->level,  s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x6680
leaq 0x47c3e(%rip), %rax     # 0x4e378
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x6768
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rcx
leaq 0x2e664(%rip), %rdi     # 0x34dc5
movb $0x0, %al
callq 0x30f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: new_symtab
symtab_t*
new_symtab(void)
{	symtab_t *that;

	if (freesymt)
	{	that = freesymt;
		freesymt = that->nxt;
		memset(that, 0, sizeof(symtab_t));
	} else
		that = (symtab_t *) emalloc(sizeof(symtab_t));

	that->root = new_scopetab(NULL);
	that->clevel = EXTERN_SCOPE;
	that->current = that->root;

	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x49ca8(%rip)     # 0x50428
je 0x67ae
movq 0x49c9f(%rip), %rax     # 0x50428
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x49c8c(%rip)     # 0x50428
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3140
jmp 0x67bc
movl $0x20, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x5d80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: st_exit_scope
void
st_exit_scope(symtab_t *that)
{
	if (!that) return;

	(that->clevel)--;
	if (that->current->level > that->clevel)
		that->current = that->current->parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6af1
jmp 0x6b26
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x6b26
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: new_context
context_t*
new_context(void)
{	context_t *that = (context_t *) emalloc( sizeof(context_t) );

	that->labels = new_symtab();
	that->tags   = new_symtab();
	that->syms   = new_symtab();

	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x8(%rbp)
callq 0x6770
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x6770
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x6770
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: free_context
void
free_context(context_t *that)
{
	if (!that) return;

	free_symtab(that->labels);
	free_symtab(that->tags);
	free_symtab(that->syms);

	efree(that);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6bd5
jmp 0x6c04
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6c10
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6c10
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6c10
movq -0x8(%rbp), %rdi
callq 0x54b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: free_symtab
static void
free_symtab(symtab_t *that)
{
	if (!that) return;

	/* post-order traversal */ 
	po_deltabs(that->root);
	
	that->nxt = freesymt;
	freesymt = that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6c25
jmp 0x6c4b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6f40
movq 0x497f0(%rip), %rcx     # 0x50428
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x497dd(%rip)     # 0x50428
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: enter_scope
int
enter_scope(context_t *that)
{
	if (!that) return 0;

#ifdef  MORE_VERBOSE
	printf("	Enter Scope: %d\n", that->syms->clevel + 1);
#endif
	st_enter_scope(that->labels);
	st_enter_scope(that->tags);

	return st_enter_scope(that->syms);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6c7c
movl $0x0, -0x4(%rbp)
jmp 0x6ca5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6ac0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6ac0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6ac0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: exit_scope
void
exit_scope(context_t *that)
{
#ifdef  MORE_VERBOSE
	printf("	Exit Scope: %d\n", that->syms->clevel);
#endif
	if (!that) return;

	st_exit_scope(that->labels);
	st_exit_scope(that->tags);
	st_exit_scope(that->syms);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6cc5
jmp 0x6ceb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x6ae0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6ae0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x6ae0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: add_constant
void
add_constant(char *p)
{	Cname *s;

	for (s = cnames; s; s = s->nxt)
		if (strcmp(p, s->vn) == 0)
			return;

	s = (Cname *) emalloc(sizeof(Cname));
	s->vn = (char *) emalloc(strlen(p)+1);
	strcpy(s->vn, p);
	s->nxt = cnames;
	cnames = s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x496cd(%rip), %rax     # 0x50430
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6d95
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x6d85
jmp 0x6dec
jmp 0x6d87
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x6d67
movl $0x10, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30c0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x54c0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3080
movq 0x49657(%rip), %rcx     # 0x50430
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x49644(%rip)     # 0x50430
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: is_constant
int
is_constant(char *p)
{	Cname *s;

	for (s = cnames; s; s = s->nxt)
		if (strcmp((const char *) p, s->vn) == 0)
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x4961d(%rip), %rax     # 0x50430
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e4c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x3160
cmpl $0x0, %eax
jne 0x6e3c
movl $0x1, -0x4(%rbp)
jmp 0x6e53
jmp 0x6e3e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6e17
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: po_deltabs
static void
po_deltabs(scopetab_t *that)
{	int j;

	if (!that) return;

	for (j = 0; j < that->nchild; j++)
		po_deltabs(that->children[j]);

 	free_scopetab(that);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x6f55
jmp 0x6f91
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x6f88
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6f40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6f5c
movq -0x8(%rbp), %rdi
callq 0x6fa0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: free_scopetab
static void
free_scopetab(scopetab_t *that)
{	Scoop *s;

	if (that)
	{	free_hashtab(that->htab);

		if (freescoop)
		{	s = freescoop;
			freescoop = s->nxt;
		} else
			s = (Scoop *) emalloc(sizeof(Scoop));

		s->n = that->size;
		s->g = that->children;
		s->nxt = scoop;
		scoop = s;

		that->parent = freestab;
		freestab = that;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7049
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7050
cmpq $0x0, 0x49444(%rip)     # 0x50410
je 0x6fea
movq 0x4943b(%rip), %rax     # 0x50410
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x49428(%rip)     # 0x50410
jmp 0x6ff8
movl $0x18, %edi
callq 0x54c0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x493ec(%rip), %rcx     # 0x50408
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x493d9(%rip)     # 0x50408
movq 0x493e2(%rip), %rcx     # 0x50418
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x493cf(%rip)     # 0x50418
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: free_hashtab
static void
free_hashtab(hashtab_t *that)
{	int j;

	if (that)
	{	for (j=0; j < that->tsize; j++)
		{	free_symlist(that->tab[j]);
			that->tab[j] = (symentry_t *) 0;
		}
		that->nxt = freehtab;
		freehtab = that;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x70c3
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x70a9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x70d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x706a
movq 0x49350(%rip), %rcx     # 0x50400
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x4933d(%rip)     # 0x50400
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/symtab.c
// Function: free_symlist
static void
free_symlist(symentry_t *list)
{
	if (list)
	{	free_symlist(list->next);
		memset(list, 0, sizeof(symentry_t));	/* was symentry * */
		list->next = fses;
		fses = list;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x711a
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x70d0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x3140
movq 0x492f1(%rip), %rcx     # 0x503f8
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x492de(%rip)     # 0x503f8
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Uno/Src/tree.c
// Function: make_node
treenode *
make_node(tn_t type)
{
    treenode *tmp_node;

    tmp_node = (treenode *) HeapAlloc(Parse_TOS->node_heap);

    if (tmp_node == NULL)
    {
        fputs("Error: Out of memory in make_node.\n",stderr);
        exit(1);
    }

    tmp_node->hdr.which = NODE_T;
    tmp_node->hdr.type  = type;
    tmp_node->hdr.defuse = 0;
    tmp_node->hdr.fnm = Parse_TOS->filename;
    tmp_node->hdr.line = Parse_TOS->yylineno;

    tmp_node->lnode = (treenode *) NULL;
    tmp_node->rnode = (treenode *) NULL;
    tmp_node->syment = (symentry_t *) NULL;

    return tmp_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x46796(%rip), %rax     # 0x4e318
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x52a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7bb9
movq 0x46458(%rip), %rax     # 0x4dff8
movq (%rax), %rsi
leaq 0x2d99e(%rip), %rdi     # 0x35548
callq 0x3130
movl $0x1, %edi
callq 0x3230
movq -0x10(%rbp), %rax
movl $0x4, (%rax)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
leaq 0x46738(%rip), %rax     # 0x4e318
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x46722(%rip), %rax     # 0x4e318
movq (%rax), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)