LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: create_client
static client *create_client(xcb_window_t win, xcb_atom_t wtype)
{
    xcb_icccm_wm_hints_t hints;
    client *c = calloc(1, sizeof(client));
    if (!c)
        err(EXIT_FAILURE, "cannot allocate client");
    c->isurgent = False;
    c->istransient = False;
    c->isfullscreen = False;
    c->ismaximized = False;
    c->isfloating = False;
    c->win = win;
    c->type = wtype;
    c->dim[0] = c->dim[1] = 0;
    c->borderwidth = -1;    /* default: use global border width */
    c->setfocus = True;     /* default: prefer xcb_set_input_focus(); */
    if (xcb_icccm_get_wm_hints_reply(dis,
            xcb_icccm_get_wm_hints(dis, win), &hints, NULL))
        c->setfocus = (hints.input) ? True : False;

    xcb_get_geometry_reply_t *g = get_geometry(c->win);
    c->position_info.previous_x = c->position_info.current_x = g->x;
    c->position_info.previous_y = c->position_info.current_y = g->y;
    free(g);

    return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x3300
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x953b
movl $0x1, %edi
leaq 0xf10(%rip), %rsi       # 0xa444
movb $0x0, %al
callq 0x3400
movq -0x38(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x19(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1b(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1c(%rax)
movq -0x38(%rbp), %rax
movb $0x0, 0x1a(%rax)
movl -0x4(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x8(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x38(%rbp), %rax
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
movq -0x38(%rbp), %rax
movb $0x1, 0x44(%rax)
movq 0x41f9(%rip), %rax      # 0xd7a0
movq %rax, -0x50(%rbp)
movq 0x41ee(%rip), %rdi      # 0xd7a0
movl -0x4(%rbp), %esi
callq 0x3030
movq -0x50(%rbp), %rdi
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
leaq -0x2c(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3640
cmpb $0x0, %al
je 0x95f5
movl -0x28(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x44(%rax)
movq -0x38(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x8e40
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movswl 0xc(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x38(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x48(%rbp), %rax
movswl 0xe(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x3c(%rax)
movq -0x38(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x48(%rbp), %rdi
callq 0x3050
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: unfloat_client
void unfloat_client(client *c)
{
    if (!c)
        return;

    c->isfloating = false;

    xcb_get_geometry_reply_t *r = get_geometry(c->win);
    c->dim[0] = r->width;
    c->dim[1] = r->height;
    free(r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9675
jmp 0x96b4
movq -0x8(%rbp), %rax
movb $0x0, 0x1a(%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x8e40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movzwl 0x12(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rdi
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kaugm[P]mmwm/mmwm.c
// Function: cleanup_display
static void cleanup_display(void)
{
    desktop *desk;
    for (desk = (desktop *)rem_head(&desktops); desk; desk = (desktop *)rem_head(&desktops)) {
        monitor *moni;
        for (moni = (monitor *)rem_head(&desk->monitors); moni; moni = (monitor *)rem_head(&desk->monitors)) {
            display *disp;
            for (disp = (display *)rem_head(&moni->displays); disp; disp = (display *)rem_head(&moni->displays)) {
                client *c;
                for (c = (client *)rem_head(&disp->clients); c; c = (client *)rem_head(&disp->clients)) {
                    xcb_border_width(dis, c->win, 0);
                    free(c);
                }
                for (struct lifo *l = (lifo *)rem_head(&disp->miniq); l; l = (lifo *)rem_head(&disp->miniq))
                    free(l);

                free(disp);
            }
            free(moni);
        }
        free(desk);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x4109(%rip), %rdi      # 0xd808
callq 0x5660
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x9824
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x5660
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9806
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x5660
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x97e7
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x5660
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x9794
movq 0x4036(%rip), %rdi      # 0xd7a0
movq -0x20(%rbp), %rax
movl 0x20(%rax), %esi
xorl %edx, %edx
callq 0x3c90
movq -0x20(%rbp), %rdi
callq 0x3050
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x5660
movq %rax, -0x20(%rbp)
jmp 0x975c
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x5660
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x97c8
movq -0x28(%rbp), %rdi
callq 0x3050
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
callq 0x5660
movq %rax, -0x28(%rbp)
jmp 0x97a5
movq -0x18(%rbp), %rdi
callq 0x3050
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x5660
movq %rax, -0x18(%rbp)
jmp 0x9740
movq -0x10(%rbp), %rdi
callq 0x3050
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x5660
movq %rax, -0x10(%rbp)
jmp 0x9724
movq -0x8(%rbp), %rdi
callq 0x3050
leaq 0x3ff2(%rip), %rdi      # 0xd808
callq 0x5660
movq %rax, -0x8(%rbp)
jmp 0x9708
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/5-Signal/alarm_fgets.c
// Function: main
int main(void)
{
	char buf[1024];
	signal(SIGALRM, sig_handler);
	alarm(TIMEOUT);
	if(fgets(buf, 1024, stdin) == NULL)
	{
		printf("No input. Goodbye!\n");
		exit(0);
	}
	alarm(0);
	printf("Your input: %s", buf);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movl $0x0, -0x4(%rbp)
movl $0xe, %edi
leaq -0x3e(%rip), %rsi       # 0x1180
callq 0x1060
movl $0x5, %edi
callq 0x1040
leaq -0x410(%rbp), %rdi
movq 0x2e05(%rip), %rax      # 0x3fe0
movq (%rax), %rdx
movl $0x400, %esi            # imm = 0x400
callq 0x1050
cmpq $0x0, %rax
jne 0x1203
leaq 0xe23(%rip), %rdi       # 0x2018
movb $0x0, %al
callq 0x1030
xorl %edi, %edi
callq 0x1070
xorl %edi, %edi
callq 0x1040
leaq -0x410(%rbp), %rsi
leaq 0xe14(%rip), %rdi       # 0x202c
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/main.cc
// Function: parse_opt(int, char*, argp_state*)
static error_t parse_opt(int key, char *arg, struct argp_state *state) {
  struct arguments *arguments = static_cast<struct arguments *>(state->input);
  switch (key) {
    case 'o':
      if (arg) {
        arguments->org = parseNum(arg);
      }
      break;
    case 'm':
      if (arg) {
        arguments->flags |= IsM8;
      }
      break;
    case 'x':
      if (arg) {
        arguments->flags |= IsX8;
      }
      break;
    case 'e':
      if (arg) {
        arguments->flags |= IsEmu;
      }
      break;
    case 'l':
      arguments->keyword = arg;
      break;
    case ARGP_KEY_ARG:
      if (state->arg_num >= 1) {
        argp_usage(state);
      }
      arguments->filename = arg;
      break;
    case ARGP_KEY_END:
      if (state->arg_num < 1 && !arguments->keyword) {
        argp_usage(state);
      }
      break;
    default:
      return ARGP_ERR_UNKNOWN;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x79e0
jmp 0x791f
movl -0x24(%rbp), %eax
subl $0x65, %eax
je 0x79b9
jmp 0x792d
movl -0x24(%rbp), %eax
subl $0x6c, %eax
je 0x79d2
jmp 0x793b
movl -0x24(%rbp), %eax
subl $0x6d, %eax
je 0x798a
jmp 0x7945
movl -0x24(%rbp), %eax
subl $0x6f, %eax
je 0x796c
jmp 0x794f
movl -0x24(%rbp), %eax
subl $0x78, %eax
je 0x79a3
jmp 0x7959
movl -0x24(%rbp), %eax
subl $0x1000001, %eax        # imm = 0x1000001
je 0x7a00
jmp 0x7a20
cmpq $0x0, -0x10(%rbp)
je 0x7985
movq -0x10(%rbp), %rdi
callq 0x7a40
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x7a29
cmpq $0x0, -0x10(%rbp)
je 0x799e
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0xc(%rax)
jmp 0x7a29
cmpq $0x0, -0x10(%rbp)
je 0x79b7
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0xc(%rax)
jmp 0x7a29
cmpq $0x0, -0x10(%rbp)
je 0x79d0
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x100, %ecx            # imm = 0x100
movl %ecx, 0xc(%rax)
jmp 0x7a29
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x7a29
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jb 0x79f3
movq -0x18(%rbp), %rdi
callq 0x64a0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x7a29
movq -0x18(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jae 0x7a1e
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x7a1e
movq -0x18(%rbp), %rdi
callq 0x64a0
jmp 0x7a29
movl $0x7, -0x4(%rbp)
jmp 0x7a30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/omf.cc
// Function: Segment::initDPS()
void Segment::initDPS() {
  kind = 0x12;
  length = 1024;
  resspc = 1024;
  bytecnt = 0;
  name = "Direct";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movw $0x12, 0x10(%rdi)
movl $0x400, 0x8(%rdi)       # imm = 0x400
movl $0x400, 0x4(%rdi)       # imm = 0x400
movl $0x0, (%rdi)
addq $0x28, %rdi
leaq 0x2f0ab(%rip), %rsi     # 0x3a200
callq 0x6410
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/omf.cc
// Function: OMF::load(char const*, unsigned int)
bool OMF::load(const char *filename, uint32_t org) {
  handle = TheHandle::createFromFile(filename);
  if (!handle->isOpen()) {
    return false;
  }

  if (!isOMF()) {
    Segment seg;
    seg.bytecnt = handle->length;
    seg.kind = 0;  // code
    seg.entry = 0;
    seg.mapped = org;
    seg.data = handle;
    seg.length = seg.bytecnt;
    seg.segnum = 1;
    segments.push_back(seg);
  } else {
    if (!loadSegments()) {
      return false;
    }
    if (!mapSegments()) {
      return false;
    }
    if (!relocSegments()) {
      return false;
    }
  }
  std::sort(segments.begin(), segments.end(), compareSegments);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x11a90
movq -0xc0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xd290
leaq -0x30(%rbp), %rdi
callq 0x8b80
movq -0xc0(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
callq 0x11e20
testb $0x1, %al
jne 0xb208
movb $0x0, -0x1(%rbp)
jmp 0xb355
movq -0xc0(%rbp), %rdi
callq 0xb370
testb $0x1, %al
jne 0xb2c5
leaq -0x98(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xd2e0
movq -0xc0(%rbp), %rdi
callq 0xd2c0
movq -0xc0(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x98(%rbp)
movw $0x0, -0x88(%rbp)
movl $0x0, -0x78(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xd310
movq -0xc0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movl -0x98(%rbp), %eax
movl %eax, -0x90(%rbp)
movw $0x1, -0x7c(%rbp)
addq $0x10, %rdi
callq 0xd340
jmp 0xb294
leaq -0x98(%rbp), %rdi
callq 0x94a0
jmp 0xb309
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x94a0
jmp 0xb363
movq -0xc0(%rbp), %rdi
callq 0xb490
testb $0x1, %al
jne 0xb2db
movb $0x0, -0x1(%rbp)
jmp 0xb355
movq -0xc0(%rbp), %rdi
callq 0xb930
testb $0x1, %al
jne 0xb2f1
movb $0x0, -0x1(%rbp)
jmp 0xb355
movq -0xc0(%rbp), %rdi
callq 0xbc30
testb $0x1, %al
jne 0xb307
movb $0x0, -0x1(%rbp)
jmp 0xb355
jmp 0xb309
movq -0xc0(%rbp), %rdi
addq $0x10, %rdi
callq 0x7cb0
movq -0xc0(%rbp), %rdi
movq %rax, -0xb0(%rbp)
addq $0x10, %rdi
callq 0x7ce0
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
leaq 0x1a54(%rip), %rdx      # 0xcda0
callq 0xd3b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x6540
nop
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/omf.cc
// Function: OMF::isOMF()
bool OMF::isOMF() {
  if (handle->length < 32) {
    return false;
  }
  uint64_t ofs = 0;
  for (ofs = 0; ofs < handle->length - 16;) {
    handle->seek(ofs);
    uint32_t bytecnt = handle->r32();
    handle->skip(11);
    uint8_t version = handle->r8();
    if (version == 1) {
      ofs += bytecnt * 512;
    } else if (version == 2) {
      ofs += bytecnt;
    } else {
      return false;
    }
  }
  return ofs == handle->length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xd2c0
cmpq $0x20, (%rax)
jge 0xb398
movb $0x0, -0x1(%rbp)
jmp 0xb484
movq $0x0, -0x18(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xd2c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rcx
subq $0x10, %rcx
cmpq %rcx, %rax
jae 0xb461
movq -0x28(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x12210
movq -0x28(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
callq 0x11e90
movq -0x28(%rbp), %rdi
movl %eax, -0x1c(%rbp)
callq 0xd2c0
movq %rax, %rdi
movl $0xb, %esi
callq 0x12230
movq -0x28(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
callq 0x11fc0
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %eax
cmpl $0x1, %eax
jne 0xb43e
movl -0x1c(%rbp), %eax
shll $0x9, %eax
movl %eax, %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb45c
movzbl -0x1d(%rbp), %eax
cmpl $0x2, %eax
jne 0xb454
movl -0x1c(%rbp), %eax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb45a
movb $0x0, -0x1(%rbp)
jmp 0xb484
jmp 0xb45c
jmp 0xb3a8
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xd2c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq (%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/map.cc
// Function: File::hex()
uint32_t File::hex() {
  uint32_t bank = 0;
  uint32_t res = 0;
  if (*p == '$') {
    p++;
  }
  while (p < end && (isxdigit(*p) || *p == '/')) {
    if (*p == '/') {
      bank = res;
      res = 0;
    } else if (isdigit(*p)) {
      res <<= 4;
      res |= *p - '0';
    } else if (*p >= 'a' && *p <= 'f') {
      res <<= 4;
      res |= *p - 'a' + 10;
    } else {
      res <<= 4;
      res |= *p - 'A' + 10;
    }
    p++;
  }
  return res | (bank << 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x24, %eax
jne 0x12e6e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x12e70
movq -0x18(%rbp), %rdx
movq 0x8(%rdx), %rcx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x19(%rbp)
jae 0x12eb9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %edi
callq 0x60e0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jne 0x12eb3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x12ec5
jmp 0x12f96
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x12ee7
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
jmp 0x12f81
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %edi
callq 0x62c0
cmpl $0x0, %eax
je 0x12f1b
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
shll $0x4, %ecx
movl %ecx, -0x10(%rbp)
movq 0x8(%rax), %rax
movzbl (%rax), %eax
subl $0x30, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x12f7f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x61, %eax
jl 0x12f5d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0x66, %eax
jg 0x12f5d
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
shll $0x4, %ecx
movl %ecx, -0x10(%rbp)
movq 0x8(%rax), %rax
movzbl (%rax), %eax
subl $0x61, %eax
addl $0xa, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x12f7d
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
shll $0x4, %ecx
movl %ecx, -0x10(%rbp)
movq 0x8(%rax), %rax
movzbl (%rax), %eax
subl $0x41, %eax
addl $0xa, %eax
orl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x12f7f
jmp 0x12f81
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x12e70
movl -0x10(%rbp), %eax
movl -0xc(%rbp), %ecx
shll $0x10, %ecx
orl %ecx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/map.cc
// Function: File::check(unsigned char)
bool File::check(uint8_t ch) {
  ws();
  if (p < end && ch == *p) {
    p++;
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x13cd0
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jae 0x13006
movq -0x20(%rbp), %rcx
movzbl -0x11(%rbp), %eax
movq 0x8(%rcx), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x13006
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1300a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/map.cc
// Function: File::oneOf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
char File::oneOf(const std::string &str) {
  ws();
  if (p < end && str.find(*p) != std::string::npos) {
    return *p++;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x13cd0
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
cmpq 0x10(%rcx), %rax
jae 0x13083
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movsbl (%rax), %esi
callq 0x63e0
cmpq $-0x1, %rax
je 0x13083
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movb (%rax), %al
movb %al, -0x1(%rbp)
jmp 0x13087
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/map.cc
// Function: File::until[abi:cxx11](unsigned char)
std::string File::until(uint8_t ch) {
  std::string r;
  while (*p != ch) {
    r += *p++;
  }
  p++;  // skip ending character
  return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x6420
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
movzbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x1310d
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
incq %rdx
movq %rdx, 0x8(%rcx)
movsbl (%rax), %esi
callq 0x61f0
jmp 0x130f4
jmp 0x130c1
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x61e0
jmp 0x1313a
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x12(%rbp)
testb $0x1, -0x12(%rbp)
jne 0x13130
movq -0x40(%rbp), %rdi
callq 0x61e0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6540
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/map.cc
// Function: Map::toAddress[abi:cxx11](unsigned int)
std::string Map::toAddress(uint32_t value) {
  static const char *digits = "0123456789abcdef";
  std::string ret="$00/0000";
  for (size_t i = 0, j = 5 << 2; i < 6; i++, j -= 4) {
    ret[i < 2 ? i + 1 : i + 2] = digits[(value >> j) & 0xf];
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x6560
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x26a98(%rip), %rsi     # 0x3a306
callq 0x7c00
jmp 0x13875
leaq -0x16(%rbp), %rdi
callq 0x6350
movq $0x0, -0x30(%rbp)
movq $0x14, -0x38(%rbp)
cmpq $0x6, -0x30(%rbp)
jae 0x1393b
movq 0x72ee8(%rip), %rax     # 0x86788
movl -0x14(%rbp), %edx
movq -0x38(%rbp), %rcx
shrl %cl, %edx
movl %edx, %ecx
andl $0xf, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x51(%rbp)
cmpq $0x2, -0x30(%rbp)
jae 0x138cb
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x138d7
movq -0x30(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x65f0
movq %rax, -0x68(%rbp)
jmp 0x138ea
movq -0x68(%rbp), %rax
movb -0x51(%rbp), %cl
movb %cl, (%rax)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
subq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x1388e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x6350
jmp 0x13958
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x61e0
jmp 0x13958
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1394e
movq -0x48(%rbp), %rdi
callq 0x61e0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6540
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/map.cc
// Function: Map::addEntry(unsigned int, unsigned int)
void Map::addEntry(uint32_t entry, uint32_t flags) {
  Entry e;
  e.org = entry;
  e.flags = flags;
  entryPoints.push_back(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
addq $0x30, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x13df0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/map.cc
// Function: File::File(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
File::File(const std::string &filename) {
  data = p = nullptr;
  std::ifstream f(filename, std::ios::in | std::ios::binary | std::ios::ate);
  if (!f.is_open()) {
    return;
  }
  auto length = f.tellg();
  data = new uint8_t[length];
  f.seekg(0, std::ios::beg);
  f.read(reinterpret_cast<char*>(data), length);
  f.close();
  p = data;
  end = data + length;
  curLine = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x250(%rbp)
addq $0x20, %rdi
movq %rdi, -0x258(%rbp)
callq 0x6420
movq -0x250(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x248(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x122b0
movl %eax, -0x23c(%rbp)
jmp 0x13ad6
movl -0x23c(%rbp), %edi
movl $0x2, %esi
callq 0x122b0
movl %eax, -0x25c(%rbp)
jmp 0x13aee
movl -0x25c(%rbp), %edx
movq -0x248(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x64e0
jmp 0x13b09
leaq -0x218(%rbp), %rdi
callq 0x64d0
movb %al, -0x25d(%rbp)
jmp 0x13b1d
movb -0x25d(%rbp), %al
testb $0x1, %al
jne 0x13b72
jmp 0x13b29
movl $0x1, -0x228(%rbp)
jmp 0x13ca1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x13cb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6100
jmp 0x13cb6
leaq -0x218(%rbp), %rdi
callq 0x6530
movq %rdx, -0x270(%rbp)
movq %rax, -0x268(%rbp)
jmp 0x13b8e
movq -0x270(%rbp), %rax
movq -0x268(%rbp), %rcx
movq %rcx, -0x238(%rbp)
movq %rax, -0x230(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x122d0
movq %rax, -0x278(%rbp)
jmp 0x13bbf
movq -0x278(%rbp), %rdi
callq 0x6030
movq %rax, -0x280(%rbp)
jmp 0x13bd4
movq -0x250(%rbp), %rax
movq -0x280(%rbp), %rcx
movq %rcx, (%rax)
xorl %edx, %edx
movl %edx, %esi
leaq -0x218(%rbp), %rdi
callq 0x6400
jmp 0x13bf7
movq -0x250(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x290(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x122d0
movq %rax, -0x288(%rbp)
jmp 0x13c1d
movq -0x288(%rbp), %rdx
movq -0x290(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x63b0
jmp 0x13c39
leaq -0x218(%rbp), %rdi
callq 0x60c0
jmp 0x13c47
movq -0x250(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rax
movq %rax, -0x2a0(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x122d0
movq %rax, -0x298(%rbp)
jmp 0x13c74
movq -0x250(%rbp), %rax
movq -0x298(%rbp), %rdx
movq -0x2a0(%rbp), %rcx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl $0x1, 0x18(%rax)
movl $0x0, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x6100
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x258(%rbp), %rdi
callq 0x61e0
movq -0x220(%rbp), %rdi
callq 0x6540
nop
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/map.cc
// Function: File::ws()
void File::ws() {
  while (p < end && isspace(*p)) {
    if (*p == '\n') {
      curLine++;
    }
    p++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rcx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x11(%rbp)
jae 0x13d10
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %edi
callq 0x6080
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x13d19
jmp 0x13d48
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x13d36
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x13ce4
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/disasm.cc
// Function: Disassembler::checkDW[abi:cxx11](unsigned short, unsigned short)
std::string Disassembler::checkDW(uint16_t cur, uint16_t prev) {
  uint32_t addr = (cur << 16) + prev;
  std::string ret = symbols[addr];
  if (ret.empty()) {
    addr = (prev << 16) + cur;
    ret = symbols[addr];
  }
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movw %cx, %ax
movw %dx, %cx
movq %rdi, %rdx
movq %rdx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movzwl -0x12(%rbp), %eax
shll $0x10, %eax
movzwl -0x14(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x13e60
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6170
movq -0x38(%rbp), %rdi
callq 0x6510
testb $0x1, %al
jne 0x1d5b9
jmp 0x1d604
movq -0x40(%rbp), %rdi
movzwl -0x14(%rbp), %eax
shll $0x10, %eax
movzwl -0x12(%rbp), %ecx
orl %ecx, %eax
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x13e60
movq %rax, -0x50(%rbp)
jmp 0x1d5dc
movq -0x50(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x6060
jmp 0x1d5eb
jmp 0x1d604
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x61e0
jmp 0x1d621
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1d617
movq -0x38(%rbp), %rdi
callq 0x61e0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6540
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/api.cc
// Function: Fingerprints::add(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned char)
void Fingerprints::add(const std::vector<uint8_t> &keys, std::string name,
                       uint8_t numDB) {
  auto node = root;
  for (auto key : keys) {
    if (node->map.find(key) == node->map.end()) {
      node->map.insert(std::pair<uint8_t, std::shared_ptr<Fingerprint>>
                       (key, std::make_shared<Fingerprint>()));
    }
    node = node->map[key];
  }
  node->name = name;
  node->numDB = numDB;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xb0(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x24fb0
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x12370
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x123a0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x24fe0
testb $0x1, %al
jne 0x21f28
jmp 0x2209b
leaq -0x40(%rbp), %rdi
callq 0x25020
movb (%rax), %al
movb %al, -0x49(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25070
movq %rax, %rdi
leaq -0x49(%rbp), %rsi
callq 0x25090
movq %rax, -0xb8(%rbp)
jmp 0x21f54
movq -0xb8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25070
movq %rax, %rdi
callq 0x250c0
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x25040
testb $0x1, %al
jne 0x21f8a
jmp 0x2205f
leaq -0x30(%rbp), %rdi
callq 0x25070
movq %rax, -0xc0(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x24f10
jmp 0x21fa8
leaq -0x88(%rbp), %rdi
leaq -0x49(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x25130
jmp 0x21fc1
movq -0xc0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x250f0
movb %dl, -0xc9(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0x21fe3
movb -0xc9(%rbp), %al
movq -0xc8(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movb %al, -0xa0(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x25170
leaq -0x98(%rbp), %rdi
callq 0x9ed0
jmp 0x2205f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x220e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2204e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x25170
leaq -0x98(%rbp), %rdi
callq 0x9ed0
jmp 0x220e6
leaq -0x30(%rbp), %rdi
callq 0x25070
movq %rax, %rdi
leaq -0x49(%rbp), %rsi
callq 0x25190
movq %rax, -0xd8(%rbp)
jmp 0x2207d
movq -0xd8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x25270
leaq -0x40(%rbp), %rdi
callq 0x252a0
jmp 0x21f12
leaq -0x30(%rbp), %rdi
callq 0x25070
movq -0xb0(%rbp), %rsi
movq %rax, %rdi
addq $0x38, %rdi
callq 0x6060
jmp 0x220b9
movb -0x19(%rbp), %al
movb %al, -0xd9(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x25070
movb -0xd9(%rbp), %cl
movb %cl, 0x30(%rax)
leaq -0x30(%rbp), %rdi
callq 0x9ed0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x9ed0
movq -0x60(%rbp), %rdi
callq 0x6540
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/api.cc
// Function: API::setIntrinsic(std::shared_ptr<TheHandle>, std::shared_ptr<symbol::Symbol>)
void API::setIntrinsic(Handle h, std::shared_ptr<symbol::Symbol> s) {
  auto i = std::static_pointer_cast<symbol::Intrinsic>(s);
  auto type = h->r8();
  switch (type) {
    case symbol::Intrinsic::U8:
      i->type = symbol::Intrinsic::U8;
      break;
    case symbol::Intrinsic::U16:
      i->type = symbol::Intrinsic::U16;
      break;
    case symbol::Intrinsic::U32:
      i->type = symbol::Intrinsic::U32;
      break;
    case symbol::Intrinsic::S8:
      i->type = symbol::Intrinsic::S8;
      break;
    case symbol::Intrinsic::S16:
      i->type = symbol::Intrinsic::S16;
      break;
    case symbol::Intrinsic::S32:
      i->type = symbol::Intrinsic::S32;
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x50(%rbp)
movq %rsi, %rax
movq -0x50(%rbp), %rsi
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x25850
movq -0x48(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
callq 0x11fc0
movb %al, -0x3d(%rbp)
jmp 0x22b72
movb -0x3d(%rbp), %al
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
movq %rax, -0x58(%rbp)
subq $0x5, %rax
ja 0x22c1f
movq -0x58(%rbp), %rax
leaq 0x17f73(%rip), %rcx     # 0x3ab08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x25440
jmp 0x22c2e
leaq -0x28(%rbp), %rdi
callq 0x258a0
movl $0x0, 0x28(%rax)
jmp 0x22c1f
leaq -0x28(%rbp), %rdi
callq 0x258a0
movl $0x1, 0x28(%rax)
jmp 0x22c1f
leaq -0x28(%rbp), %rdi
callq 0x258a0
movl $0x2, 0x28(%rax)
jmp 0x22c1f
leaq -0x28(%rbp), %rdi
callq 0x258a0
movl $0x3, 0x28(%rax)
jmp 0x22c1f
leaq -0x28(%rbp), %rdi
callq 0x258a0
movl $0x4, 0x28(%rax)
jmp 0x22c1f
leaq -0x28(%rbp), %rdi
callq 0x258a0
movl $0x5, 0x28(%rax)
leaq -0x28(%rbp), %rdi
callq 0x25440
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6540
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/api.cc
// Function: API::setEnum(std::shared_ptr<TheHandle>, std::shared_ptr<symbol::Symbol>)
void API::setEnum(Handle h, std::shared_ptr<symbol::Symbol> s) {
  auto e = std::static_pointer_cast<symbol::Enum>(s);
  e->type = lookup(h->r32());
  auto num = h->r32();
  for (uint32_t i = 0; i < num; i++) {
    auto value = h->r32();
    e->entries[h->rs()] = value;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0x90(%rbp)
movq %rsi, %rax
movq -0x90(%rbp), %rsi
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x258c0
movq -0x80(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
callq 0x11e90
movl %eax, -0x74(%rbp)
jmp 0x22c96
movl -0x74(%rbp), %edx
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x23890
jmp 0x22cab
leaq -0x28(%rbp), %rdi
callq 0x25910
movq %rax, %rdi
addq $0x28, %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x25930
movq -0xa0(%rbp), %rdi
callq 0x8770
movq -0x80(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
callq 0x11e90
movl %eax, -0x94(%rbp)
jmp 0x22cf0
movl -0x94(%rbp), %eax
movl %eax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x48(%rbp), %eax
jae 0x22dc6
movq -0x80(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
callq 0x11e90
movl %eax, -0xa4(%rbp)
jmp 0x22d25
movl -0xa4(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0xb4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x25910
movq -0x80(%rbp), %rdi
addq $0x38, %rax
movq %rax, -0xb0(%rbp)
callq 0xd2c0
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x11fe0
jmp 0x22d62
movq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x25960
movq %rax, -0xc0(%rbp)
jmp 0x22d7b
movq -0xc0(%rbp), %rax
movl -0xb4(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x70(%rbp), %rdi
callq 0x61e0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x22d00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x22dd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x61e0
jmp 0x22dd8
leaq -0x28(%rbp), %rdi
callq 0x25500
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x25500
movq -0x40(%rbp), %rdi
callq 0x6540
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/api.cc
// Function: API::setRef(std::shared_ptr<TheHandle>, std::shared_ptr<symbol::Symbol>)
void API::setRef(Handle h, std::shared_ptr<symbol::Symbol> s) {
  auto r = std::static_pointer_cast<symbol::Ref>(s);
  auto id = h->r32();
  if (id == 0) {
    r->symbol = nullptr;
  } else {
    r->symbol = lookup(id);
    r->pointer = h->r32();
    r->array = static_cast<int32_t>(h->r32());
    r->reg = h->rs();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0xa0(%rbp)
movq %rsi, %rax
movq -0xa0(%rbp), %rsi
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x25a40
movq -0x90(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
callq 0x11e90
movl %eax, -0x84(%rbp)
jmp 0x22e4f
movl -0x84(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x22eac
leaq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x25380
leaq -0x28(%rbp), %rdi
callq 0x25a90
movq %rax, %rdi
addq $0x28, %rdi
leaq -0x50(%rbp), %rsi
callq 0x25930
leaq -0x50(%rbp), %rdi
callq 0x8770
jmp 0x22f85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x255c0
jmp 0x22f97
movq -0x98(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq -0x60(%rbp), %rdi
callq 0x23890
jmp 0x22ec1
leaq -0x28(%rbp), %rdi
callq 0x25a90
movq %rax, %rdi
addq $0x28, %rdi
leaq -0x60(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x25930
movq -0xb0(%rbp), %rdi
callq 0x8770
movq -0x90(%rbp), %rdi
callq 0xd2c0
movq %rax, %rdi
callq 0x11e90
movl %eax, -0xa4(%rbp)
jmp 0x22f09
leaq -0x28(%rbp), %rdi
callq 0x25a90
movl -0xa4(%rbp), %ecx
movq -0x90(%rbp), %rdi
movl %ecx, 0x38(%rax)
callq 0xd2c0
movq %rax, %rdi
callq 0x11e90
movl %eax, -0xb4(%rbp)
jmp 0x22f37
leaq -0x28(%rbp), %rdi
callq 0x25a90
movl -0xb4(%rbp), %ecx
movq -0x90(%rbp), %rdi
movl %ecx, 0x3c(%rax)
callq 0xd2c0
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x11fe0
jmp 0x22f63
leaq -0x28(%rbp), %rdi
callq 0x25a90
movq %rax, %rdi
addq $0x40, %rdi
leaq -0x80(%rbp), %rsi
callq 0x6390
leaq -0x80(%rbp), %rdi
callq 0x61e0
leaq -0x28(%rbp), %rdi
callq 0x255c0
addq $0xc0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6540
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/api.cc
// Function: API::search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
void API::search(std::string keyword, uint32_t org) {
  for (auto &s : symbols) {
    auto it = std::search(s.first.begin(), s.first.end(),
                          keyword.begin(), keyword.end(),
                          [](char a, char b) {
                            return std::toupper(a) == std::toupper(b);
                          });
    if (it != s.first.end()) {
      dumpSymbol(s.second, org);
      printf("\n");
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7e00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7e30
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7e60
testb $0x1, %al
jne 0x2394c
jmp 0x23a44
leaq -0x28(%rbp), %rdi
callq 0x7e90
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x62d0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
callq 0x65a0
movq -0xa0(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x6290
movq -0xa0(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x61c0
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x23a60
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x65a0
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x25ca0
testb $0x1, %al
jne 0x239cc
jmp 0x23a34
movq -0x38(%rbp), %rsi
addq $0x20, %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x8490
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movl -0x14(%rbp), %edx
xorl %ecx, %ecx
callq 0x23ac0
jmp 0x239fe
leaq -0x80(%rbp), %rdi
callq 0x8770
leaq 0x16827(%rip), %rdi     # 0x3a235
movb $0x0, %al
callq 0x6070
jmp 0x23a34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x8770
jmp 0x23a4d
jmp 0x23a36
leaq -0x28(%rbp), %rdi
callq 0x8170
jmp 0x23936
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x6540
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/api.cc
// Function: API::dumpRef(std::shared_ptr<symbol::Ref>)
void API::dumpRef(std::shared_ptr<symbol::Ref> ref) {
  for (int i = 0; i < ref->pointer; i++) {
    printf("^");
  }
  printf("%s", ref->symbol->name.c_str());
  if (ref->array > 0) {
    printf("[%d]", ref->array);
  } else if (ref->array == 0) {
    printf("[]");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x25a90
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl 0x38(%rcx), %eax
jae 0x2486e
leaq 0x16346(%rip), %rdi     # 0x3aba2
movb $0x0, %al
callq 0x6070
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2483b
movq -0x20(%rbp), %rdi
callq 0x25a90
movq %rax, %rdi
addq $0x28, %rdi
callq 0x7ef0
movq %rax, %rdi
callq 0x6160
movq %rax, %rsi
leaq 0x1630f(%rip), %rdi     # 0x3aba4
movb $0x0, %al
callq 0x6070
movq -0x20(%rbp), %rdi
callq 0x25a90
cmpl $0x0, 0x3c(%rax)
jle 0x248c7
movq -0x20(%rbp), %rdi
callq 0x25a90
movl 0x3c(%rax), %esi
leaq 0x162e9(%rip), %rdi     # 0x3aba7
movb $0x0, %al
callq 0x6070
jmp 0x248e6
movq -0x20(%rbp), %rdi
callq 0x25a90
cmpl $0x0, 0x3c(%rax)
jne 0x248e4
leaq 0x162cf(%rip), %rdi     # 0x3abac
movb $0x0, %al
callq 0x6070
jmp 0x248e6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/scanner.cc
// Function: Scanner::getAddress(unsigned int)
Handle Scanner::getAddress(uint32_t address) {
  for (auto &s : segments) {
    if (address >= s.mapped && address < s.mapped + s.length) {
      s.data->seek(address - s.mapped);
      return s.data;
    }
  }
  return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7cb0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7ce0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7d10
testb $0x1, %al
jne 0x31087
jmp 0x310fb
leaq -0x28(%rbp), %rdi
callq 0x7d50
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jb 0x310eb
movl -0x14(%rbp), %eax
movq -0x38(%rbp), %rcx
movl 0x60(%rcx), %ecx
movq -0x38(%rbp), %rdx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x310eb
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
callq 0xd2c0
movq %rax, %rdi
movl -0x14(%rbp), %eax
movq -0x38(%rbp), %rcx
subl 0x60(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x12210
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x50, %rsi
callq 0xb060
jmp 0x31108
jmp 0x310ed
leaq -0x28(%rbp), %rdi
callq 0x7d70
jmp 0x31074
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x33a30
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/scanner.cc
// Function: Scanner::valid(unsigned int)
bool Scanner::valid(uint32_t address) {
  for (auto &s : segments) {
    if (address >= s.mapped && address < s.mapped + s.length) {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7cb0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7ce0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7d10
testb $0x1, %al
jne 0x313d8
jmp 0x31419
leaq -0x28(%rbp), %rdi
callq 0x7d50
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0x60(%rcx), %eax
jb 0x3140c
movl -0x14(%rbp), %eax
movq -0x38(%rbp), %rcx
movl 0x60(%rcx), %ecx
movq -0x38(%rbp), %rdx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jae 0x3140c
movb $0x1, -0x1(%rbp)
jmp 0x3141d
jmp 0x3140e
leaq -0x28(%rbp), %rdi
callq 0x7d70
jmp 0x313c5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mrkite[P]regs/src/scanner.cc
// Function: Scanner::getBlock(unsigned int)
std::shared_ptr<Block> Scanner::getBlock(uint32_t address) {
  auto res = std::find_if(blocks.begin(), blocks.end(),
                          [address](const std::shared_ptr<Block> n) {
                            return n->address == address;
                          });
  if (res != blocks.end()) {
    return *res;
  }
  auto block = std::make_shared<Block>(address);
  block->branchLen = 0;
  block->length = 0;
  blocks.push_back(block);
  return block;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0xb8, %rdi
callq 0x33850
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0xb8, %rdi
callq 0x33880
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x32bb0
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0xb8, %rdi
callq 0x33880
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x338b0
testb $0x1, %al
jne 0x31cdb
jmp 0x31cf2
leaq -0x20(%rbp), %rdi
callq 0x338f0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x33910
jmp 0x31d67
movq -0x70(%rbp), %rdi
movb $0x0, -0x41(%rbp)
leaq -0x14(%rbp), %rsi
callq 0x33a50
movq -0x70(%rbp), %rdi
callq 0x33670
movq -0x70(%rbp), %rdi
movl $0x0, 0x8(%rax)
callq 0x33670
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl $0x0, 0x4(%rax)
addq $0xb8, %rdi
callq 0x33690
jmp 0x31d39
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x31d65
jmp 0x31d5c
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x1ea40
jmp 0x31d71
movq -0x70(%rbp), %rdi
callq 0x1ea40
jmp 0x31d67
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6540
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/collect32.c
// Function: main
int
main(void)
{
    int i;

    shmem_init();
    npes = shmem_n_pes();
    me = shmem_my_pe();

    for (i = 0; i < DST_SIZE; i++) {
        dst[i] = -1;
    }

    for (i = 0; i < SHMEM_BCAST_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }

    shmem_barrier_all();

    if (me < 4) {
        shmem_collect32(dst, src, me + 1, 0, 0, 4, pSync);
        show_dst("AFTER");
    }

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
callq 0x1090
callq 0x1040
movl %eax, 0x2ec4(%rip)      # 0x4080
callq 0x1060
movl %eax, 0x2ebd(%rip)      # 0x4084
movl $0x0, 0x10(%rsp)
cmpl $0x14, 0x10(%rsp)
jge 0x11f6
movslq 0x10(%rsp), %rcx
leaq 0x2eae(%rip), %rax      # 0x4090
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11cf
movl $0x0, 0x10(%rsp)
cmpl $0x2, 0x10(%rsp)
jge 0x1226
movslq 0x10(%rsp), %rcx
leaq 0x2ecf(%rip), %rax      # 0x40e0
movq $-0x1, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11fe
callq 0x1080
cmpl $0x4, 0x2e52(%rip)      # 0x4084
jge 0x1276
movl 0x2e4a(%rip), %eax      # 0x4084
addl $0x1, %eax
movslq %eax, %rdx
leaq 0x2e49(%rip), %rdi      # 0x4090
leaq 0x2e12(%rip), %rsi      # 0x4060
xorl %r8d, %r8d
movl $0x4, %r9d
leaq 0x2e82(%rip), %rax      # 0x40e0
movl %r8d, %ecx
movq %rax, (%rsp)
callq 0x1070
leaq 0xd93(%rip), %rdi       # 0x2004
callq 0x1290
callq 0x1050
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)