LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: relational_expression
int relational_expression(struct pp_node **node) {
  int result = shift_expression(node);
  while((*node) && ((*node)->token->type == PP_LT || (*node)->token->type == PP_GT || (*node)->token->type == PP_LTE || (*node)->token->type == PP_GTE)) {
    enum pp_token_type type = (*node)->token->type;
    *node = (*node)->next;
    int value = shift_expression(node);
    if(type == PP_LT) {
      result = result < value;
    } else if(type == PP_GT) {
      result = result > value;
    } else if(type == PP_LTE) {
      result = result <= value;
    } else if(type == PP_GTE) {
      result = result >= value;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7660
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x15(%rbp)
je 0x779c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x2a, (%rcx)
movb %al, -0x16(%rbp)
je 0x7796
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x30, (%rcx)
movb %al, -0x16(%rbp)
je 0x7796
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x2d, (%rcx)
movb %al, -0x16(%rbp)
je 0x7796
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x33, (%rax)
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x77a8
jmp 0x7842
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7660
movl %eax, -0x14(%rbp)
cmpl $0x2a, -0x10(%rbp)
jne 0x77ee
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x783d
cmpl $0x30, -0x10(%rbp)
jne 0x7807
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
setg %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x783b
cmpl $0x2d, -0x10(%rbp)
jne 0x7820
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x7839
cmpl $0x33, -0x10(%rbp)
jne 0x7837
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x7839
jmp 0x783b
jmp 0x783d
jmp 0x7738
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: equality_expression
int equality_expression(struct pp_node **node) {
  int result = relational_expression(node);
  while((*node) && ((*node)->token->type == PP_EQ || (*node)->token->type == PP_NEQ)) {
    enum pp_token_type type = (*node)->token->type;
    *node = (*node)->next;
    int value = relational_expression(node);
    if(type == PP_EQ) {
      result = result == value;
    } else if(type == PP_NEQ) {
      result = result == value;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7720
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x15(%rbp)
je 0x78a4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x27, (%rcx)
movb %al, -0x16(%rbp)
je 0x789e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x29, (%rax)
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x78ad
jmp 0x7911
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7720
movl %eax, -0x14(%rbp)
cmpl $0x27, -0x10(%rbp)
jne 0x78f3
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x790c
cmpl $0x29, -0x10(%rbp)
jne 0x790a
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x790c
jmp 0x7868
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: and_expression
int and_expression(struct pp_node **node) {
  int result = equality_expression(node);
  while((*node) && (*node)->token->type == PP_AND) {
    *node = (*node)->next;
    int value = equality_expression(node);
    result = result & value;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7850
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x795a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x1e, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7963
jmp 0x798c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7850
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
andl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x7938
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: exclusive_or_expression
int exclusive_or_expression(struct pp_node **node) {
  int result = and_expression(node);
  while((*node) && (*node)->token->type == PP_XOR) {
    *node = (*node)->next;
    int value = and_expression(node);
    result = result ^ value;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7920
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x79da
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x24, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x79e3
jmp 0x7a0c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7920
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
xorl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x79b8
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: inclusive_or_expression
int inclusive_or_expression(struct pp_node **node) {
  int result = exclusive_or_expression(node);
  while((*node) && (*node)->token->type == PP_OR) {
    *node = (*node)->next;
    int value = exclusive_or_expression(node);
    result = result | value;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x79a0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x7a5a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x21, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7a63
jmp 0x7a8c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x79a0
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
orl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x7a38
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: logical_and_expression
int logical_and_expression(struct pp_node **node) {
  int result = inclusive_or_expression(node);
  while((*node) && (*node)->token->type == PP_LAND) {
    *node = (*node)->next;
    int value = inclusive_or_expression(node);
    result = result && value;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7a20
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x7ada
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x1f, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7ae3
jmp 0x7b23
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7a20
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x12(%rbp)
je 0x7b16
cmpl $0x0, -0x10(%rbp)
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x7ab8
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: logical_or_expression
int logical_or_expression(struct pp_node **node) {
  int result = logical_and_expression(node);
  while((*node) && (*node)->token->type == PP_LOR) {
    *node = (*node)->next;
    int value = logical_and_expression(node);
    result = result || value;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7aa0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x7b6a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x22, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x7b73
jmp 0x7bb3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7aa0
movl %eax, -0x10(%rbp)
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x12(%rbp)
jne 0x7ba6
cmpl $0x0, -0x10(%rbp)
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0xc(%rbp)
jmp 0x7b48
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: check_defined_operator
struct pp_node *check_defined_operator(struct pp_node **node) {
  struct pp_node *ident;

  *node = (*node)->next;
  if((*node)->token->type == PP_SPACE) {
    *node = (*node)->next;
  }

  if((*node)->token->type == PP_IDENT) {
    ident = *node;
  } else if((*node)->token->type == PP_LPAREN) {
    *node = (*node)->next;
    if((*node)->token->type == PP_SPACE) {
      *node = (*node)->next;
    }

    if((*node)->token->type == PP_IDENT) {
      ident = *node;
      *node = (*node)->next;

      if((*node)->token->type != PP_RPAREN) {
        error("%s is expected.\n", pp_token_name[PP_RPAREN]);
      }
    } else {
      error("%s is expected.\n", pp_token_name[PP_IDENT]);
    }
  } else {
    error("%s or %s is expected.\n", pp_token_name[PP_IDENT], pp_token_name[PP_RPAREN]);
  }

  return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x3c, (%rax)
jne 0x7bff
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x7c1e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x7d21
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x7, (%rax)
jne 0x7cf0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x3c, (%rax)
jne 0x7c64
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x7cc9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x8, (%rax)
je 0x7cc7
leaq 0x2d19(%rip), %rdi      # 0xa9bf
movl $0x31c, %esi            # imm = 0x31C
leaq 0x2dee(%rip), %rdx      # 0xaaa0
leaq 0x23f7(%rip), %rcx      # 0xa0b0
addq $0x100, %rcx            # imm = 0x100
movb $0x0, %al
callq 0x1280
jmp 0x7cee
leaq 0x2cef(%rip), %rdi      # 0xa9bf
movl $0x31f, %esi            # imm = 0x31F
leaq 0x2dc4(%rip), %rdx      # 0xaaa0
leaq 0x23cd(%rip), %rcx      # 0xa0b0
addq $0x20, %rcx
movb $0x0, %al
callq 0x1280
jmp 0x7d1f
leaq 0x2cc8(%rip), %rdi      # 0xa9bf
movl $0x322, %esi            # imm = 0x322
leaq 0x2d97(%rip), %rdx      # 0xaa9a
leaq 0x23a6(%rip), %r8       # 0xa0b0
movq %r8, %rcx
addq $0x20, %rcx
addq $0x100, %r8             # imm = 0x100
movb $0x0, %al
callq 0x1280
jmp 0x7d21
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: skip_group
void skip_group(struct preprocessor *pp) {
  while(peek_pp_token(pp)->type != PP_NONE) {
    if(peek_pp_token(pp)->type == PP_SHARP) {
      read_pp_token_with_space(pp);

      if(check_if_section(pp)) {
        skip_line(pp);
        skip_group(pp);
        while(check_keyword(pp, "elif")) {
          skip_line(pp);
          skip_group(pp);
        }
        if(check_keyword(pp, "else")) {
          skip_line(pp);
          skip_group(pp);
        }
        if(check_keyword(pp, "endif")) {
          skip_line(pp);
        }
      } else if(check_group_end(pp)) {
        break;
      } else {
        skip_line(pp);
      }
    } else {
      skip_line(pp);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d40
cmpl $0x3e, (%rax)
je 0x8328
movq -0x8(%rbp), %rdi
callq 0x6d40
cmpl $0x39, (%rax)
jne 0x831a
movq -0x8(%rbp), %rdi
callq 0x6f70
movq -0x8(%rbp), %rdi
callq 0x9130
cmpl $0x0, %eax
je 0x82fd
movq -0x8(%rbp), %rdi
callq 0x9230
movq -0x8(%rbp), %rdi
callq 0x8230
movq -0x8(%rbp), %rdi
leaq 0x282e(%rip), %rsi      # 0xaac6
callq 0x6e20
cmpl $0x0, %eax
je 0x82b6
movq -0x8(%rbp), %rdi
callq 0x9230
movq -0x8(%rbp), %rdi
callq 0x8230
jmp 0x828d
movq -0x8(%rbp), %rdi
leaq 0x280a(%rip), %rsi      # 0xaacb
callq 0x6e20
cmpl $0x0, %eax
je 0x82dd
movq -0x8(%rbp), %rdi
callq 0x9230
movq -0x8(%rbp), %rdi
callq 0x8230
movq -0x8(%rbp), %rdi
leaq 0x27e8(%rip), %rsi      # 0xaad0
callq 0x6e20
cmpl $0x0, %eax
je 0x82fb
movq -0x8(%rbp), %rdi
callq 0x9230
jmp 0x8318
movq -0x8(%rbp), %rdi
callq 0x91b0
cmpl $0x0, %eax
je 0x830d
jmp 0x8328
movq -0x8(%rbp), %rdi
callq 0x9230
jmp 0x8318
jmp 0x8323
movq -0x8(%rbp), %rdi
callq 0x9230
jmp 0x823c
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: if_directive
int if_directive(struct preprocessor *pp) {
  skip_pp_token_with_space(pp);

  int control = if_control(pp);
  conditional_include(pp, control);

  return control;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6fa0
movq -0x8(%rbp), %rdi
callq 0x7d30
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7fd0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: ifdef_directive
int ifdef_directive(struct preprocessor *pp) {
  skip_pp_token_with_space(pp);

  struct pp_token *ident = expect_pp_token(pp, PP_IDENT);
  discard_new_line(pp);

  struct macro_entry *macro = search_macro_table(ident->text->head);
  int control = macro != NULL;
  conditional_include(pp, control);

  return control;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6fa0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6ee0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6f40
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x59c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x7fd0
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: elif_directive
int elif_directive(struct preprocessor *pp, int skip) {
  skip_pp_token_with_space(pp);

  int control = if_control(pp);
  conditional_include(pp, !skip && control);

  return skip || control;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6fa0
movq -0x8(%rbp), %rdi
callq 0x7d30
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jne 0x8491
cmpl $0x0, -0x10(%rbp)
setne %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x7fd0
movb $0x1, %al
cmpl $0x0, -0xc(%rbp)
movb %al, -0x21(%rbp)
jne 0x84b7
cmpl $0x0, -0x10(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: if_section
void if_section(struct preprocessor *pp) {
  int skip;

  if(check_keyword(pp, "if")) {
    skip = if_directive(pp);
  } else if(check_keyword(pp, "ifdef")) {
    skip = ifdef_directive(pp);
  } else if(check_keyword(pp, "ifndef")) {
    skip = ifndef_directive(pp);
  }

  while(check_keyword(pp, "elif")) {
    skip = elif_directive(pp, skip);
  }

  if(check_keyword(pp, "else")) {
    else_directive(pp, skip);
  }

  if(check_keyword(pp, "endif")) {
    endif_directive(pp);
  } else {
    error("#endif directive is missing.\n");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x257c(%rip), %rsi      # 0xaad3
callq 0x6e20
cmpl $0x0, %eax
je 0x856f
movq -0x8(%rbp), %rdi
callq 0x8330
movl %eax, -0xc(%rbp)
jmp 0x85b7
movq -0x8(%rbp), %rdi
leaq 0x253f(%rip), %rsi      # 0xaab9
callq 0x6e20
cmpl $0x0, %eax
je 0x8592
movq -0x8(%rbp), %rdi
callq 0x8370
movl %eax, -0xc(%rbp)
jmp 0x85b5
movq -0x8(%rbp), %rdi
leaq 0x2522(%rip), %rsi      # 0xaabf
callq 0x6e20
cmpl $0x0, %eax
je 0x85b3
movq -0x8(%rbp), %rdi
callq 0x83e0
movl %eax, -0xc(%rbp)
jmp 0x85b5
jmp 0x85b7
jmp 0x85b9
movq -0x8(%rbp), %rdi
leaq 0x2502(%rip), %rsi      # 0xaac6
callq 0x6e20
cmpl $0x0, %eax
je 0x85df
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x8450
movl %eax, -0xc(%rbp)
jmp 0x85b9
movq -0x8(%rbp), %rdi
leaq 0x24e1(%rip), %rsi      # 0xaacb
callq 0x6e20
cmpl $0x0, %eax
je 0x8600
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x84d0
movq -0x8(%rbp), %rdi
leaq 0x24c5(%rip), %rsi      # 0xaad0
callq 0x6e20
cmpl $0x0, %eax
je 0x8620
movq -0x8(%rbp), %rdi
callq 0x8510
jmp 0x863a
leaq 0x2398(%rip), %rdi      # 0xa9bf
movl $0x3ac, %esi            # imm = 0x3AC
leaq 0x24a3(%rip), %rdx      # 0xaad6
movb $0x0, %al
callq 0x1280
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: try_fopen
int try_fopen(char *file) {
  FILE *fp = fopen(file, "r");

  if(fp == NULL) return 0;

  fclose(fp);
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x19bd(%rip), %rsi      # 0xa014
callq 0x10b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8670
movl $0x0, -0x4(%rbp)
jmp 0x8680
movq -0x18(%rbp), %rdi
callq 0x1040
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: search_header_file
struct string *search_header_file(struct string *text) {
  char location[4][64] = {
    "/usr/lib/gcc/x86_64-linux-gnu/7/include/",
    "/usr/include/",
    "/usr/include/linux/",
    "/usr/include/x86_64-linux-gnu/"
  };

  for(int k = 0; k < 4; k++) {
    struct string *path = allocate_string();
    write_string(path, location[k]);
    for(int i = 1; i < text->size - 1; i++) {
      append_string(path, text->head[i]);
    }

    if(try_fopen(path->head)) return path;

    free_string(path);
  }

  // failed to search header file
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
leaq -0x110(%rbp), %rdi
leaq 0x2643(%rip), %rsi      # 0xacf0
movl $0x100, %edx            # imm = 0x100
callq 0x1090
movl $0x0, -0x114(%rbp)
cmpl $0x4, -0x114(%rbp)
jge 0x878b
movb $0x0, %al
callq 0x2060
movq %rax, -0x120(%rbp)
movq -0x120(%rbp), %rdi
movslq -0x114(%rbp), %rax
leaq -0x110(%rbp), %rsi
shlq $0x6, %rax
addq %rax, %rsi
callq 0x21a0
movl $0x1, -0x124(%rbp)
movl -0x124(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x874a
movq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x124(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x20c0
movl -0x124(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x124(%rbp)
jmp 0x8707
movq -0x120(%rbp), %rax
movq (%rax), %rdi
callq 0x8640
cmpl $0x0, %eax
je 0x876b
movq -0x120(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8793
movq -0x120(%rbp), %rdi
callq 0x2240
movl -0x114(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x114(%rbp)
jmp 0x86c1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: search_named_source_file
struct string *search_named_source_file(struct string *text, const char *current_file) {
  int last_slash = 0;
  for(int i = 0; current_file[i]; i++) {
    if(current_file[i] == '/') {
      last_slash = i;
    }
  }

  struct string *dir = allocate_string();
  if(last_slash > 0) {
    for(int i = 0; i < last_slash; i++) {
      append_string(dir, current_file[i]);
    }
    append_string(dir, '/');
  }

  struct string *path = allocate_string();
  concat_string(path, dir);
  for(int i = 1; i < text->size - 1; i++) {
    append_string(path, text->head[i]);
  }

  if(try_fopen(path->head)) {
    return path;
  }

  free_string(path);

  // reprocess as if header file was read
  return search_header_file(text);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x87f0
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x87e3
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x87e5
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x87be
movb $0x0, %al
callq 0x2060
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x883e
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x8830
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x20c0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8808
movq -0x28(%rbp), %rdi
movl $0x2f, %esi
callq 0x20c0
movb $0x0, %al
callq 0x2060
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x21f0
movl $0x1, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x8891
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0x20c0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x885d
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x8640
cmpl $0x0, %eax
je 0x88ac
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x88c2
movq -0x38(%rbp), %rdi
callq 0x2240
movq -0x10(%rbp), %rdi
callq 0x8690
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: include_directive
void include_directive(struct preprocessor *pp) {
  struct pp_token *header;
  if(peek_pp_token(pp)->type == PP_H_NAME) {
    header = read_pp_token(pp);
  } else {
    error("macro-replaced include directive is not implemented yet.\n");
  }
  discard_new_line(pp);

  struct string *path;
  if(header->type == PP_H_NAME && header->text->head[0] == '<') {
    path = search_header_file(header->text);
  } else if(header->type == PP_H_NAME && header->text->head[0] == '"') {
    path = search_named_source_file(header->text, pp->lexer->src->file);
  }

  if(path == NULL) {
    error("failed to search include file\n");
  }

  struct pp_list *list = parse_preprocessing_file(path->head);
  concat_pp_list(pp->list, list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d40
cmpl $0x0, (%rax)
jne 0x88f9
movq -0x8(%rbp), %rdi
callq 0x6d90
movq %rax, -0x10(%rbp)
jmp 0x8913
leaq 0x20bf(%rip), %rdi      # 0xa9bf
movl $0x3f7, %esi            # imm = 0x3F7
leaq 0x21e8(%rip), %rdx      # 0xaaf4
movb $0x0, %al
callq 0x1280
movq -0x8(%rbp), %rdi
callq 0x6f40
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x894b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x3c, %eax
jne 0x894b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8690
movq %rax, -0x18(%rbp)
jmp 0x8988
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8986
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x22, %eax
jne 0x8986
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
callq 0x87a0
movq %rax, -0x18(%rbp)
jmp 0x8988
cmpq $0x0, -0x18(%rbp)
jne 0x89a9
leaq 0x2029(%rip), %rdi      # 0xa9bf
movl $0x403, %esi            # imm = 0x403
leaq 0x218c(%rip), %rdx      # 0xab2e
movb $0x0, %al
callq 0x1280
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x89d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x54d0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: parse_preprocessing_file
struct pp_list *parse_preprocessing_file(unsigned char *file) {
  struct preprocessor pp;
  pp.lexer = allocate_pp_token_lexer(file);
  pp.token_queue_size = 0;
  pp.list = allocate_pp_list();

  group(&pp);

  if(!check_pp_token(&pp, PP_NONE)) {
    if(check_keyword(&pp, "elif")) {
      error("invalid #elif directive appeared.\n");
    } else if(check_keyword(&pp, "else")) {
      error("invalid #else directive appeared.\n");
    } else if(check_keyword(&pp, "endif")) {
      error("invalid #endif directive appeared.\n");
    }
  }

  return pp.list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2270
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x53b0
movq %rax, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8000
leaq -0x28(%rbp), %rdi
movl $0x3e, %esi
callq 0x6df0
cmpl $0x0, %eax
jne 0x8ab0
leaq -0x28(%rbp), %rdi
leaq 0x20a2(%rip), %rsi      # 0xaac6
callq 0x6e20
cmpl $0x0, %eax
je 0x8a4a
leaq 0x1f8a(%rip), %rdi      # 0xa9bf
movl $0x504, %esi            # imm = 0x504
leaq 0x2235(%rip), %rdx      # 0xac76
movb $0x0, %al
callq 0x1280
jmp 0x8aae
leaq -0x28(%rbp), %rdi
leaq 0x2076(%rip), %rsi      # 0xaacb
callq 0x6e20
cmpl $0x0, %eax
je 0x8a7b
leaq 0x1f59(%rip), %rdi      # 0xa9bf
movl $0x506, %esi            # imm = 0x506
leaq 0x2227(%rip), %rdx      # 0xac99
movb $0x0, %al
callq 0x1280
jmp 0x8aac
leaq -0x28(%rbp), %rdi
leaq 0x204a(%rip), %rsi      # 0xaad0
callq 0x6e20
cmpl $0x0, %eax
je 0x8aaa
leaq 0x1f28(%rip), %rdi      # 0xa9bf
movl $0x508, %esi            # imm = 0x508
leaq 0x2219(%rip), %rdx      # 0xacbc
movb $0x0, %al
callq 0x1280
jmp 0x8aac
jmp 0x8aae
jmp 0x8ab0
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: check_parameter
int check_parameter(struct macro_entry *macro, struct pp_token *token) {
  int parameter_size = macro->parameter_size;
  if(macro->parameter_ellipsis) parameter_size++;

  if(token->type == PP_IDENT) {
    for(int i = 0; i < parameter_size; i++) {
      if(strcmp(token->text->head, macro->parameters[i]->head) == 0) {
        return 1;
      }
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x8aed
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x8b42
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x8b40
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0x8b33
movl $0x1, -0x4(%rbp)
jmp 0x8b49
jmp 0x8b35
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8afd
jmp 0x8b42
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: check_stringify_operator
int check_stringify_operator(struct macro_entry *macro) {
  struct pp_list *list = macro->replacement_list;

  for(struct pp_node *node = list->head; node != NULL; node = node->next) {
    if(node->token->type == PP_SHARP) {
      struct pp_node *target = node->next;

      if(target == NULL) return 0;
      if(target->token->type == PP_SPACE) target = target->next;
      if(!check_parameter(macro, target->token)) return 0;

      node = target;
    }
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x418(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8c03
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x39, (%rax)
jne 0x8bf3
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8bb5
movl $0x0, -0x4(%rbp)
jmp 0x8c0a
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpl $0x3c, (%rax)
jne 0x8bcd
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x8ac0
cmpl $0x0, %eax
jne 0x8beb
movl $0x0, -0x4(%rbp)
jmp 0x8c0a
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8bf5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x8b86
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: check_concat_operator
int check_concat_operator(struct macro_entry *macro) {
  struct pp_list *list = macro->replacement_list;

  for(struct pp_node *node = list->head; node != NULL; node = node->next) {
    if(node->token->type == PP_CONCAT) {
      if(node == list->head) return 0;
      if(node->next == NULL) return 0;
    }
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x418(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8c91
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x3a, (%rax)
jne 0x8c81
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x8c6b
movl $0x0, -0x4(%rbp)
jmp 0x8c98
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x8c7f
movl $0x0, -0x4(%rbp)
jmp 0x8c98
jmp 0x8c81
jmp 0x8c83
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x8c42
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: parse_text_line
void parse_text_line(struct preprocessor *pp) {
  struct pp_list *text = allocate_pp_list();

  while(1) {
    struct pp_token *token = read_pp_token(pp);
    append_pp_list(text, token);
    if(token->type == PP_NEW_LINE) {
      struct pp_token *next = peek_pp_token(pp);
      if(next->type == PP_SHARP || next->type == PP_NONE) {
        break;
      }
    }
  }

  struct pp_list *replaced = scan_macro(pp, text);
  concat_pp_list(pp->list, replaced);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x53b0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d90
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5460
movq -0x18(%rbp), %rax
cmpl $0x3b, (%rax)
jne 0x90fb
movq -0x8(%rbp), %rdi
callq 0x6d40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x39, (%rax)
je 0x90f7
movq -0x20(%rbp), %rax
cmpl $0x3e, (%rax)
jne 0x90f9
jmp 0x90fd
jmp 0x90fb
jmp 0x90b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5c00
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x54d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: check_if_section
int check_if_section(struct preprocessor *pp) {
  if(check_keyword(pp, "if")) return 1;
  if(check_keyword(pp, "ifdef")) return 1;
  if(check_keyword(pp, "ifndef")) return 1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x198c(%rip), %rsi      # 0xaad3
callq 0x6e20
cmpl $0x0, %eax
je 0x915a
movl $0x1, -0x4(%rbp)
jmp 0x919d
movq -0x10(%rbp), %rdi
leaq 0x1954(%rip), %rsi      # 0xaab9
callq 0x6e20
cmpl $0x0, %eax
je 0x9178
movl $0x1, -0x4(%rbp)
jmp 0x919d
movq -0x10(%rbp), %rdi
leaq 0x193c(%rip), %rsi      # 0xaabf
callq 0x6e20
cmpl $0x0, %eax
je 0x9196
movl $0x1, -0x4(%rbp)
jmp 0x919d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: check_group_end
int check_group_end(struct preprocessor *pp) {
  if(check_keyword(pp, "elif")) return 1;
  if(check_keyword(pp, "else")) return 1;
  if(check_keyword(pp, "endif")) return 1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x18ff(%rip), %rsi      # 0xaac6
callq 0x6e20
cmpl $0x0, %eax
je 0x91da
movl $0x1, -0x4(%rbp)
jmp 0x921d
movq -0x10(%rbp), %rdi
leaq 0x18e6(%rip), %rsi      # 0xaacb
callq 0x6e20
cmpl $0x0, %eax
je 0x91f8
movl $0x1, -0x4(%rbp)
jmp 0x921d
movq -0x10(%rbp), %rdi
leaq 0x18cd(%rip), %rsi      # 0xaad0
callq 0x6e20
cmpl $0x0, %eax
je 0x9216
movl $0x1, -0x4(%rbp)
jmp 0x921d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: preprocess
struct pp_list *preprocess(unsigned char *file) {
  struct macro_entry *arch = allocate_macro_entry();
  arch->identifier = "__x86_64__";
  insert_macro_table(arch);

  struct pp_list *list = parse_preprocessing_file(file);

  for(int i = 0; i < MACRO_TABLE_SIZE; i++) {
    if(macro_table[i] != NULL) {
      free_macro_entry(macro_table[i]);
    }
  }

  return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x5510
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
leaq 0x1a60(%rip), %rcx      # 0xace0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x5790
movq -0x8(%rbp), %rdi
callq 0x89d0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa001, -0x1c(%rbp)    # imm = 0xA001
jge 0x92dd
movslq -0x1c(%rbp), %rcx
leaq 0x4dfb(%rip), %rax      # 0xe0b0
cmpq $0x0, (%rax,%rcx,8)
je 0x92d0
movslq -0x1c(%rbp), %rcx
leaq 0x4de9(%rip), %rax      # 0xe0b0
movq (%rax,%rcx,8), %rdi
callq 0x5570
jmp 0x92d2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x92a1
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/main.c
// Function: main
int main(int argc, char **argv) {
  if(argc < 2) {
    error("usage: skcc [source file name]");
  }

  char *file = argv[1];
  struct pp_list *list = preprocess(file);

  /* for(struct pp_node *node = list->head; node != NULL; node = node->next) { */
  /*   struct pp_token *token = node->token; */
  /*   printf("(%d, %s)", token->type, token->name); */
  /*   if(token->type != PP_NEW_LINE && token->type != PP_SPACE && token->type != PP_NONE) { */
  /*     printf(" %s", token->text->head); */
  /*   } */
  /*   printf("\n"); */
  /* } */

  for(struct pp_node *node = list->head; node != NULL; node = node->next) {
    struct pp_token *token = node->token;
    printf("%s", token->text->head);
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x9326
leaq 0x1add(%rip), %rdi      # 0xadf0
movl $0x5, %esi
leaq 0x1ad8(%rip), %rdx      # 0xadf7
movb $0x0, %al
callq 0x1280
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x9383
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
leaq 0x1aa8(%rip), %rdi      # 0xae16
movb $0x0, %al
callq 0x1050
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x934a
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/net.cpp
// Function: Net::Net(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Net::Net(string n){
  netname = n;
  val ='x';
  drivers = new vector<Gate *>;
  loads = new vector<Gate *>;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3330
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3050
jmp 0x3738
movq -0x38(%rbp), %rax
movb $0x78, 0x10(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x40(%rbp)
jmp 0x3750
movq -0x40(%rbp), %rdi
callq 0x3a60
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x48(%rbp)
jmp 0x3774
movq -0x48(%rbp), %rdi
callq 0x3a60
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3150
movq -0x18(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/net.cpp
// Function: Net::printDriversLoads()
void Net::printDriversLoads(){
  cout << " net " << name();

  cout << ", drivers: ";
  for(unsigned int i=0; i!=drivers->size();i++){
    cout << (*drivers)[i];
  }

  cout << "  loads: ";
  for(unsigned int i=0; i!=loads->size();i++){
    cout << (*loads)[i];
  }
  cout<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x136b5(%rip), %rdi     # 0x16fd0
leaq 0xc6e2(%rip), %rsi      # 0x10004
callq 0x3220
movq -0x58(%rbp), %rsi
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3830
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x3200
jmp 0x394b
leaq -0x28(%rbp), %rdi
callq 0x3150
movq 0x13675(%rip), %rdi     # 0x16fd0
leaq 0xc6a8(%rip), %rsi      # 0x1000a
callq 0x3220
movl $0x0, -0x38(%rbp)
movq -0x58(%rbp), %rax
movl -0x38(%rbp), %ecx
movq %rcx, -0x60(%rbp)
movq (%rax), %rdi
callq 0x3b50
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x39cf
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movl -0x38(%rbp), %eax
movl %eax, %esi
callq 0x3b70
movq (%rax), %rsi
movq 0x13628(%rip), %rdi     # 0x16fd0
callq 0x31b0
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x396e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3150
jmp 0x3a4e
movq 0x135fa(%rip), %rdi     # 0x16fd0
leaq 0xc639(%rip), %rsi      # 0x10016
callq 0x3220
movl $0x0, -0x3c(%rbp)
movq -0x58(%rbp), %rax
movl -0x3c(%rbp), %ecx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rdi
callq 0x3b50
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
je 0x3a35
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x3c(%rbp), %eax
movl %eax, %esi
callq 0x3b70
movq (%rax), %rsi
movq 0x135ab(%rip), %rdi     # 0x16fd0
callq 0x31b0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x39e9
movq 0x13594(%rip), %rdi     # 0x16fd0
movq 0x1357d(%rip), %rsi     # 0x16fc0
callq 0x3270
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/gsim.cpp
// Function: main
int main(int argc, char* argv[]){

  if(argc < 2){ //use "argc < 3" for pa6
    cerr << "Usage: ./gatesim verilog_file input_test_file" << endl;
    return 1;
  }

/*************** autoparsing **************
//note: to use the autoparsing, need to change "parse" to a pure virtual fuction, in vlg_parser.h, namely:
//  virtual Design *parse(char *filename) =0;

  VlgParserAuto auto_;
  Design* design2 = auto_.parse(argv[1]);
  ofstream output_stream("autoparsing_result.v");

  design2->dump(output_stream);
  output_stream.close();
*******************************************/

  //self parsing
  VlgParser pars;
  Design* design1= pars.parse(argv[1]);
  ofstream ofile("output.v") ; 
  
  //print results if no errors
  if(design1!=NULL){
    cout<< " parser correct " <<endl;
    design1->dump(ofile);
    delete design1;
  }
  else{ //if error, report
    cout<< " Parser reports error " <<endl;
  }


  ofile.close();

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x456d
movq 0x12aaa(%rip), %rdi     # 0x16ff0
leaq 0xbaed(%rip), %rsi      # 0x1003a
callq 0x3220
movq %rax, %rdi
movq 0x12a64(%rip), %rsi     # 0x16fc0
callq 0x3270
movl $0x1, -0x4(%rbp)
jmp 0x4695
leaq -0x18(%rbp), %rdi
callq 0x46b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0xb3d0
movq %rax, -0x20(%rbp)
leaq -0x220(%rbp), %rdi
leaq 0xbacf(%rip), %rsi      # 0x10068
movl $0x10, %edx
callq 0x32a0
cmpq $0x0, -0x20(%rbp)
je 0x4641
movq 0x12a1b(%rip), %rdi     # 0x16fd0
leaq 0xbab5(%rip), %rsi      # 0x10071
callq 0x3220
movq %rax, -0x238(%rbp)
jmp 0x45ca
movq -0x238(%rbp), %rdi
movq 0x129e8(%rip), %rsi     # 0x16fc0
callq 0x3270
jmp 0x45df
movq -0x20(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x6e40
jmp 0x45f1
movq -0x20(%rbp), %rax
movq %rax, -0x240(%rbp)
cmpq $0x0, %rax
je 0x461f
movq -0x240(%rbp), %rdi
callq 0x6760
movq -0x240(%rbp), %rdi
movl $0xd8, %esi
callq 0x3240
jmp 0x4674
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x3360
jmp 0x46a1
movq 0x12988(%rip), %rdi     # 0x16fd0
leaq 0xba33(%rip), %rsi      # 0x10082
callq 0x3220
movq %rax, -0x248(%rbp)
jmp 0x465d
movq -0x248(%rbp), %rdi
movq 0x12955(%rip), %rsi     # 0x16fc0
callq 0x3270
jmp 0x4672
jmp 0x4674
leaq -0x220(%rbp), %rdi
callq 0x3340
jmp 0x4682
movl $0x0, -0x4(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x3360
movl -0x4(%rbp), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/gates.cpp
// Function: Gate::Gate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Gate::Gate(string n){ //no delay
  delay = 1;
  inst_name = n;
  inputs = new vector<Net *>;
  delay_default=true;
  output = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
leaq 0x124b5(%rip), %rax     # 0x16bd8
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3330
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, 0x38(%rax)
callq 0x3050
jmp 0x474d
movl $0x18, %edi
callq 0x3230
movq %rax, -0x40(%rbp)
jmp 0x475d
movq -0x40(%rbp), %rdi
callq 0x5ad0
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, 0x3c(%rax)
movq $0x0, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3150
movq -0x18(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/gates.cpp
// Function: Gate::Gate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
Gate::Gate(string n, int d){  // with delay provided
  inst_name = n;
  delay = d;
  inputs = new vector<Net *>;
  delay_default=false;
  output = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq 0x12402(%rip), %rax     # 0x16bd8
movq %rax, (%rdi)
addq $0x18, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3330
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3050
jmp 0x47f5
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x38(%rax)
movl $0x18, %edi
callq 0x3230
movq %rax, -0x48(%rbp)
jmp 0x480f
movq -0x48(%rbp), %rdi
callq 0x5ad0
movq -0x48(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x0, 0x3c(%rax)
movq $0x0, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3150
movq -0x20(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/luixmao[P]verilog/gates.cpp
// Function: Gate::dump(std::ostream&)
void Gate::dump(ostream &os) {

  if(!delay_default){
    os << "#" << delay <<" "; 
  }
  os << inst_name <<'(';
  if(output!=NULL){
    os << output->name();
  }
  for(unsigned int i=0; i!=inputs->size(); i++){
    os << ", " << ( (*inputs)[i]->name() );
  }
  os << ");" <<endl ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
testb $0x1, 0x3c(%rax)
jne 0x4a5f
movq -0x10(%rbp), %rdi
leaq 0xb65d(%rip), %rsi      # 0x10099
callq 0x3220
movq %rax, %rdi
movq -0x68(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x3400
movq %rax, %rdi
leaq 0xb758(%rip), %rsi      # 0x101b2
callq 0x3220
movq -0x68(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x18, %rsi
callq 0x3200
movq %rax, %rdi
movl $0x28, %esi
callq 0x32d0
movq -0x68(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4ad9
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq 0x10(%rax), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3830
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x3200
jmp 0x4ab4
leaq -0x30(%rbp), %rdi
callq 0x3150
jmp 0x4ad9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3150
jmp 0x4bae
movl $0x0, -0x40(%rbp)
movq -0x68(%rbp), %rax
movl -0x40(%rbp), %ecx
movq %rcx, -0x80(%rbp)
movq 0x8(%rax), %rdi
callq 0x5bc0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
je 0x4b86
movq -0x10(%rbp), %rdi
leaq 0xb58c(%rip), %rsi      # 0x1009b
callq 0x3220
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x90(%rbp)
movq 0x8(%rax), %rdi
movl -0x40(%rbp), %eax
movl %eax, %esi
callq 0x5be0
movq (%rax), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3830
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x3200
jmp 0x4b58
leaq -0x60(%rbp), %rdi
callq 0x3150
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x4ae0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3150
jmp 0x4bae
movq -0x10(%rbp), %rdi
leaq 0xb50d(%rip), %rsi      # 0x1009e
callq 0x3220
movq %rax, %rdi
movq 0x12420(%rip), %rsi     # 0x16fc0
callq 0x3270
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)