LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/rouming[P]io/poller.c
// Function: _del_prewait
static void __del_prewait(struct prewait *prew)
{
	assert(prew->item->prews_num);
	prew->item->prews_num -= 1;
	prew->poller = NULL;
	prew->item = NULL;
	list_del(&prew->list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x18(%rax)
je 0x6dac
jmp 0x6dcb
leaq 0xab0(%rip), %rdi       # 0x7863
leaq 0xabf(%rip), %rsi       # 0x7879
movl $0x25, %edx
leaq 0xabc(%rip), %rcx       # 0x7882
callq 0x10d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x18(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x6e10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cyb70289[P]tt/tests/sort.c
// Function: verify
static bool verify(int *data)
{
	for (int i = 0; i < LEN - 1; i++)
		if (data[i] > data[i + 1])
			return false;
	return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
cmpl $0xffff, -0x14(%rsp)    # imm = 0xFFFF
jge 0x183e
movq -0x10(%rsp), %rax
movslq -0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
movl -0x14(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x182f
movb $0x0, -0x1(%rsp)
jmp 0x1843
jmp 0x1831
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x17fd
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/containers.c
// Function: new_vec
Vector* new_vec() {
  Vector* v = calloc(1, sizeof(Vector));
  v->ptr = calloc(16, sizeof(void*));
  v->capacity = 16;
  v->length = 0;
  return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x18, %esi
callq 0x20d0
movq %rax, -0x8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x20d0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x10, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/containers.c
// Function: vec_push
void vec_push(Vector* v, void* elem) {
  if (v->capacity == v->length) {
    v->capacity *= 2;
    v->ptr = realloc(v->ptr, sizeof(void*) * v->capacity);
  }
  v->ptr[v->length++] = elem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x2333
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x2120
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x10(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x10(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: preprocess
Token* preprocess(char* dir, Token* tokens) {
  gbl_env = calloc(1, sizeof(MacroEnv));
  gbl_env->name = "__hoc__";
  input = tokens;
  src_dir = dir;

  while (input) {
    traverse();
  }

  return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x20d0
movq %rax, 0x1522a(%rip)     # 0x17610
movq 0x15223(%rip), %rax     # 0x17610
leaq 0xfc10(%rip), %rcx      # 0x12004
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x15215(%rip)     # 0x17618
movq -0x8(%rbp), %rax
movq %rax, 0x15212(%rip)     # 0x17620
cmpq $0x0, 0x15202(%rip)     # 0x17618
je 0x241f
callq 0x2430
jmp 0x240e
movq 0x15202(%rip), %rax     # 0x17628
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: read_define
static void read_define(char* name) {
  if (eq_reserved(input, "(")) {
    consume();
    read_funclike_define(name);
  } else {
    read_objlike_define(name);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x14f85(%rip), %rdi     # 0x17618
leaq 0x11334(%rip), %rsi     # 0x139ce
callq 0xfe80
testb $0x1, %al
jne 0x26a5
jmp 0x26b5
callq 0x2650
movq -0x8(%rbp), %rdi
callq 0x2920
jmp 0x26be
movq -0x8(%rbp), %rdi
callq 0x2960
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: expect
static Token* expect(char* expected, enum TokenTag tag) {
  if (input->tag != tag) {
    pp_error(expected, input);
    return NULL;
  } else {
    Token* ret = input;
    consume();
    return ret;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x14f32(%rip), %rax     # 0x17618
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x2708
movq -0x10(%rbp), %rdi
movq 0x14f1f(%rip), %rsi     # 0x17618
callq 0x2b30
movq $0x0, -0x8(%rbp)
jmp 0x2720
movq 0x14f09(%rip), %rax     # 0x17618
movq %rax, -0x20(%rbp)
callq 0x2650
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: is_macro
static bool is_macro(Token* token) {
  if (token->tag == TIDENT) {
    for (MacroEnv* env = gbl_env; env != NULL; env = env->next) {
      if (streq(token->ident, env->name)) {
        return true;
      }
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x27f9
movq 0x14e53(%rip), %rax     # 0x17610
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x27f7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0x27e8
movb $0x1, -0x1(%rbp)
jmp 0x27fd
jmp 0x27ea
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x27c1
jmp 0x27f9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: apply
static void apply(char* name) {
  if (input && eq_reserved(input, "(")) {
    consume();
    apply_funclike(name);
  } else {
    apply_objlike(name);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x14d84(%rip)     # 0x17618
je 0x28bf
movq 0x14d7b(%rip), %rdi     # 0x17618
leaq 0x1112a(%rip), %rsi     # 0x139ce
callq 0xfe80
testb $0x1, %al
jne 0x28af
jmp 0x28bf
callq 0x2650
movq -0x8(%rbp), %rdi
callq 0x2bd0
jmp 0x28c8
movq -0x8(%rbp), %rdi
callq 0x2cb0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: copy_token
static Token* copy_token(Token* src) {
  Token* new = calloc(1, sizeof(Token));
  memcpy(new, src, sizeof(Token));
  new->next = NULL;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x20d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x38, %edx
callq 0x20f0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: read_funclike_params
static Vector* read_funclike_params(void) {
  Vector* params = new_vec();
  while (!eq_reserved(input, ")")) {
    char* name = expect("macro parameter", TIDENT)->ident;
    vec_push(params, name);
    if (eq_reserved(input, ",")) {
      consume();
    } else if (!eq_reserved(input, ")")) {
      pp_error(") or ,", input);
    }
  }
  consume();
  return params;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, %al
callq 0x2280
movq %rax, -0x8(%rbp)
movq 0x14c5e(%rip), %rdi     # 0x17618
leaq 0x10941(%rip), %rsi     # 0x13302
callq 0xfe80
xorb $-0x1, %al
testb $0x1, %al
jne 0x29ce
jmp 0x2a45
leaq 0xf664(%rip), %rdi      # 0x12039
movl $0x2, %esi
callq 0x26d0
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22e0
movq 0x14c1d(%rip), %rdi     # 0x17618
leaq 0xf64c(%rip), %rsi      # 0x1204e
callq 0xfe80
testb $0x1, %al
jne 0x2a0d
jmp 0x2a14
callq 0x2650
jmp 0x2a40
movq 0x14bfd(%rip), %rdi     # 0x17618
leaq 0x108e0(%rip), %rsi     # 0x13302
callq 0xfe80
testb $0x1, %al
jne 0x2a3e
movq 0x14be6(%rip), %rsi     # 0x17618
leaq 0xf610(%rip), %rdi      # 0x12049
callq 0x2b30
jmp 0x2a40
jmp 0x29b3
callq 0x2650
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: read_until_bol
static Token* read_until_bol(void) {
  if (input->bol) {
    return NULL;
  } else {
    Token* new = copy_token(input);
    consume();
    new->next = read_until_bol();
    return new;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x14ba9(%rip), %rax     # 0x17618
testb $0x1, 0x30(%rax)
je 0x2a7f
movq $0x0, -0x8(%rbp)
jmp 0x2aab
movq 0x14b92(%rip), %rdi     # 0x17618
callq 0x28d0
movq %rax, -0x10(%rbp)
callq 0x2650
callq 0x2a60
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: add_funclike
static void add_funclike(char* name, Token* tokens, Vector* params, MacroEnv** prev) {
  MacroEnv* new = calloc(1, sizeof(MacroEnv));
  new->name = name;
  new->tokens = tokens;
  new->params = params;
  new->next = *prev;
  *prev = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x20d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: add_objlike
static void add_objlike(char* name, Token* tokens, MacroEnv** prev) {
  MacroEnv* new = calloc(1, sizeof(MacroEnv));
  new->name = name;
  new->tokens = tokens;
  new->next = *prev;
  *prev = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x20d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: apply_funclike
static void apply_funclike(char* name) {
  Vector* args = read_funclike_args();
  MacroEnv* lcl_env = get_local_env(name, args);
  Token* func_tokens = get_macro_tokens(name);

  MacroEnv* env_backup = gbl_env;
  Token* input_backup = input;
  Token* output_backup = output;

  gbl_env = lcl_env;
  input = func_tokens;
  output = NULL;

  while (input) {
    traverse();
  }

  Token* expanded = output;

  gbl_env = env_backup;
  input = input_backup;
  output = output_backup;

  append(&expanded, input);
  input = expanded;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2cf0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2da0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2eb0
movq %rax, -0x20(%rbp)
movq 0x14a06(%rip), %rax     # 0x17610
movq %rax, -0x28(%rbp)
movq 0x14a03(%rip), %rax     # 0x17618
movq %rax, -0x30(%rbp)
movq 0x14a08(%rip), %rax     # 0x17628
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, 0x149e1(%rip)     # 0x17610
movq -0x20(%rbp), %rax
movq %rax, 0x149de(%rip)     # 0x17618
movq $0x0, 0x149e3(%rip) # 0x17628
cmpq $0x0, 0x149cb(%rip)     # 0x17618
je 0x2c56
callq 0x2430
jmp 0x2c45
movq 0x149cb(%rip), %rax     # 0x17628
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, 0x149a4(%rip)     # 0x17610
movq -0x30(%rbp), %rax
movq %rax, 0x149a1(%rip)     # 0x17618
movq -0x38(%rbp), %rax
movq %rax, 0x149a6(%rip)     # 0x17628
movq 0x1498f(%rip), %rsi     # 0x17618
leaq -0x40(%rbp), %rdi
callq 0x2760
movq -0x40(%rbp), %rax
movq %rax, 0x1497b(%rip)     # 0x17618
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: read_funclike_args
static Vector* read_funclike_args(void) {
  Vector* args = new_vec();
  while (!eq_reserved(input, ")")) {
    Token* arg = read_one_arg();
    vec_push(args, arg);
    if (eq_reserved(input, ",")) {
      consume();
    } else if (!eq_reserved(input, ")")) {
      pp_error(") or ,", input);
    }
  }
  consume();
  return args;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, %al
callq 0x2280
movq %rax, -0x8(%rbp)
movq 0x1490e(%rip), %rdi     # 0x17618
leaq 0x105f1(%rip), %rsi     # 0x13302
callq 0xfe80
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d1e
jmp 0x2d82
callq 0x2f20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22e0
movq 0x148dd(%rip), %rdi     # 0x17618
leaq 0xf30c(%rip), %rsi      # 0x1204e
callq 0xfe80
testb $0x1, %al
jne 0x2d4d
jmp 0x2d54
callq 0x2650
jmp 0x2d80
movq 0x148bd(%rip), %rdi     # 0x17618
leaq 0x105a0(%rip), %rsi     # 0x13302
callq 0xfe80
testb $0x1, %al
jne 0x2d7e
movq 0x148a6(%rip), %rsi     # 0x17618
leaq 0xf2d0(%rip), %rdi      # 0x12049
callq 0x2b30
jmp 0x2d80
jmp 0x2d03
callq 0x2650
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: get_local_env
static MacroEnv* get_local_env(char* name, Vector* args) {
  Vector* params = NULL;
  for (MacroEnv* env = gbl_env; env != NULL; env = env->next) {
    if (streq(name, env->name)) {
      params = env->params;
    }
  }

  if (params == NULL) {
    error("undefined macro %s\n", name);
  }

  MacroEnv* lcl_env = NULL;
  MacroEnv** p = &lcl_env;
  for (int i = 0; i < params->length; i++) {
    MacroEnv* new = calloc(1, sizeof(MacroEnv));
    new->name = params->ptr[i];
    new->tokens = args->ptr[i];
    new->next = *p;
    *p = new;
  }

  return lcl_env;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq 0x14851(%rip), %rax     # 0x17610
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2dfb
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0x2dec
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2dee
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2dc3
cmpq $0x0, -0x18(%rbp)
jne 0x2e14
movq -0x8(%rbp), %rsi
leaq 0xf255(%rip), %rdi      # 0x12062
movb $0x0, %al
callq 0xfb50
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2e9e
movl $0x1, %edi
movl $0x20, %esi
callq 0x20d0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2e2b
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: get_macro_tokens
static Token* get_macro_tokens(char* name) {
  for (MacroEnv* env = gbl_env; env != NULL; env = env->next) {
    if (streq(name, env->name)) {
      return copy_tokens(env->tokens);
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1474d(%rip), %rax     # 0x17610
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2f06
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0x2ef7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2fa0
movq %rax, -0x8(%rbp)
jmp 0x2f0e
jmp 0x2ef9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2ec7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: read_one_arg
static Token* read_one_arg(void) {
  Token* arg = NULL;
  while (!eq_reserved(input, ")") && !eq_reserved(input, ",")) {
    append(&arg, copy_token(input));
    consume();
  }
  return arg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movq 0x146e1(%rip), %rdi     # 0x17618
leaq 0x103c4(%rip), %rsi     # 0x13302
callq 0xfe80
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x2f67
movq 0x146c2(%rip), %rdi     # 0x17618
leaq 0xf0f1(%rip), %rsi      # 0x1204e
callq 0xfe80
xorb $-0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x2f70
jmp 0x2f8f
movq 0x146a1(%rip), %rdi     # 0x17618
callq 0x28d0
movq %rax, %rsi
leaq -0x8(%rbp), %rdi
callq 0x2760
callq 0x2650
jmp 0x2f30
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/cpp.c
// Function: copy_tokens
static Token* copy_tokens(Token* src) {
  if (src == NULL) {
    return NULL;
  } else {
    Token* new = copy_token(src);
    new->next = copy_tokens(src->next);
    return new;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2fbd
movq $0x0, -0x8(%rbp)
jmp 0x2fe8
movq -0x10(%rbp), %rdi
callq 0x28d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2fa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_const
static void emit_const(Type* type, Node* node) {
  if (!node) {
    return;
  }

  switch (node->tag) {
  case NINT: {
    if (size_of(type) == 1) {
      emit(".byte %d", node->integer);
    } else if (size_of(type) == 4) {
      emit(".int %d", node->integer);
    } else if (size_of(type) == 8) {
      emit(".quad %d", node->integer);
    } else {
      bad_token(node->token, "emit error: emit_const(invalid size)");
    }
    break;
  }
  case NGVAR: {
    if (size_of(type) == 1) {
      emit(".byte %s", node->name);
    } else if (size_of(type) == 4) {
      emit(".int %s", node->name);
    } else if (size_of(type) == 8) {
      emit(".quad %s", node->name);
    } else {
      bad_token(node->token, "emit error: emit_const(invalid size)");
    }
    break;
  }
  default:
    bad_token(node->token, "emit error: value is not constant");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x31fc
jmp 0x334e
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x321c
jmp 0x320b
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x32ab
jmp 0x333a
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x1, %rax
jne 0x3242
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0xef09(%rip), %rdi      # 0x12142
movb $0x0, %al
callq 0x3360
jmp 0x32a6
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x4, %rax
jne 0x3268
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0xeeec(%rip), %rdi      # 0x1214b
movb $0x0, %al
callq 0x3360
jmp 0x32a4
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x8, %rax
jne 0x328e
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
leaq 0xeece(%rip), %rdi      # 0x12153
movb $0x0, %al
callq 0x3360
jmp 0x32a2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xeebf(%rip), %rsi      # 0x1215c
callq 0xed90
jmp 0x32a4
jmp 0x32a6
jmp 0x334e
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x1, %rax
jne 0x32d2
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0xeeb8(%rip), %rdi      # 0x12181
movb $0x0, %al
callq 0x3360
jmp 0x3338
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x4, %rax
jne 0x32f9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0xee9a(%rip), %rdi      # 0x1218a
movb $0x0, %al
callq 0x3360
jmp 0x3336
movq -0x8(%rbp), %rdi
callq 0x9d60
cmpq $0x8, %rax
jne 0x3320
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0xee7b(%rip), %rdi      # 0x12192
movb $0x0, %al
callq 0x3360
jmp 0x3334
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xee2d(%rip), %rsi      # 0x1215c
callq 0xed90
jmp 0x3336
jmp 0x3338
jmp 0x334e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xee52(%rip), %rsi      # 0x1219b
callq 0xed90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit
static void emit(char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  printf("\t");
  vprintf(fmt, ap);
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3395
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
leaq 0xedd9(%rip), %rdi      # 0x121bd
xorl %eax, %eax
movb %al, -0xd1(%rbp)
callq 0x2090
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2110
movb -0xd1(%rbp), %al
leaq 0x10231(%rip), %rdi     # 0x1363c
callq 0x2090
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_function
static void emit_function(Function* func) {
  comment("start Function");

  if (func->body == NULL) {
    comment("prototype");
    comment("end Function");
    return;
  }

  func_end_label = new_label("end");

  if (!func->is_static) {
    printf(".global %s\n", func->name);
  }

  printf("%s:\n", func->name);
  emit("push rbp");
  emit("mov rbp, rsp");

  // variable arguments list
  if (func->has_va_arg) {
    set_reg_nums(func->params);
    emit_regsave_area();
  }

  emit("sub rsp, %lu", func->local_size);

  for (size_t i = 0; i < func->params->length; i++) {
    Node* param = func->params->ptr[i];
    emit_var(param);
    store(argregs[i], size_of(param->type));
  }

  emit_node(func->body);

  printf("%s:\n", func_end_label);
  emit("leave");
  emit("ret");

  comment("end Function");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xed8c(%rip), %rdi      # 0x121bf
movb $0x0, %al
callq 0x35c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3466
leaq 0xed82(%rip), %rdi      # 0x121ce
movb $0x0, %al
callq 0x35c0
leaq 0xed7e(%rip), %rdi      # 0x121d8
movb $0x0, %al
callq 0x35c0
jmp 0x35b8
leaq 0xed78(%rip), %rdi      # 0x121e5
callq 0x3680
movq %rax, 0x141b7(%rip)     # 0x17630
movq -0x8(%rbp), %rax
testb $0x1, 0x28(%rax)
jne 0x3498
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0xed58(%rip), %rdi      # 0x121e9
movb $0x0, %al
callq 0x2090
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0xec8d(%rip), %rdi      # 0x12133
movb $0x0, %al
callq 0x2090
leaq 0xed41(%rip), %rdi      # 0x121f5
movb $0x0, %al
callq 0x3360
leaq 0xed3c(%rip), %rdi      # 0x121fe
movb $0x0, %al
callq 0x3360
movq -0x8(%rbp), %rax
testb $0x1, 0x29(%rax)
je 0x34e5
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x36c0
callq 0x36e0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
leaq 0xed17(%rip), %rdi      # 0x1220b
movb $0x0, %al
callq 0x3360
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x356c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x37c0
movq -0x10(%rbp), %rcx
leaq 0x13b90(%rip), %rax     # 0x170d0
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x9d60
movl -0x1c(%rbp), %edi
movq %rax, %rsi
callq 0x3820
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3503
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3860
movq 0x140b0(%rip), %rsi     # 0x17630
leaq 0xebac(%rip), %rdi      # 0x12133
movb $0x0, %al
callq 0x2090
leaq 0xec83(%rip), %rdi      # 0x12218
movb $0x0, %al
callq 0x3360
leaq 0xec7b(%rip), %rdi      # 0x1221e
movb $0x0, %al
callq 0x3360
leaq 0xec27(%rip), %rdi      # 0x121d8
movb $0x0, %al
callq 0x35c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: comment
static void comment(char *fmt, ...) {
  va_list ap;
  va_start(ap, fmt);
  printf("# ");
  vprintf(fmt, ap);
  printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x35f5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
leaq 0xebde(%rip), %rdi      # 0x12222
xorl %eax, %eax
movb %al, -0xd1(%rbp)
callq 0x2090
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2110
movb -0xd1(%rbp), %al
leaq 0xffd1(%rip), %rdi      # 0x1363c
callq 0x2090
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_regsave_area
static void emit_regsave_area(void) {
  emit("sub rsp, %d", REGAREA_SIZE);
  emit("mov [rsp], rdi");
  emit("mov [rsp + 8], rsi");
  emit("mov [rsp + 16], rdx");
  emit("mov [rsp + 24], rcx");
  emit("mov [rsp + 32], r8");
  emit("mov [rsp + 40], r9");
  emit("movaps [rsp + 48], xmm0");
  emit("movaps [rsp + 64], xmm1");
  emit("movaps [rsp + 80], xmm2");
  emit("movaps [rsp + 96], xmm3");
  emit("movaps [rsp + 112], xmm4");
  emit("movaps [rsp + 128], xmm5");
  emit("movaps [rsp + 144], xmm6");
  emit("movaps [rsp + 160], xmm7");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xeb41(%rip), %rdi      # 0x1222c
movl $0xb0, %esi
movb $0x0, %al
callq 0x3360
leaq 0xeb3a(%rip), %rdi      # 0x12238
movb $0x0, %al
callq 0x3360
leaq 0xeb3b(%rip), %rdi      # 0x12247
movb $0x0, %al
callq 0x3360
leaq 0xeb40(%rip), %rdi      # 0x1225a
movb $0x0, %al
callq 0x3360
leaq 0xeb46(%rip), %rdi      # 0x1226e
movb $0x0, %al
callq 0x3360
leaq 0xeb4c(%rip), %rdi      # 0x12282
movb $0x0, %al
callq 0x3360
leaq 0xeb51(%rip), %rdi      # 0x12295
movb $0x0, %al
callq 0x3360
leaq 0xeb56(%rip), %rdi      # 0x122a8
movb $0x0, %al
callq 0x3360
leaq 0xeb60(%rip), %rdi      # 0x122c0
movb $0x0, %al
callq 0x3360
leaq 0xeb6a(%rip), %rdi      # 0x122d8
movb $0x0, %al
callq 0x3360
leaq 0xeb74(%rip), %rdi      # 0x122f0
movb $0x0, %al
callq 0x3360
leaq 0xeb7e(%rip), %rdi      # 0x12308
movb $0x0, %al
callq 0x3360
leaq 0xeb89(%rip), %rdi      # 0x12321
movb $0x0, %al
callq 0x3360
leaq 0xeb94(%rip), %rdi      # 0x1233a
movb $0x0, %al
callq 0x3360
leaq 0xeb9f(%rip), %rdi      # 0x12353
movb $0x0, %al
callq 0x3360
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_var
static void emit_var(Node* var) {
  comment("start lval NVAR %s", var->name);
  emit("lea rax, -%zu[rbp]", var->offset);
  push(AX);
  comment("end lval NVAR %s", var->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0xeb91(%rip), %rdi      # 0x1236c
movb $0x0, %al
callq 0x35c0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
leaq 0xeb8e(%rip), %rdi      # 0x1237f
movb $0x0, %al
callq 0x3360
xorl %edi, %edi
callq 0x5140
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0xeb84(%rip), %rdi      # 0x12392
movb $0x0, %al
callq 0x35c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: reg
static char* reg(Reg r, size_t s) {
  if (s == 1) {
    return reg8[r];
  } else if (s == 4) {
    return reg32[r];
  } else {
    return reg64[r];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jne 0x5198
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x11fb2(%rip), %rax     # 0x17140
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x51c9
cmpq $0x4, -0x18(%rbp)
jne 0x51b5
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x11fe5(%rip), %rax     # 0x17190
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x51c9
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x11f2f(%rip), %rax     # 0x170f0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_lval
static void emit_lval(Node* node) {
  if (node->tag == NVAR) {
    emit_var(node);
  } else if (node->tag == NGVAR) {
    comment("start lval NGVAR");
    emit("lea rax, %s", node->name);
    push(AX);
    comment("end lval NGVAR");
  } else if (node->tag == NMEMBER) {
    comment("start lval NMEMBER");
    emit_lval(node->expr);
    size_t offset = field_offset(type_of(node->expr)->fields, node->name);
    pop(AX);
    emit("lea rax, %zu[rax]", offset);
    push(AX);
    comment("end lval NMEMBER");
  } else if (node->tag == NDEREF){
    comment("start lval NDEREF");
    emit_node(node->expr);
    comment("end lval NDEREF");
  } else {
    bad_token(node->token, "emit error: emit_lval");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x5223
movq -0x8(%rbp), %rdi
callq 0x37c0
jmp 0x532e
movq -0x8(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x526a
leaq 0xd689(%rip), %rdi      # 0x128bc
movb $0x0, %al
callq 0x35c0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
leaq 0xd684(%rip), %rdi      # 0x128cd
movb $0x0, %al
callq 0x3360
xorl %edi, %edi
callq 0x5140
leaq 0xd67b(%rip), %rdi      # 0x128d9
movb $0x0, %al
callq 0x35c0
jmp 0x532c
movq -0x8(%rbp), %rax
cmpl $0x1b, (%rax)
jne 0x52e0
leaq 0xd66e(%rip), %rdi      # 0x128e8
movb $0x0, %al
callq 0x35c0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x5200
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x9f70
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0xa100
movq %rax, -0x10(%rbp)
xorl %edi, %edi
callq 0x5340
movq -0x10(%rbp), %rsi
leaq 0xd639(%rip), %rdi      # 0x128fb
movb $0x0, %al
callq 0x3360
xorl %edi, %edi
callq 0x5140
leaq 0xd636(%rip), %rdi      # 0x1290d
movb $0x0, %al
callq 0x35c0
jmp 0x532a
movq -0x8(%rbp), %rax
cmpl $0x1a, (%rax)
jne 0x5314
leaq 0xd62e(%rip), %rdi      # 0x1291e
movb $0x0, %al
callq 0x35c0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3860
leaq 0xd625(%rip), %rdi      # 0x12930
movb $0x0, %al
callq 0x35c0
jmp 0x5328
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xd61d(%rip), %rsi      # 0x12940
callq 0xed90
jmp 0x532a
jmp 0x532c
jmp 0x532e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: load
static void load(Reg dst, size_t size) {
  if (size == 1) {
    // 8bitの値は自動では0拡張されないので、movzxを使う
    // 32bit整数との演算を行うので32bitレジスタにロードする
    emit("movsx %s, BYTE PTR [rax]", reg(dst, 4));
  } else {
   emit("mov %s, [rax]", reg(dst, size));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x1, -0x10(%rbp)
jne 0x53a6
movl -0x4(%rbp), %edi
movl $0x4, %esi
callq 0x5170
movq %rax, %rsi
leaq 0xd5c2(%rip), %rdi      # 0x1295f
movb $0x0, %al
callq 0x3360
jmp 0x53c3
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5170
movq %rax, %rsi
leaq 0xd5bc(%rip), %rdi      # 0x12978
movb $0x0, %al
callq 0x3360
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_assign
static void emit_assign(Node* lhs, Node* rhs) {
  comment("  start lval");
  emit_lval(lhs);
  comment("  end lval");
  emit_node(rhs);
  pop(DI);
  pop(AX);
  store(DI, size_of(type_of(lhs)));
  push(DI);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xd55f(%rip), %rdi      # 0x12986
movb $0x0, %al
callq 0x35c0
movq -0x8(%rbp), %rdi
callq 0x5200
leaq 0xd555(%rip), %rdi      # 0x12993
movb $0x0, %al
callq 0x35c0
movq -0x10(%rbp), %rdi
callq 0x3860
movl $0x1, %edi
callq 0x5340
xorl %edi, %edi
callq 0x5340
movq -0x8(%rbp), %rdi
callq 0x9f70
movq %rax, %rdi
callq 0x9d60
movq %rax, %rsi
movl $0x1, %edi
callq 0x3820
movl $0x1, %edi
callq 0x5140
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: emit_builtin_va_start
static void emit_builtin_va_start(Node* node) {
  align_rsp();
  emit_node(node);
  pop(AX); // address of va_list
  push(CX); // save register
  emit("mov DWORD PTR [rax], %d", numgp * 8);
  emit("mov DWORD PTR [rax + 4], 48");
  emit("lea rcx, [rbp - %d]", REGAREA_SIZE);
  emit("mov [rax + 16], rcx");
  pop(CX); // load register
  revert_rsp();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x5520
movq -0x8(%rbp), %rdi
callq 0x3860
xorl %edi, %edi
callq 0x5340
movl $0x4, %edi
callq 0x5140
movl 0x1217b(%rip), %esi     # 0x1763c
shll $0x3, %esi
leaq 0xd4d3(%rip), %rdi      # 0x1299e
movb $0x0, %al
callq 0x3360
leaq 0xd4dd(%rip), %rdi      # 0x129b6
movb $0x0, %al
callq 0x3360
leaq 0xd4eb(%rip), %rdi      # 0x129d2
movl $0xb0, %esi
movb $0x0, %al
callq 0x3360
leaq 0xd4ec(%rip), %rdi      # 0x129e6
movb $0x0, %al
callq 0x3360
movl $0x4, %edi
callq 0x5340
callq 0x5560
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/emit.c
// Function: align_rsp
static void align_rsp(void) {
  comment("start align rsp");
  emit("mov r10, rsp");
  emit("and rsp, -16"); // 下位4bit(16で割ったあまり)を切り捨て
  comment("end align rsp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xd4cf(%rip), %rdi      # 0x129fa
movb $0x0, %al
callq 0x35c0
leaq 0xd4d1(%rip), %rdi      # 0x12a0a
movb $0x0, %al
callq 0x3360
leaq 0xd4d0(%rip), %rdi      # 0x12a17
movb $0x0, %al
callq 0x3360
leaq 0xd4cf(%rip), %rdi      # 0x12a24
movb $0x0, %al
callq 0x35c0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: is_defined_proto
IFunc* is_defined_proto(Vector* funcs, char* name) {
  for (size_t i = 0; i < funcs->length; i++) {
    IFunc* func = funcs->ptr[i];
    if (streq(func->name, name) && !func->blocks) {
      return func;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x5603
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xfca0
cmpl $0x0, %eax
je 0x55f3
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x55f3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x560b
jmp 0x55f5
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x55a8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: gen_ir
IProgram* gen_ir(Program* program) {
  IProgram* ip = calloc(1, sizeof(IProgram));
  ip->globals = program->globals;
  ip->ifuncs = new_vec();

  for (int i = 0; i < program->funcs->length; i++) {
    Function* func = program->funcs->ptr[i];
    IFunc* ifunc = emit_func(func);

    // プロトタイプ宣言を上書きする。
    // gen_x86ですべてのプロトタイプ宣言を外部関数だと解釈する
    IFunc* proto = is_defined_proto(ip->ifuncs, func->name);
    if (proto) {
      memcpy(proto, ifunc, sizeof(IFunc));
    } else {
      vec_push(ip->ifuncs, ifunc);
    }
  }

  return ip;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x20d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x0, %al
callq 0x2280
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x577d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5790
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x5590
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x575d
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x28, %edx
callq 0x20f0
jmp 0x576d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x22e0
jmp 0x576f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x56f7
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: emit_func
static IFunc* emit_func(Function* func) {
  IFunc* ifunc = calloc(1, sizeof(IFunc));
  ifunc->name = func->name;
  ifunc->is_static = func->is_static;
  ifunc->has_va_arg = func->has_va_arg;
  ifunc->params = new_vec();

  if (!func->body) {
    return ifunc;
  }

  ifunc->blocks = new_vec();
  blocks = ifunc->blocks;

  ifunc->entry_label = new_label("entry");
  in_new_block(ifunc->entry_label);

  for (int i = 0; i < func->params->length; i++) {
    Node* param = func->params->ptr[i];
    emit_ir(alloc(size_of(type_of(param))));

    IReg* reg = new_reg(8);
    emit_ir(address(reg, param->offset));
    emit_ir(storearg(reg, i, size_of(type_of(func->params->ptr[i]))));
    vec_push(ifunc->params, reg);
    // assign_var(((Node*)func->params->ptr[i])->name, reg);
  }

  emit_stmt(func->body);

  return ifunc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movb 0x28(%rax), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
movb 0x29(%rax), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x9(%rax)
movb $0x0, %al
callq 0x2280
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x5809
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5944
movb $0x0, %al
callq 0x2280
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x11e1e(%rip)     # 0x17648
leaq 0xd3e3(%rip), %rdi      # 0x12c14
callq 0x5950
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x59a0
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x592f
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9f70
movq %rax, %rdi
callq 0x9d60
movl %eax, %edi
callq 0x5a10
movq %rax, %rdi
callq 0x59e0
movl $0x8, %edi
callq 0x5a40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movl %eax, %esi
callq 0x5a90
movq %rax, %rdi
callq 0x59e0
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x9f70
movq %rax, %rdi
callq 0x9d60
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %esi
movq %rax, %rdx
callq 0x5ad0
movq %rax, %rdi
callq 0x59e0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x22e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5855
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5b50
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: new_reg
static IReg* new_reg(size_t size) {
  IReg* new = calloc(1, sizeof(IReg));
  new->id = reg_id++;
  new->size = size;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x20d0
movq %rax, -0x10(%rbp)
movl 0x11bfb(%rip), %ecx     # 0x17660
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x11bf0(%rip)     # 0x17660
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: address
static IR* address(IReg* addr, int offset) {
  IR* new = new_ir(IADDRESS);
  new->r0 = addr;
  new->imm_int = offset;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x11, %edi
callq 0x8d70
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: storearg
static IR* storearg(IReg* dst, int arg_index, size_t size) {
  assert(dst);
  IR* new = new_ir(ISTOREARG);
  new->r1 = dst;
  new->imm_int = arg_index;
  new->size = size;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5aec
jmp 0x5b0b
leaq 0xd12e(%rip), %rdi      # 0x12c21
leaq 0xd12b(%rip), %rsi      # 0x12c25
movl $0x60, %edx
leaq 0xd12c(%rip), %rcx      # 0x12c32
callq 0x20b0
movl $0x14, %edi
callq 0x8d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: new_block
static Block* new_block(char* label) {
  Block* new = calloc(1, sizeof(Block));
  new->label = label;
  new->instrs = new_vec();
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x20d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, %al
callq 0x2280
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: branch
static IR* branch(IReg* cond, char* then_label, char* else_label) {
  IR* new = new_ir(IBR);
  new->r1 = cond;
  new->then = then_label;
  new->els = else_label;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x8d70
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: imm
static IR* imm(IReg* reg, int val) {
  IR* new = calloc(1, sizeof(IR));
  new->op = IIMM;
  new->r0 = reg;
  new->imm_int = val;
  return new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x58, %esi
callq 0x20d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/takoeight0821[P]hoc_nyan/src/gen_ir.c
// Function: emit_lval
static IReg* emit_lval(Node* node) {
  switch (node->tag) {
  case NVAR: {
    IReg* addr = new_reg(8);
    emit_ir(address(addr, node->offset));
    return addr;
  }
  case NGVAR: {
    IReg* addr = new_reg(8);
    emit_ir(label(addr, node->name));
    return addr;
  }
  case NMEMBER: {
    IReg* addr = emit_lval(node->expr);
    IReg* offset = new_reg(8);
    emit_ir(imm(offset, field_offset(type_of(node->expr)->fields, node->name)));
    IReg* reg = new_reg(8);
    emit_ir(new_binop_ir(IADD, reg, addr, offset));
    return reg;
  }
  case NDEREF: {
    return emit_expr(node->expr);
  }
  default: {
    bad_token(node->token, "gen_ir error: emit_lval");
  }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x40(%rbp)
subl $0x1a, %eax
ja 0x7582
movq -0x40(%rbp), %rax
leaq 0xb73a(%rip), %rcx      # 0x12ba8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x8, %edi
callq 0x5a40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl %eax, %esi
callq 0x5a90
movq %rax, %rdi
callq 0x59e0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7596
movl $0x8, %edi
callq 0x5a40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0x76f0
movq %rax, %rdi
callq 0x59e0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7596
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x7440
movq %rax, -0x28(%rbp)
movl $0x8, %edi
callq 0x5a40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x9f70
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
callq 0xa100
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x73f0
movq %rax, %rdi
callq 0x59e0
movl $0x8, %edi
callq 0x5a40
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movl $0x2, %edi
callq 0x8db0
movq %rax, %rdi
callq 0x59e0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7596
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x6370
movq %rax, -0x8(%rbp)
jmp 0x7596
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xb782(%rip), %rsi      # 0x12d13
callq 0xed90
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq