LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_dump_records
void xlink_omf_dump_records(xlink_omf *omf) {
  int i;
  xlink_omf_record *rec;
  printf("Summary of records:\n");
  for (i = 0, rec = omf->records; i < omf->nrecords; i++, rec++) {
    printf("  %02Xh %-7s - %-32s%6i bytes%s\n", rec->type,
     xlink_omf_record_get_name(rec->type), xlink_omf_record_get_desc(rec->type),
     3 + rec->size - 1, rec->type & 1 ? " 32-bit" : "");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x9ca6(%rip), %rdi      # 0xeb29
movb $0x0, %al
callq 0x20a0
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4f38
movq -0x18(%rbp), %rax
movzbl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movzbl 0xc(%rax), %edi
callq 0x3110
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movzbl 0xc(%rax), %edi
callq 0x4f40
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
movq -0x18(%rbp), %rax
movzwl 0xe(%rax), %r8d
addl $0x3, %r8d
subl $0x1, %r8d
movq -0x18(%rbp), %rax
movzbl 0xc(%rax), %edi
andl $0x1, %edi
leaq 0xa95c(%rip), %r9       # 0xf85e
leaq 0x9c56(%rip), %rax      # 0xeb5f
cmpl $0x0, %edi
cmovneq %rax, %r9
leaq 0x9c27(%rip), %rdi      # 0xeb3e
movb $0x0, %al
callq 0x20a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0x4e9c
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_record_get_desc
static const char *xlink_omf_record_get_desc(xlink_omf_record_type type) {
  switch (type & ~1) {
    case OMF_THEADR : return "Translator Header";
    case OMF_LHEADR : return "Library Module Header";
    case OMF_MODEND : return "Module End";
    case OMF_EXTDEF : return "External Names Definition";
    case OMF_PUBDEF : return "Public Names Definition";
    case OMF_FIXUPP : return "Fixup";
    case OMF_GRPDEF : return "Group Definition";
    case OMF_LNAMES : return "List of Names";
    case OMF_SEGDEF : return "Segment Definition";
    case OMF_LEDATA : return "Logical Enumerated Data";
    case OMF_LIDATA : return "Logical Iterated Data";
    case OMF_COMDEF : return "Communal Names Definition";
    case OMF_LEXTDEF : return "Local External Names Definition";
    case OMF_LPUBDEF : return "Local Public Names";
    case OMF_CEXTDEF : return "COMDAT External Names Definition";
    case OMF_COMDAT : return "Initialized Communal Data";
    case OMF_LLNAMES : return "Local Logical Names Definition";
    default : return "Unknown or Unsupported";
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $-0x2, %eax
addl $-0x80, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4a, %eax
ja 0x5068
movq -0x18(%rbp), %rax
leaq 0x921e(%rip), %rcx      # 0xe188
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xaa27(%rip), %rax      # 0xf9a1
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa29(%rip), %rax      # 0xf9b3
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa2f(%rip), %rax      # 0xf9c9
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaafc(%rip), %rax      # 0xfaa6
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa1a(%rip), %rax      # 0xf9d4
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa22(%rip), %rax      # 0xf9ec
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa18(%rip), %rax      # 0xf9f2
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa19(%rip), %rax      # 0xfa03
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa17(%rip), %rax      # 0xfa11
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa1d(%rip), %rax      # 0xfa24
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa28(%rip), %rax      # 0xfa3c
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa31(%rip), %rax      # 0xfa52
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa3e(%rip), %rax      # 0xfa6c
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa51(%rip), %rax      # 0xfa8c
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa57(%rip), %rax      # 0xfa9f
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa6b(%rip), %rax      # 0xfac0
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa78(%rip), %rax      # 0xfada
movq %rax, -0x8(%rbp)
jmp 0x5073
leaq 0xaa8a(%rip), %rax      # 0xfaf9
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_dump_lxdata
void xlink_omf_dump_lxdata(xlink_omf *omf, xlink_module *mod) {
  int i;
  xlink_omf_record *rec;
  printf("LEDATA, LIDATA, COMDAT and FIXUPP records:\n");
  for (i = 0, rec = omf->records; i < omf->nrecords; i++, rec++) {
    xlink_segment *seg;
    int offset;
    xlink_omf_record_reset(rec);
    switch (rec->type & ~1) {
      case OMF_LEDATA : {
        seg = xlink_module_get_segment(mod, xlink_omf_record_read_index(rec));
        offset = xlink_omf_record_read_numeric(rec);
        printf("  LEDATA: segment %8s, offset 0x%04x, size 0x%04x\n",
         xlink_segment_get_name(seg), offset, 3 + rec->size - 1 - rec->idx);
        break;
      }
      case OMF_LIDATA : {
        seg = xlink_module_get_segment(mod, xlink_omf_record_read_index(rec));
        offset = xlink_omf_record_read_numeric(rec);
        printf("  LIDATA: segment %8s, offset 0x%04x, size ",
         xlink_segment_get_name(seg), offset);
        printf(" = 0x%04x\n", xlink_omf_record_read_lidata_block(rec));
        break;
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x9ad0(%rip), %rdi      # 0xeb67
movb $0x0, %al
callq 0x20a0
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x51cd
movq -0x20(%rbp), %rdi
callq 0x51e0
movq -0x20(%rbp), %rax
movzbl 0xc(%rax), %eax
andl $-0x2, %eax
movl %eax, -0x30(%rbp)
subl $0xa0, %eax
je 0x50ef
jmp 0x50e0
movl -0x30(%rbp), %eax
subl $0xa2, %eax
je 0x514f
jmp 0x51b1
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5200
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x3440
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4b70
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2760
movq %rax, %rsi
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movzwl 0xe(%rax), %ecx
addl $0x3, %ecx
subl $0x1, %ecx
movq -0x20(%rbp), %rax
subl 0x8(%rax), %ecx
leaq 0x9a4d(%rip), %rdi      # 0xeb93
movb $0x0, %al
callq 0x20a0
jmp 0x51b1
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5200
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x3440
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4b70
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2760
movq %rax, %rsi
movl -0x2c(%rbp), %edx
leaq 0x9a35(%rip), %rdi      # 0xebc6
movb $0x0, %al
callq 0x20a0
movq -0x20(%rbp), %rdi
callq 0x4d90
movl %eax, %esi
leaq 0x9a48(%rip), %rdi      # 0xebf2
movb $0x0, %al
callq 0x20a0
jmp 0x51b3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x50b0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_record_read_index
static unsigned int xlink_omf_record_read_index(xlink_omf_record *rec) {
  unsigned char byte;
  byte = xlink_omf_record_read_byte(rec);
  if (byte & 0x80) {
    return ((byte & 0x7f) << 8) | xlink_omf_record_read_byte(rec);
  }
  return byte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4cf0
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x524b
movzbl -0x11(%rbp), %eax
andl $0x7f, %eax
shll $0x8, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4cf0
movb %al, %cl
movl -0x18(%rbp), %eax
movzbl %cl, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5252
movzbl -0x11(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_module_dump_names
void xlink_module_dump_names(xlink_module *mod) {
  int i;
  if (mod->nnames > 0) {
    printf("Local names:\n");
    for (i = 1; i <= mod->nnames; i++) {
      char buf[256];
      sprintf(buf, "'%s'", xlink_module_get_name(mod, i)->str);
      printf("%2i : %8s\n", i, buf);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x120(%rax)
jle 0x52fb
leaq 0x997a(%rip), %rdi      # 0xebfd
movb $0x0, %al
callq 0x20a0
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x120(%rcx), %eax
jg 0x52f9
leaq -0x110(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x32e0
movq -0x118(%rbp), %rdi
movq %rax, %rdx
addq $0x10, %rdx
leaq 0x9efa(%rip), %rsi      # 0xf1c9
movb $0x0, %al
callq 0x21b0
movl -0xc(%rbp), %esi
leaq -0x110(%rbp), %rdx
leaq 0x9924(%rip), %rdi      # 0xec0b
movb $0x0, %al
callq 0x20a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5291
jmp 0x52fb
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: pub_comp
int pub_comp(const void *a, const void *b) {
  const xlink_public *pub_a;
  const xlink_public *pub_b;
  pub_a = *(xlink_public **)a;
  pub_b = *(xlink_public **)b;
  return pub_a->offset - pub_b->offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x124(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x124(%rcx), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: rel_comp
int rel_comp(const void *a, const void *b) {
  const xlink_reloc *rel_a;
  const xlink_reloc *rel_b;
  rel_a = *(xlink_reloc **)a;
  rel_b = *(xlink_reloc **)b;
  return rel_a->offset - rel_b->offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x18(%rcx), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_omf_record_load_iterated
int xlink_omf_record_load_iterated(xlink_omf_record *rec, unsigned char *data,
 int length) {
  unsigned char *block;
  unsigned int repeat_count;
  unsigned int block_count;
  unsigned int size;
  int i;
  block = data;
  repeat_count = xlink_omf_record_read_numeric(rec);
  block_count = xlink_omf_record_read_word(rec);
  if (block_count) {
    size = 0;
    for (i = 0; i < block_count; i++) {
      int block_size;
      block_size = xlink_omf_record_load_iterated(rec, block, length);
      block += block_size;
      length -= block_size;
      size += block_size;
    }
  }
  else {
    size = xlink_omf_record_read_byte(rec);
    XLINK_ERROR(size > length,
     ("LIDATA wrote past end of segment, size = %i but length = %i", size,
     length));
    memcpy(block, &rec->buf[rec->idx], size);
    block += size;
    rec->idx += size;
  }
  for (i = 1; i < repeat_count; i++) {
    memcpy(block, data, size);
    block += size;
  }
  return repeat_count*size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4b70
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4bf0
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x61c7
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x61c5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x6130
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x34(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x34(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x617a
jmp 0x623b
movq -0x8(%rbp), %rdi
callq 0x4cf0
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0x61fc
movl -0x2c(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x8bcd(%rip), %rdi      # 0xedb8
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x61fe
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rax
addq %rax, %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x2100
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl $0x1, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x6277
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x2100
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x6242
movl -0x24(%rbp), %eax
imull -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_segment_get_class
xlink_segment_class xlink_segment_get_class(const xlink_segment *seg) {
  if (strcmp(seg->class->str, "CODE") == 0) {
    return OMF_SEGMENT_CODE;
  }
  if (seg->info & SEG_HAS_DATA) {
    return OMF_SEGMENT_DATA;
  }
  return OMF_SEGMENT_BSS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x10, %rdi
leaq 0x76f9(%rip), %rsi      # 0xf0b8
callq 0x20d0
cmpl $0x0, %eax
jne 0x79d2
movl $0x0, -0x4(%rbp)
jmp 0x79f1
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x79ea
movl $0x1, -0x4(%rbp)
jmp 0x79f1
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: seg_comp
int seg_comp(const void *a, const void *b) {
  const xlink_segment *seg_a;
  const xlink_segment *seg_b;
  seg_a = *(xlink_segment **)a;
  seg_b = *(xlink_segment **)b;
  if (xlink_segment_get_class(seg_a) == xlink_segment_get_class(seg_b)) {
    if (seg_a->attrib.proc == seg_b->attrib.proc) {
      if (seg_a->module == seg_b->module) {
        return seg_a->index - seg_b->index;
      }
      return seg_a->module->index - seg_b->module->index;
    }
    return seg_a->attrib.proc - seg_b->attrib.proc;
  }
  return xlink_segment_get_class(seg_a) - xlink_segment_get_class(seg_b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79a0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x79a0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x7abf
movq -0x20(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
movb 0x10(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x7a9f
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x7a84
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ade
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x7ade
movq -0x20(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
movb 0x10(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x7ade
movq -0x20(%rbp), %rdi
callq 0x79a0
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x79a0
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_link_root_segment
void xlink_binary_link_root_segment(xlink_binary *bin, xlink_segment *root) {
  int i;
  xlink_binary_process_segment(bin, root);
  for (i = 1; i <= bin->nexterns; i++) {
    xlink_extern *ext;
    ext = xlink_binary_get_extern(bin, i);
    if (ext->is_local) {
      ext->public = xlink_module_find_public(ext->module, ext->name);
    }
    else {
      ext->public = xlink_binary_find_public(bin, ext->name);
    }
    if (ext->public->segment != NULL) {
      xlink_binary_process_segment(bin, ext->public->segment);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x46a0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jg 0x7bbf
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x45e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x114(%rax)
je 0x7b66
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x3cd0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x118(%rax)
jmp 0x7b85
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
callq 0x4210
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x20(%rbp), %rax
movq 0x118(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x7baf
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x118(%rax), %rax
movq 0x18(%rax), %rsi
callq 0x46a0
jmp 0x7bb1
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7b14
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_sort_segments
void xlink_sort_segments(xlink_segment **segments, int nsegments, int *data_idx,
 int *bss_idx) {
  int i;
  qsort(segments, nsegments, sizeof(xlink_segment *), seg_comp);
  if (data_idx != NULL) {
    for (i = 0; i < nsegments; i++) {
      if (xlink_segment_get_class(segments[i]) == OMF_SEGMENT_DATA) break;
    }
    *data_idx = i;
  }
  if (bss_idx != NULL) {
    for (i = 0; i < nsegments; i++) {
      if (xlink_segment_get_class(segments[i]) == OMF_SEGMENT_BSS) break;
    }
    *bss_idx = i;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movl $0x8, %edx
leaq -0x1fb(%rip), %rcx      # 0x7a00
callq 0x2050
cmpq $0x0, -0x18(%rbp)
je 0x7c44
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7c3b
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x79a0
cmpl $0x1, %eax
jne 0x7c2e
jmp 0x7c3b
jmp 0x7c30
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7c0e
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x7c88
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7c7f
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x79a0
cmpl $0x2, %eax
jne 0x7c72
jmp 0x7c7f
jmp 0x7c74
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7c52
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_set_first_segment
void xlink_set_first_segment(xlink_segment **segments, xlink_segment *first) {
  int i;
  for (i = 0; segments[i] != first; i++);
  memmove(&segments[1], &segments[0], sizeof(*segments)*i);
  segments[0] = first;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
je 0x7cc6
jmp 0x7cbb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7ca7
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq $0x3, %rdx
callq 0x2170
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_layout_segments
void xlink_binary_layout_segments(xlink_binary *bin, int index, int offset) {
  int i;
  for (i = index + 1; i <= bin->nsegments; i++) {
    xlink_segment *seg;
    seg = xlink_binary_get_segment(bin, i);
    /* If this is a 32-bit program, move all 32-bit BSS above the first 64k */
    if (bin->is_32bit && seg->attrib.proc == OMF_SEGMENT_USE32 &&
     xlink_segment_get_class(seg) == OMF_SEGMENT_BSS && offset < 0x10000) {
      offset = 0x10000;
    }
    offset = ALIGN2(offset, xlink_segment_get_alignment(seg));
    seg->start = offset;
    offset += seg->length;
  }
  XLINK_ERROR(!bin->is_32bit && offset > 65536,
   ("Address space exceeds 65536 bytes, %i", offset));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jg 0x7dd0
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x44b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x7d64
movq -0x20(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x7d64
movq -0x20(%rbp), %rdi
callq 0x79a0
cmpl $0x2, %eax
jne 0x7d64
cmpl $0x10000, -0x10(%rbp)   # imm = 0x10000
jge 0x7d64
movl $0x10000, -0x10(%rbp)   # imm = 0x10000
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x27e0
movl %eax, %ecx
movl -0x28(%rbp), %eax
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
callq 0x27e0
movl %eax, %ecx
movl -0x24(%rbp), %eax
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x7c(%rax)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7d0b
jmp 0x7dd2
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jne 0x7e00
cmpl $0x10000, -0x10(%rbp)   # imm = 0x10000
jle 0x7e00
movl -0x10(%rbp), %esi
leaq 0x72ce(%rip), %rdi      # 0xf0bd
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x7e02
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_extract_class
int xlink_binary_extract_class(xlink_binary *bin, int index, int offset,
 xlink_segment_class class, xlink_list *bytes) {
  int i;
  for (i = index + 1; i <= bin->nsegments; i++) {
    xlink_segment *seg;
    seg = xlink_binary_get_segment(bin, i);
    if (xlink_segment_get_class(seg) != class) break;
    XLINK_ERROR(seg->info & SEG_HAS_DATA == 0,
     ("Error segment %s has no data", xlink_segment_get_name(seg)));
    if (offset != seg->start) {
      unsigned char buf[4096];
      memset(buf, 0, 4096);
      xlink_list_add_all(bytes, buf, seg->start - offset);
      offset = seg->start;
    }
    xlink_list_add_all(bytes, seg->data, seg->length);
    offset += seg->length;
  }
  return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jg 0x7f55
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x44b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x79a0
cmpl -0x14(%rbp), %eax
je 0x7ea8
jmp 0x7f55
jmp 0x7eaa
movq -0x30(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x0, %eax
cmpl $0x0, %eax
je 0x7edd
movq -0x30(%rbp), %rdi
callq 0x2760
movq %rax, %rsi
leaq 0x7217(%rip), %rdi      # 0xf0e3
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x7edf
movl -0x10(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl 0x7c(%rcx), %eax
je 0x7f22
leaq -0x1030(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20b0
movq -0x20(%rbp), %rdi
leaq -0x1030(%rbp), %rsi
movq -0x30(%rbp), %rax
movl 0x7c(%rax), %edx
subl -0x10(%rbp), %edx
callq 0xc9b0
movq -0x30(%rbp), %rax
movl 0x7c(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %edx
callq 0xc9b0
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7e75
movl -0x10(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_model_search
void xlink_model_search(xlink_list *models, xlink_list *bytes) {
  xlink_modeler mod;
  /* Build a context modeler for bytes */
  xlink_modeler_init(&mod, xlink_list_length(bytes));
  xlink_modeler_load_binary(&mod, bytes);
  /* Search for the best context to use for bytes */
  xlink_list_empty(models);
  xlink_modeler_search(&mod, models);
  XLINK_ERROR(xlink_list_length(models) == 0,
   ("Error no context models found for bytes"));
  xlink_modeler_clear(&mod);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc6a0
movl %eax, %esi
leaq -0x98(%rbp), %rdi
callq 0xbc10
movq -0x10(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xbcc0
movq -0x8(%rbp), %rdi
callq 0xc6c0
movq -0x8(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xc320
movq -0x8(%rbp), %rdi
callq 0xc6a0
cmpl $0x0, %eax
jne 0x7fe9
leaq 0x7128(%rip), %rdi      # 0xf100
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x7feb
leaq -0x98(%rbp), %rdi
callq 0xbc80
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_decoder_test_bytes
void xlink_decoder_test_bytes(xlink_decoder *dec, xlink_list *bytes) {
  int i;
  for (i = 0; i < xlink_list_length(bytes); i++) {
    unsigned char orig;
    unsigned char byte;
    orig = *xlink_list_get_byte(bytes, i);
    byte = xlink_decoder_read_byte(dec);
    XLINK_ERROR(byte != orig,
     ("Decoder mismatch %02x != %02x at pos = %i", byte, orig, i));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc6a0
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0x810a
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc870
movb (%rax), %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
callq 0xacc0
movb %al, -0x16(%rbp)
movzbl -0x16(%rbp), %eax
movzbl -0x15(%rbp), %ecx
cmpl %ecx, %eax
je 0x80fb
movzbl -0x16(%rbp), %esi
movzbl -0x15(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x703e(%rip), %rdi      # 0xf128
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x80fd
jmp 0x80ff
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8097
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_bitstream_from_context
void xlink_bitstream_from_context(xlink_bitstream *bs, xlink_context *ctx,
 xlink_list *bytes) {
  xlink_encoder enc;
  xlink_decoder dec;
  bs->bytes.length = 0;
  /* Reset the context */
  xlink_context_reset(ctx);
  /* Encode bytes with the context */
  xlink_encoder_init(&enc, ctx);
  xlink_encoder_write_bytes(&enc, bytes);
  /* Finalize the bitstream */
  xlink_encoder_finalize(&enc, bs);
  xlink_encoder_clear(&enc);
  /* Reset the context */
  xlink_context_reset(ctx);
  /* Initialize the decoder with the context and bitstream */
  xlink_decoder_init(&dec, ctx, bs);
  /* Test that decoded bytes match original input */
  xlink_decoder_test_bytes(&dec, bytes);
  xlink_decoder_clear(&dec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0xb940
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa2d0
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa4c0
movq -0x8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa630
leaq -0x50(%rbp), %rdi
callq 0xa4a0
movq -0x10(%rbp), %rdi
callq 0xb940
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0xaa70
movq -0x18(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x8080
leaq -0x78(%rbp), %rdi
callq 0xacb0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_load_modules
void xlink_binary_load_modules(xlink_binary *bin) {
  int i;
  for (i = 0; i < sizeof(XLINK_STUB_MODULES)/sizeof(xlink_file); i++) {
    xlink_file file;
    file = XLINK_STUB_MODULES[i];
    if (strstr(file.name, "stub32") == NULL) {
      xlink_module *mod;
      mod = xlink_file_load_omf_module(&file, 0);
      XLINK_LIST_ADD(binary, module, bin, mod);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x1a, %rax
jae 0x83c9
movslq -0xc(%rbp), %rcx
leaq 0xb604(%rip), %rax      # 0x13950
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x6ddd(%rip), %rsi      # 0xf152
callq 0x2200
cmpq $0x0, %rax
jne 0x83b9
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x6290
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3fb0
jmp 0x83bb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8333
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_load_stub
void xlink_binary_load_stub(xlink_binary *bin, const char *stub) {
  char buf[1024];
  xlink_module *mod;
  int i;
  sprintf(buf, "stubs/%s.o", stub);
  mod = NULL;
  for (i = 0; i < sizeof(XLINK_STUB_MODULES)/sizeof(xlink_file); i++) {
    xlink_file file;
    file = XLINK_STUB_MODULES[i];
    if (strcmp(file.name, buf) == 0) {
      mod = xlink_file_load_omf_module(&file, 0);
      XLINK_LIST_ADD(binary, module, bin, mod);
      break;
    }
  }
  XLINK_ERROR(mod == NULL, ("Stub %s not found", stub));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x6d64(%rip), %rsi      # 0xf159
movb $0x0, %al
callq 0x21b0
movq $0x0, -0x418(%rbp)
movl $0x0, -0x41c(%rbp)
movslq -0x41c(%rbp), %rax
cmpq $0x1a, %rax
jae 0x84cf
movslq -0x41c(%rbp), %rcx
leaq 0xb520(%rip), %rax      # 0x13950
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x438(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x430(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x428(%rbp)
movq -0x438(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x20d0
cmpl $0x0, %eax
jne 0x84b9
leaq -0x438(%rbp), %rdi
xorl %esi, %esi
callq 0x6290
movq %rax, -0x418(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movq -0x418(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x418(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movq -0x418(%rbp), %rsi
callq 0x3fb0
jmp 0x84cf
jmp 0x84bb
movl -0x41c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x41c(%rbp)
jmp 0x8411
jmp 0x84d1
cmpq $0x0, -0x418(%rbp)
jne 0x84f7
movq -0x10(%rbp), %rsi
leaq 0x6c7e(%rip), %rdi      # 0xf164
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x84f9
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_find_segment_by_public
xlink_segment *xlink_binary_find_segment_by_public(xlink_binary *bin,
 const char *public, xlink_segment_class class) {
  xlink_segment *seg;
  seg = xlink_binary_find_public(bin, public)->segment;
  XLINK_ERROR(xlink_segment_get_class(seg) != class,
   ("Public %s found in segment %s, but class %s not '%s'", public,
   xlink_segment_get_name(seg), xlink_segment_get_class_name(seg),
   XLINK_SEGMENT_CLASS_NAME[class]));
  return seg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4210
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x79a0
cmpl -0x14(%rbp), %eax
je 0x8597
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2760
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x27a0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
movl -0x14(%rbp), %eax
movl %eax, %edi
leaq 0xeb95(%rip), %rax      # 0x17110
movq (%rax,%rdi,8), %r8
leaq 0x6bf0(%rip), %rdi      # 0xf176
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x8599
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_write_map
void xlink_binary_write_map(xlink_binary *bin) {
  FILE *out;
  out = fopen(bin->map, "w");
  xlink_binary_print_map(bin, out);
  fclose(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
leaq 0x7091(%rip), %rsi      # 0xf65c
callq 0x2180
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x47b0
movq -0x10(%rbp), %rdi
callq 0x2070
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_write_com
void xlink_binary_write_com(xlink_binary *bin, int nsegments) {
  FILE *out;
  int i;
  int offset;
  out = fopen(bin->output, "wb");
  XLINK_ERROR(out == NULL, ("Unable to open output file '%s'", bin->output));
  for (offset = 0x100, i = 1; i <= nsegments; i++) {
    xlink_segment *seg;
    seg = xlink_binary_get_segment(bin, i);
    if (seg->info & SEG_HAS_DATA) {
      if (offset != seg->start) {
        unsigned char buf[4096];
        memset(buf, 0, 4096);
        fwrite(buf, 1, seg->start - offset, out);
        offset = seg->start;
      }
      fwrite(seg->data, 1, seg->length, out);
      offset += seg->length;
    }
  }
  fclose(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x6b9b(%rip), %rsi      # 0xf1ab
callq 0x2180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x863f
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x6b80(%rip), %rdi      # 0xf1ae
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x8641
movl $0x100, -0x20(%rbp)     # imm = 0x100
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x8700
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x44b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x86f0
movl -0x20(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x7c(%rcx), %eax
je 0x86c5
leaq -0x1030(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20b0
leaq -0x1030(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x7c(%rax), %eax
subl -0x20(%rbp), %eax
movslq %eax, %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x21d0
movq -0x28(%rbp), %rax
movl 0x7c(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x28(%rbp), %rax
movslq 0x1c(%rax), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x21d0
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x86f2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x864f
movq -0x18(%rbp), %rdi
callq 0x2070
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_segment_find_reloc
xlink_reloc *xlink_segment_find_reloc(xlink_segment *seg, const char *name) {
  xlink_reloc *ret;
  int i;
  ret = NULL;
  for (i = 1; i <= seg->nrelocs; i++) {
    xlink_reloc *rel;
    rel = xlink_segment_get_reloc(seg, i);
    if (rel->target == OMF_TARGET_EXT) {
      xlink_extern *ext;
      ext = xlink_module_get_extern(seg->module, rel->target_idx);
      if (strcmp(ext->name, name) == 0) {
        XLINK_ERROR(ret != NULL,
         ("Duplicate relocation definition found for name %s in %s", name,
         seg->module->filename));
        ret = rel;
        break;
      }
    }
  }
  XLINK_ERROR(ret == NULL, ("No relocation found for extern name %s", name));
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jg 0x87e5
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2630
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x6, 0x28(%rax)
jne 0x87d5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x39c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
callq 0x20d0
cmpl $0x0, %eax
jne 0x87d3
jmp 0x8799
cmpq $0x0, -0x18(%rbp)
je 0x87c7
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdx
leaq 0x6a18(%rip), %rdi      # 0xf1ce
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x87c9
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x87e5
jmp 0x87d5
jmp 0x87d7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x873f
jmp 0x87e7
cmpq $0x0, -0x18(%rbp)
jne 0x880a
movq -0x10(%rbp), %rsi
leaq 0x6a0d(%rip), %rdi      # 0xf206
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x880c
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_binary_get_relative_byte
unsigned char xlink_binary_get_relative_byte(xlink_binary *bin,
 xlink_segment *prog, int relative) {
  int prog_idx;
  int i;
  unsigned char byte;
  XLINK_ERROR(relative >= 0,
   ("Relative byte index should be negative, %i", relative));
  for (prog_idx = bin->nsegments; prog_idx-- > 0; ) {
    if (bin->segments[prog_idx] == prog) {
      break;
    }
  }
  XLINK_ERROR(prog_idx < 0, ("PROG segment index not found"));
  for (i = prog_idx; relative < 0 && i-- > 0; ) {
    relative += bin->segments[i + 1]->start - bin->segments[i]->start;
  }
  XLINK_ERROR(i < 0, ("Relative byte %i bytes before program start", relative));
  byte = 0;
  if (relative <= bin->segments[i]->length) {
    byte = bin->segments[i]->data[relative];
  }
  return byte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x8854
movl -0x14(%rbp), %esi
leaq 0x69ea(%rip), %rdi      # 0xf22d
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x8856
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x18(%rbp)
cmpl $0x0, %eax
jle 0x888a
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x8888
jmp 0x888a
jmp 0x8860
jmp 0x888c
cmpl $0x0, -0x18(%rbp)
jge 0x88aa
leaq 0x69bf(%rip), %rdi      # 0xf258
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x88ac
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x1e(%rbp)
jge 0x88d1
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
testb $0x1, %al
jne 0x88da
jmp 0x890d
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl 0x7c(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
subl 0x7c(%rcx), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x88b2
jmp 0x890f
cmpl $0x0, -0x1c(%rbp)
jge 0x8930
movl -0x14(%rbp), %esi
leaq 0x6956(%rip), %rdi      # 0xf275
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0x8932
movb $0x0, -0x1d(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl 0x1c(%rcx), %eax
jg 0x896c
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/xlink.c
// Function: xlink_parity
int xlink_parity(unsigned char byte) {
  int bits;
  bits = 0;
  while (byte > 0) {
    bits += byte & 1;
    byte >>= 1;
  }
  return bits & 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x0, %eax
jle 0x89b2
movzbl -0x1(%rbp), %eax
andl $0x1, %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movzbl -0x1(%rbp), %eax
sarl %eax
movb %al, -0x1(%rbp)
jmp 0x8991
movl -0x8(%rbp), %eax
andl $0x1, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/ec.c
// Function: xlink_bitstream_copy_bits
void xlink_bitstream_copy_bits(xlink_bitstream *bs, unsigned char *dst,
 int pos) {
  int i;
  /* Intentionally skip the first bit */
  for (i = 1; i < bs->bits; i++, pos++) {
    XLINK_SET_BIT(dst, pos, XLINK_GET_BIT(bs->bytes.data, i));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jge 0xa2c3
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl -0x14(%rbp), %ecx
andl $0x7, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
xorl $-0x1, %ecx
andl %ecx, %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl -0x18(%rbp), %edx
sarl $0x3, %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %edx
movl -0x18(%rbp), %ecx
andl $0x7, %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x1, %ecx
cmpl $0x0, %ecx
setne %cl
xorb $-0x1, %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %edx
movl -0x14(%rbp), %ecx
andl $0x7, %ecx
shll %cl, %edx
movl %edx, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
sarl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa226
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/ec.c
// Function: xlink_encoder_init
void xlink_encoder_init(xlink_encoder *enc, xlink_context *ctx) {
  enc->ctx = ctx;
  xlink_list_init(&enc->bytes, sizeof(unsigned char), 0);
  enc->bits = 0;
  enc->low = 0;
  enc->range = EC_BASE;
  enc->zero = 0;
  enc->ones = 0;
  /* Start by writing a 1 bit, this is necessary for decoder implementation */
  xlink_encoder_write_bit(enc, 1, 1, 1);
  /* Update the context with 1 bit */
  xlink_context_update_bit(enc->ctx, 0, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xc610
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x80000000, 0x28(%rax) # imm = 0x80000000
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0xa370
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xba90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/negge[P]xlink/src/ec.c
// Function: xlink_encoder_write_bit
static void xlink_encoder_write_bit(xlink_encoder *enc, xlink_word c0,
 xlink_word c1, int bit) {
  xlink_word s;
  XLINK_ERROR(c0 == 0 || c1 == 0 || (c0 > EC_MASK - c1),
   ("Error invalid counts, c0 = %i and c1 = %i", c0, c1));
  s = ((xlink_dword)enc->range)*c1/(c0 + c1);
  enc->range = bit ? s : enc->range - s;
  if (!bit) {
    /* Handle carry */
    if (s > EC_MASK - enc->low) {
      xlink_encoder_emit(enc, 1);
    }
    enc->low += s;
  }
  /* Normalize */
  while (enc->range < EC_BASE) {
    if (enc->low & EC_BASE) {
      enc->ones++;
    }
    else {
      xlink_encoder_emit(enc, 0);
    }
    enc->low <<= 1;
    enc->range <<= 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xa3a0
cmpl $0x0, -0x10(%rbp)
je 0xa3a0
movl -0xc(%rbp), %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
subl -0x10(%rbp), %ecx
cmpl %ecx, %eax
jbe 0xa3be
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x5d13(%rip), %rdi      # 0x100c0
movb $0x0, %al
callq 0xad90
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x21c0
jmp 0xa3c0
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl -0x10(%rbp), %ecx
imulq %rcx, %rax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
movl %ecx, %ecx
xorl %edx, %edx
divq %rcx
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xa3ec
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xa3f9
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
cmpl $0x0, -0x14(%rbp)
jne 0xa437
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rdx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
subl 0x24(%rdx), %ecx
cmpl %ecx, %eax
jbe 0xa42a
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xa760
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x24(%rax), %ecx
movl %ecx, 0x24(%rax)
jmp 0xa439
movq -0x8(%rbp), %rax
cmpl $0x80000000, 0x28(%rax) # imm = 0x80000000
jae 0xa48b
movq -0x8(%rbp), %rax
movl 0x24(%rax), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0xa466
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x30(%rax)
jmp 0xa471
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0xa760
movq -0x8(%rbp), %rax
movl 0x24(%rax), %ecx
shll %ecx
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
shll %ecx
movl %ecx, 0x28(%rax)
jmp 0xa439
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)