LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/utf8.c
// Function: count_bytes
int count_bytes(unsigned char c) {
  int bytes;

  if(0x00 <= c && c <= 0x7F) { // 1-byte character
    bytes = 1;
  } else if(0x80 <= c && c <= 0xC1) { // invalid sequence (not first byte)
    bytes = -1;
  } else if(0xC2 <= c && c <= 0xDF) { // 2-bytes character
    bytes = 2;
  } else if(0xE0 <= c && c <= 0xEF) { // 3-bytes character
    bytes = 3;
  } else if(0xF0 <= c && c <= 0xF7) { // 4-bytes character
    bytes = 4;
  } else if(0xF8 <= c && c <= 0xFB) { // 5-bytes character
    bytes = -1;
  } else if(0xFC <= c && c <= 0xFD) { // 6-bytes character
    bytes = -1;
  } else if(c == 0xFE) { // invalid sequence
    bytes = -1;
  } else if(c == 0xFF) { // EOF
    bytes = 0;
  }

  return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x1499
movzbl -0x1(%rbp), %eax
cmpl $0x7f, %eax
jg 0x1499
movl $0x1, -0x8(%rbp)
jmp 0x159e
movzbl -0x1(%rbp), %ecx
movl $0x80, %eax
cmpl %ecx, %eax
jg 0x14bd
movzbl -0x1(%rbp), %eax
cmpl $0xc1, %eax
jg 0x14bd
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x159c
movzbl -0x1(%rbp), %ecx
movl $0xc2, %eax
cmpl %ecx, %eax
jg 0x14e1
movzbl -0x1(%rbp), %eax
cmpl $0xdf, %eax
jg 0x14e1
movl $0x2, -0x8(%rbp)
jmp 0x159a
movzbl -0x1(%rbp), %ecx
movl $0xe0, %eax
cmpl %ecx, %eax
jg 0x1505
movzbl -0x1(%rbp), %eax
cmpl $0xef, %eax
jg 0x1505
movl $0x3, -0x8(%rbp)
jmp 0x1598
movzbl -0x1(%rbp), %ecx
movl $0xf0, %eax
cmpl %ecx, %eax
jg 0x1526
movzbl -0x1(%rbp), %eax
cmpl $0xf7, %eax
jg 0x1526
movl $0x4, -0x8(%rbp)
jmp 0x1596
movzbl -0x1(%rbp), %ecx
movl $0xf8, %eax
cmpl %ecx, %eax
jg 0x1547
movzbl -0x1(%rbp), %eax
cmpl $0xfb, %eax
jg 0x1547
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x1594
movzbl -0x1(%rbp), %ecx
movl $0xfc, %eax
cmpl %ecx, %eax
jg 0x1568
movzbl -0x1(%rbp), %eax
cmpl $0xfd, %eax
jg 0x1568
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x1592
movzbl -0x1(%rbp), %eax
cmpl $0xfe, %eax
jne 0x157c
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x1590
movzbl -0x1(%rbp), %eax
cmpl $0xff, %eax
jne 0x158e
movl $0x0, -0x8(%rbp)
jmp 0x1590
jmp 0x1592
jmp 0x1594
jmp 0x1596
jmp 0x1598
jmp 0x159a
jmp 0x159c
jmp 0x159e
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/utf8.c
// Function: single_byte_char
struct utf8c single_byte_char(unsigned char c) {
  struct utf8c uc;
  uc.bytes = 1;
  uc.sequence[0] = c;
  uc.sequence[1] = '\0';
  return uc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0xd(%rbp)
movl $0x1, -0xc(%rbp)
movb -0xd(%rbp), %al
movb %al, -0x8(%rbp)
movb $0x0, -0x7(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb -0x18(%rbp), %dl
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/utf8.c
// Function: code_point
struct utf8c code_point(int code) {
  int bit = 0;
  for(int i = code; i > 0; i /= 2) bit++;

  struct utf8c uc;
  if(0 <= bit && bit <= 7) {
    uc.bytes = 1;
    uc.sequence[0] = code;
  } else if(8 <= bit && bit <= 11) {
    uc.bytes = 2;
    uc.sequence[0] = ((code >> 6) & 0x1F) | 0xC0;
    uc.sequence[1] = (code & 0x3F) | 0x80;
  } else if(12 <= bit && bit <= 16) {
    uc.bytes = 3;
    uc.sequence[0] = ((code >> 12) & 0xF) | 0xE0;
    uc.sequence[1] = ((code >> 6) & 0x3F) | 0x80;
    uc.sequence[2] = (code & 0x3F) | 0x80;
  } else if(17 <= bit && bit <= 21) {
    uc.bytes = 4;
    uc.sequence[0] = ((code >> 18) & 0x7) | 0xF0;
    uc.sequence[1] = ((code >> 12) & 0x3F) | 0x80;
    uc.sequence[2] = ((code >> 6) & 0x3F) | 0x80;
    uc.sequence[3] = (code & 0x3F) | 0x80;
  } else {
    uc = ueof;
  }
  return uc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x1913
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
jmp 0x18f4
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jg 0x1932
cmpl $0x7, -0x14(%rbp)
jg 0x1932
movl $0x1, -0xc(%rbp)
movl -0x10(%rbp), %eax
movb %al, -0x8(%rbp)
jmp 0x1a2a
movl $0x8, %eax
cmpl -0x14(%rbp), %eax
jg 0x196d
cmpl $0xb, -0x14(%rbp)
jg 0x196d
movl $0x2, -0xc(%rbp)
movl -0x10(%rbp), %eax
sarl $0x6, %eax
andl $0x1f, %eax
orl $0xc0, %eax
movb %al, -0x8(%rbp)
movl -0x10(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0x7(%rbp)
jmp 0x1a28
movl $0xc, %eax
cmpl -0x14(%rbp), %eax
jg 0x19b6
cmpl $0x10, -0x14(%rbp)
jg 0x19b6
movl $0x3, -0xc(%rbp)
movl -0x10(%rbp), %eax
sarl $0xc, %eax
andl $0xf, %eax
orl $0xe0, %eax
movb %al, -0x8(%rbp)
movl -0x10(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0x7(%rbp)
movl -0x10(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0x6(%rbp)
jmp 0x1a26
movl $0x11, %eax
cmpl -0x14(%rbp), %eax
jg 0x1a10
cmpl $0x15, -0x14(%rbp)
jg 0x1a10
movl $0x4, -0xc(%rbp)
movl -0x10(%rbp), %eax
sarl $0x12, %eax
andl $0x7, %eax
orl $0xf0, %eax
movb %al, -0x8(%rbp)
movl -0x10(%rbp), %eax
sarl $0xc, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0x7(%rbp)
movl -0x10(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0x6(%rbp)
movl -0x10(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0x5(%rbp)
jmp 0x1a24
movq 0xc671(%rip), %rax      # 0xe088
movq %rax, -0xc(%rbp)
movl 0xc66f(%rip), %eax      # 0xe090
movl %eax, -0x4(%rbp)
jmp 0x1a26
jmp 0x1a28
jmp 0x1a2a
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb -0x20(%rbp), %dl
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/file.c
// Function: allocate_source
struct source *allocate_source(const unsigned char *file) {
  struct source *src = (struct source *) malloc(sizeof(struct source));
  if(src == NULL) {
    perror("malloc");
    exit(1);
  }

  src->fp = fopen(file, "r");
  if(src->fp == NULL) {
    perror("fopen");
    exit(1);
  }

  src->file = file;
  src->row = 1;
  src->col = 1;
  src->trigraph_queue_size = 0;
  src->splice_queue_size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x68, %edi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1a87
leaq 0x85ac(%rip), %rdi      # 0xa024
callq 0x10c0
movl $0x1, %edi
callq 0x10e0
movq -0x10(%rbp), %rdi
leaq 0x8582(%rip), %rsi      # 0xa014
callq 0x10b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1ac1
leaq 0x8579(%rip), %rdi      # 0xa02b
callq 0x10c0
movl $0x1, %edi
callq 0x10e0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/file.c
// Function: fget_utf8c
struct utf8c fget_utf8c(struct source *src) {
  struct utf8c uc;
  uc.sequence[0] = fgetc(src->fp);
  uc.bytes = count_bytes(uc.sequence[0]);

  if(uc.bytes == -1) {
    error("source file \"%s\" contains invalid sequence.\n", src->file);
  }

  if(uc.bytes == 0) {
    return ueof;
  }

  for(int i = 1; i < uc.bytes; i++) {
    uc.sequence[i] = fgetc(src->fp);
  }

  if(!check_sequence(uc)) {
    error("source file \"%s\" contains invalid sequence.\n", src->file);
  }

  uc.sequence[uc.bytes] = '\0';

  return uc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1060
movb %al, -0x20(%rbp)
movzbl -0x20(%rbp), %edi
callq 0x1470
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x1b8f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x84b5(%rip), %rdi      # 0xa031
movl $0x22, %esi
leaq 0x84b0(%rip), %rdx      # 0xa038
movb $0x0, %al
callq 0x1280
cmpl $0x0, -0x24(%rbp)
jne 0x1bae
leaq 0xc4ec(%rip), %rax      # 0xe088
movq (%rax), %rcx
movq %rcx, -0xc(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1c37
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x1bde
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1060
movb %al, %cl
movslq -0x28(%rbp), %rax
movb %cl, -0x20(%rbp,%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1bb5
movq -0x24(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movzbl -0x30(%rbp), %esi
callq 0x15b0
cmpl $0x0, %eax
jne 0x1c20
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x8424(%rip), %rdi      # 0xa031
movl $0x2e, %esi
leaq 0x841f(%rip), %rdx      # 0xa038
movb $0x0, %al
callq 0x1280
movslq -0x24(%rbp), %rax
movb $0x0, -0x20(%rbp,%rax)
movq -0x24(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0xc(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movb -0x40(%rbp), %dl
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/string.c
// Function: allocate_string
struct string *allocate_string() {
  const int INIT_SIZE = 4;

  struct string *str = (struct string *) malloc(sizeof(struct string));
  str->head = (unsigned char *) malloc(sizeof(unsigned char) * (INIT_SIZE + 1));
  str->size = 0;
  str->alloc_size = INIT_SIZE;
  str->head[0] = '\0';

  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4, -0x4(%rbp)
movl $0x10, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
movl $0x5, %edi
callq 0x10a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x4, 0xc(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/string.c
// Function: append_string
void append_string(struct string *str, unsigned char c) {
  if(str->size >= str->alloc_size) {
    int new_size = str->alloc_size * 2;
    unsigned char *t = (unsigned char *) malloc(sizeof(unsigned char) * (new_size + 1));
    for(int i = 0; i < str->size; i++) t[i] = str->head[i];

    free(str->head);

    str->head = t;
    str->alloc_size = new_size;
  }

  str->head[str->size++] = c;
  str->head[str->size] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jl 0x215c
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
shll %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x10a0
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x213b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x210b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movb -0x9(%rbp), %dl
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x8(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x8(%rsi)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/lex.c
// Function: allocate_pp_token_lexer
struct pp_token_lexer *allocate_pp_token_lexer(const unsigned char *file) {
  const int INIT_SIZE = 64;

  struct pp_token_lexer *lexer = (struct pp_token_lexer *) malloc(sizeof(struct pp_token_lexer));
  if(lexer == NULL) {
    perror("malloc");
    exit(1);
  }

  lexer->src = allocate_source(file);
  lexer->comment_queue_size = 0;
  lexer->queue = (struct utf8c *) malloc(sizeof(struct utf8c) * INIT_SIZE);
  lexer->queue_head = 0;
  lexer->queue_size = 0;
  lexer->queue_allocate_size = INIT_SIZE;
  lexer->context = CTX_NL;

  while(1) {
    struct utf8c uc = remove_comment(lexer);
    unsigned char c = uc.sequence[0];
    if(!(c == ' ' || c == '\t' || c == '\v' || c == '\f' || c == '\n')) {
      push_char_queue(lexer, uc);
      break;
    }
  }

  return lexer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x40, -0xc(%rbp)
movl $0x40, %edi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x22ae
leaq 0x7d85(%rip), %rdi      # 0xa024
callq 0x10c0
movl $0x1, %edi
callq 0x10e0
movq -0x8(%rbp), %rdi
callq 0x1a50
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movl $0x300, %edi            # imm = 0x300
callq 0x10a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x18(%rbp), %rax
movl $0x40, 0x38(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x18(%rbp), %rdi
callq 0x2390
movb %dl, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x24(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x1c(%rbp)
movb -0x20(%rbp), %al
movb %al, -0x39(%rbp)
movzbl -0x39(%rbp), %eax
cmpl $0x20, %eax
je 0x237f
movzbl -0x39(%rbp), %eax
cmpl $0x9, %eax
je 0x237f
movzbl -0x39(%rbp), %eax
cmpl $0xb, %eax
je 0x237f
movzbl -0x39(%rbp), %eax
cmpl $0xc, %eax
je 0x237f
movzbl -0x39(%rbp), %eax
cmpl $0xa, %eax
je 0x237f
movq -0x18(%rbp), %rdi
movq -0x24(%rbp), %rax
movq %rax, -0x4c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x4c(%rbp), %rsi
movzbl -0x44(%rbp), %edx
callq 0x26b0
jmp 0x2381
jmp 0x230d
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/lex.c
// Function: push_char_queue
void push_char_queue(struct pp_token_lexer *lexer, struct utf8c uc) {
  if(lexer->queue_size >= lexer->queue_allocate_size) {
    struct utf8c *t = (struct utf8c *) malloc(sizeof(struct utf8c) * lexer->queue_allocate_size * 2);
    if(t == NULL) {
      perror("malloc");
      exit(1);
    }
    for(int i = 0; i < lexer->queue_size; i++) {
      t[i] = lexer->queue[(lexer->queue_head + i) % lexer->queue_allocate_size];
    }
    lexer->queue = t;
    lexer->queue_head = 0;
    lexer->queue_allocate_size *= 2;
  }
  lexer->queue[(lexer->queue_head + lexer->queue_size) % lexer->queue_allocate_size] = uc;
  lexer->queue_size++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rsi, -0x1c(%rbp)
movb %al, -0x14(%rbp)
movq -0x1c(%rbp), %rax
movq %rax, -0xc(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movq %rdi, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x34(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jl 0x27a4
movq -0x28(%rbp), %rax
movslq 0x38(%rax), %rax
imulq $0xc, %rax, %rdi
shlq %rdi
callq 0x10a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x271c
leaq 0x7917(%rip), %rdi      # 0xa024
callq 0x10c0
movl $0x1, %edi
callq 0x10e0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x34(%rcx), %eax
jge 0x2781
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movl 0x30(%rax), %eax
addl -0x34(%rbp), %eax
movq -0x28(%rbp), %rsi
cltd
idivl 0x38(%rsi)
movq -0x40(%rbp), %rax
movslq %edx, %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2723
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x28(%rbp), %rax
movl 0x38(%rax), %ecx
shll %ecx
movl %ecx, 0x38(%rax)
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movl 0x30(%rax), %eax
movq -0x28(%rbp), %rcx
addl 0x34(%rcx), %eax
movq -0x28(%rbp), %rcx
cltd
idivl 0x38(%rcx)
movq -0x48(%rbp), %rax
movslq %edx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq -0xc(%rbp), %rcx
movq %rcx, (%rax)
movl -0x4(%rbp), %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movl 0x34(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/lex.c
// Function: allocate_pp_token
struct pp_token *allocate_pp_token() {
  struct pp_token *token = (struct pp_token *) malloc(sizeof(struct pp_token));
  if(token == NULL) {
    perror("malloc");
    exit(1);
  }
  token->text = allocate_string();
  return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2833
leaq 0x7800(%rip), %rdi      # 0xa024
callq 0x10c0
movl $0x1, %edi
callq 0x10e0
movb $0x0, %al
callq 0x2060
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/lex.c
// Function: pop_char_queue
struct utf8c pop_char_queue(struct pp_token_lexer *lexer) {
  if(lexer->queue_size == 0) {
    error("internal: lexer character queue is empty\n");
  }

  struct utf8c uc = lexer->queue[lexer->queue_head];
  lexer->queue_head++;
  lexer->queue_head %= lexer->queue_allocate_size;
  lexer->queue_size--;
  return uc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x28f0
leaq 0x7fd3(%rip), %rdi      # 0xa8b0
movl $0x9f, %esi
leaq 0x803b(%rip), %rdx      # 0xa924
movb $0x0, %al
callq 0x1280
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
movslq 0x30(%rcx), %rcx
leaq (%rcx,%rcx,2), %rcx
movl 0x8(%rax,%rcx,4), %edx
movl %edx, -0x8(%rbp)
movq (%rax,%rcx,4), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl 0x30(%rax), %ecx
incl %ecx
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl 0x30(%rcx), %eax
movl 0x38(%rcx), %ecx
cltd
idivl %ecx
movq -0x30(%rbp), %rax
movl %edx, 0x30(%rax)
movq -0x18(%rbp), %rax
movl 0x34(%rax), %ecx
decl %ecx
movl %ecx, 0x34(%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb -0x20(%rbp), %dl
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/lex.c
// Function: one_of
int one_of(char c, char *s) {
  for(int i = 0; s[i] != '\0'; i++) {
    if(c == s[i]) {
      return 1;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x29b0
movsbl -0x5(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x29a3
movl $0x1, -0x4(%rbp)
jmp 0x29b7
jmp 0x29a5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2975
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/lex.c
// Function: non_digit
int non_digit(unsigned char c) {
  if('A' <= c && c <= 'Z') return 1;
  if('a' <= c && c <= 'z') return 1;
  if(c == '_') return 1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x29e9
movzbl -0x5(%rbp), %eax
cmpl $0x5a, %eax
jg 0x29e9
movl $0x1, -0x4(%rbp)
jmp 0x2a21
movzbl -0x5(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x2a08
movzbl -0x5(%rbp), %eax
cmpl $0x7a, %eax
jg 0x2a08
movl $0x1, -0x4(%rbp)
jmp 0x2a21
movzbl -0x5(%rbp), %eax
cmpl $0x5f, %eax
jne 0x2a1a
movl $0x1, -0x4(%rbp)
jmp 0x2a21
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/lex.c
// Function: hex_digit
int hex_digit(unsigned char c) {
  if(digit(c)) return 1;
  if('A' <= c && c <= 'F') return 1;
  if('a' <= c && c <= 'f') return 1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %edi
callq 0x2a30
cmpl $0x0, %eax
je 0x2a95
movl $0x1, -0x4(%rbp)
jmp 0x2ada
movzbl -0x5(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0x2ab4
movzbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x2ab4
movl $0x1, -0x4(%rbp)
jmp 0x2ada
movzbl -0x5(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0x2ad3
movzbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x2ad3
movl $0x1, -0x4(%rbp)
jmp 0x2ada
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/lex.c
// Function: ident_disallowed_init_code
int ident_disallowed_init_code(int code) {
  if(0x300 <= code && code <= 0x36F) return 1;
  if(0x1DC0 <= code && code <= 0x1DFF) return 1;
  if(0x20D0 <= code && code <= 0x20FF) return 1;
  if(0xFE20 <= code && code <= 0xFE2F) return 1;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x300, %eax            # imm = 0x300
cmpl -0x8(%rbp), %eax
jg 0x30a3
cmpl $0x36f, -0x8(%rbp)      # imm = 0x36F
jg 0x30a3
movl $0x1, -0x4(%rbp)
jmp 0x30fe
movl $0x1dc0, %eax           # imm = 0x1DC0
cmpl -0x8(%rbp), %eax
jg 0x30bf
cmpl $0x1dff, -0x8(%rbp)     # imm = 0x1DFF
jg 0x30bf
movl $0x1, -0x4(%rbp)
jmp 0x30fe
movl $0x20d0, %eax           # imm = 0x20D0
cmpl -0x8(%rbp), %eax
jg 0x30db
cmpl $0x20ff, -0x8(%rbp)     # imm = 0x20FF
jg 0x30db
movl $0x1, -0x4(%rbp)
jmp 0x30fe
movl $0xfe20, %eax           # imm = 0xFE20
cmpl -0x8(%rbp), %eax
jg 0x30f7
cmpl $0xfe2f, -0x8(%rbp)     # imm = 0xFE2F
jg 0x30f7
movl $0x1, -0x4(%rbp)
jmp 0x30fe
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: allocate_pp_list
struct pp_list *allocate_pp_list() {
  struct pp_list *list = (struct pp_list *) malloc(sizeof(struct pp_list));
  if(list == NULL) {
    perror("malloc");
    exit(1);
  }
  list->head = NULL;
  list->tail = &(list->head);
  return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x53e3
leaq 0x4c50(%rip), %rdi      # 0xa024
callq 0x10c0
movl $0x1, %edi
callq 0x10e0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: free_pp_list
void free_pp_list(struct pp_list *list) {
  struct pp_node *node = list->head;
  while(node != NULL) {
    struct pp_node *next = node->next;
    free(node);
    node = next;
  }
  free(list);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x544d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x5427
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: append_pp_list
void append_pp_list(struct pp_list *list, struct pp_token *token) {
  struct pp_node *node = (struct pp_node *) malloc(sizeof(struct pp_node));
  node->token = token;
  node->next = NULL;
  node->skip = 0;
  *(list->tail) = node;
  list->tail = &(node->next);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x10a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: allocate_macro_entry
struct macro_entry *allocate_macro_entry() {
  struct macro_entry *macro = (struct macro_entry *) malloc(sizeof(struct macro_entry));
  if(macro == NULL) {
    perror("malloc");
    exit(1);
  }
  macro->replacement_list = allocate_pp_list();
  macro->expanded = 0;
  return macro;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x428, %edi            # imm = 0x428
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5543
leaq 0x4af0(%rip), %rdi      # 0xa024
callq 0x10c0
movl $0x1, %edi
callq 0x10e0
callq 0x53b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x418(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x420(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: ident_hash
int ident_hash(const unsigned char *ident) {
  const int BASE = 257;
  int h = 0;
  for(int i = 0; ident[i] != '\0'; i++) {
    h = (h * BASE + ident[i]) % MACRO_TABLE_SIZE;
  }
  return h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x101, -0xc(%rbp)      # imm = 0x101
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x55f9
imull $0x101, -0x10(%rbp), %eax # imm = 0x101
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0xa001, %ecx           # imm = 0xA001
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55bd
movl -0x10(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: compare_macro
int compare_macro(const struct macro_entry *macro1, const struct macro_entry *macro2) {
  if(macro1->type != macro2->type) {
    return 0;
  }

  if(macro1->type == MACRO_FUNCTION) {
    if(macro1->parameter_ellipsis != macro2->parameter_ellipsis) return 0;
    if(macro1->parameter_size != macro2->parameter_size) return 0;
    for(int i = 0; i < macro1->parameter_size; i++) {
      if(strcmp(macro1->parameters[i]->head, macro2->parameters[i]->head) != 0) return 0;
    }
  }

  struct pp_node *node1 = macro1->replacement_list->head;
  struct pp_node *node2 = macro2->replacement_list->head;
  while(1) {
    if(node1 == NULL || node2 == NULL) {
      if(node1 == NULL && node2 == NULL) break;
      return 0;
    }
    if(node1->token->type != node2->token->type) return 0;
    if(strcmp(node1->token->text->head, node2->token->text->head) != 0) return 0;
    node1 = node1->next;
    node2 = node2->next;
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0x562a
movl $0x0, -0x4(%rbp)
jmp 0x5782
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x56c7
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x14(%rcx), %eax
je 0x5653
movl $0x0, -0x4(%rbp)
jmp 0x5782
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
je 0x566f
movl $0x0, -0x4(%rbp)
jmp 0x5782
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x56c5
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
je 0x56b8
movl $0x0, -0x4(%rbp)
jmp 0x5782
jmp 0x56ba
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5676
jmp 0x56c7
movq -0x10(%rbp), %rax
movq 0x418(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x418(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x56f9
cmpq $0x0, -0x30(%rbp)
jne 0x5712
cmpq $0x0, -0x28(%rbp)
jne 0x5709
cmpq $0x0, -0x30(%rbp)
jne 0x5709
jmp 0x577b
movl $0x0, -0x4(%rbp)
jmp 0x5782
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0x572f
movl $0x0, -0x4(%rbp)
jmp 0x5782
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
je 0x575e
movl $0x0, -0x4(%rbp)
jmp 0x5782
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x56eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: insert_macro_table
void insert_macro_table(struct macro_entry *macro) {
  int h1 = ident_hash(macro->identifier);
  for(int i = 0, h = h1; i < MACRO_TABLE_SIZE; i++, h = (h + 1) % MACRO_TABLE_SIZE) {
    if(macro_table[h] == NULL) {
      macro_table[h] = macro;
      break;
    } else {
      if(strcmp(macro_table[h]->identifier, macro->identifier) == 0) {
        if(compare_macro(macro_table[h], macro)) {
          break;
        } else {
          error("duplicated macro definition: %s\n", macro->identifier);
        }
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x55a0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0xa001, -0x10(%rbp)    # imm = 0xA001
jge 0x587b
movslq -0x14(%rbp), %rcx
leaq 0x88df(%rip), %rax      # 0xe0b0
cmpq $0x0, (%rax,%rcx,8)
jne 0x57f0
movq -0x8(%rbp), %rdx
movslq -0x14(%rbp), %rcx
leaq 0x88c9(%rip), %rax      # 0xe0b0
movq %rdx, (%rax,%rcx,8)
jmp 0x587b
movslq -0x14(%rbp), %rcx
leaq 0x88b5(%rip), %rax      # 0xe0b0
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0x5858
movslq -0x14(%rbp), %rcx
leaq 0x8890(%rip), %rax      # 0xe0b0
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
callq 0x5600
cmpl $0x0, %eax
je 0x5834
jmp 0x587b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x517c(%rip), %rdi      # 0xa9bf
movl $0x75, %esi
leaq 0x517d(%rip), %rdx      # 0xa9cc
movb $0x0, %al
callq 0x1280
jmp 0x5858
jmp 0x585a
jmp 0x585c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0xa001, %ecx           # imm = 0xA001
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
jmp 0x57b9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: delete_macro_table
void delete_macro_table(const unsigned char *identifier) {
  int h1 = ident_hash(identifier);
  for(int i = 0, h = h1; i < MACRO_TABLE_SIZE; i++, h = (h + 1) % MACRO_TABLE_SIZE) {
    if(macro_table[h] == NULL) break;
    if(strcmp(macro_table[h]->identifier, identifier) == 0) {
      macro_table[h] = NULL;
      h = (h + 1) % MACRO_TABLE_SIZE;
      for(int j = i; j < MACRO_TABLE_SIZE; j++, h = (h + 1) % MACRO_TABLE_SIZE) {
        if(macro_table[h] == NULL) break;
        struct macro_entry *t = macro_table[h];
        macro_table[h] = NULL;
        insert_macro_table(t);
      }
      break;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x55a0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0xa001, -0x10(%rbp)    # imm = 0xA001
jge 0x59b3
movslq -0x14(%rbp), %rcx
leaq 0x87e3(%rip), %rax      # 0xe0b0
cmpq $0x0, (%rax,%rcx,8)
jne 0x58d9
jmp 0x59b3
movslq -0x14(%rbp), %rcx
leaq 0x87cc(%rip), %rax      # 0xe0b0
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0x5992
movslq -0x14(%rbp), %rcx
leaq 0x87a7(%rip), %rax      # 0xe0b0
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0xa001, %ecx           # imm = 0xA001
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0xa001, -0x18(%rbp)    # imm = 0xA001
jge 0x5990
movslq -0x14(%rbp), %rcx
leaq 0x8774(%rip), %rax      # 0xe0b0
cmpq $0x0, (%rax,%rcx,8)
jne 0x5945
jmp 0x5990
movslq -0x14(%rbp), %rcx
leaq 0x8760(%rip), %rax      # 0xe0b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x874d(%rip), %rax      # 0xe0b0
movq $0x0, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
callq 0x5790
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0xa001, %ecx           # imm = 0xA001
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
jmp 0x5928
jmp 0x59b3
jmp 0x5994
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl $0xa001, %ecx           # imm = 0xA001
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
jmp 0x58b5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: search_macro_table
struct macro_entry *search_macro_table(const unsigned char *identifier) {
  int h1 = ident_hash(identifier);
  for(int i = 0, h = h1; i < MACRO_TABLE_SIZE; i++, h = (h + 1) % MACRO_TABLE_SIZE) {
    if(macro_table[h] == NULL) break;
    if(strcmp(macro_table[h]->identifier, identifier) == 0) {
      return macro_table[h];
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x55a0
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0xa001, -0x18(%rbp)    # imm = 0xA001
jge 0x5a56
movslq -0x1c(%rbp), %rcx
leaq 0x86b7(%rip), %rax      # 0xe0b0
cmpq $0x0, (%rax,%rcx,8)
jne 0x5a02
jmp 0x5a56
movslq -0x1c(%rbp), %rcx
leaq 0x86a3(%rip), %rax      # 0xe0b0
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1070
cmpl $0x0, %eax
jne 0x5a38
movslq -0x1c(%rbp), %rcx
leaq 0x8682(%rip), %rax      # 0xe0b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x5a5e
jmp 0x5a3a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl $0xa001, %ecx           # imm = 0xA001
cltd
idivl %ecx
movl %edx, -0x1c(%rbp)
jmp 0x59e5
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: check_object_macro_invocation
int check_object_macro_invocation(struct preprocessor *pp, struct pp_node *node) {
  if(node->token->type != PP_IDENT) return 0;
  if(node->skip) return 0;

  struct macro_entry *macro = search_macro_table(node->token->text->head);
  return macro != NULL && !macro->expanded && macro->type == MACRO_OBJECT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
je 0x5a95
movl $0x0, -0x4(%rbp)
jmp 0x5af5
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x5aa8
movl $0x0, -0x4(%rbp)
jmp 0x5af5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x59c0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x21(%rbp)
je 0x5aea
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0x420(%rcx)
movb %al, -0x21(%rbp)
jne 0x5aea
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: check_function_macro_invocation
int check_function_macro_invocation(struct preprocessor *pp, struct pp_node *node) {
  if(node->token->type != PP_IDENT) return 0;
  if(node->skip) return 0;

  struct macro_entry *macro = search_macro_table(node->token->text->head);
  if(macro == NULL || macro->expanded || macro->type != MACRO_FUNCTION) {
    return 0;
  }

  struct pp_node *current = node->next;
  if(current == NULL) {
    return 0;
  }
  if(current->token->type == PP_NEW_LINE || current->token->type == PP_SPACE) {
    current = current->next;
    if(current == NULL) return 0;
  }
  if(current->token->type != PP_LPAREN) return 0;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
je 0x5b28
movl $0x0, -0x4(%rbp)
jmp 0x5be9
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x5b3e
movl $0x0, -0x4(%rbp)
jmp 0x5be9
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x59c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5b72
movq -0x20(%rbp), %rax
cmpl $0x0, 0x420(%rax)
jne 0x5b72
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x5b7b
movl $0x0, -0x4(%rbp)
jmp 0x5be9
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5b97
movl $0x0, -0x4(%rbp)
jmp 0x5be9
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpl $0x3b, (%rax)
je 0x5baf
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpl $0x3c, (%rax)
jne 0x5bcd
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5bcb
movl $0x0, -0x4(%rbp)
jmp 0x5be9
jmp 0x5bcd
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpl $0x7, (%rax)
je 0x5be2
movl $0x0, -0x4(%rbp)
jmp 0x5be9
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: object_macro_invocation
struct pp_list *object_macro_invocation(struct preprocessor *pp, struct macro_entry *macro) {
  macro->expanded = 1;

  struct pp_list *list = allocate_pp_list();
  for(struct pp_node *node = macro->replacement_list->head; node != NULL; node = node->next) {
    append_pp_list(list, node->token);
  }

  struct pp_list *concat_list = concat_macro_token(list);
  struct pp_list *result = scan_macro(pp, concat_list);

  macro->expanded = 0;
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x420(%rax)
callq 0x53b0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x418(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x619e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x5460
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x6179
movq -0x18(%rbp), %rdi
callq 0x69e0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x5c00
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x420(%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: conditional_expression
int conditional_expression(struct pp_node **node) {
  int result = logical_or_expression(node);
  if((*node) && (*node)->token->type == PP_QUESTION) {
    *node = (*node)->next;
    int left = conditional_expression(node);
    *node = (*node)->next;
    int right = conditional_expression(node);
    result = result ? left : right;
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7b30
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x73a7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x35, (%rax)
jne 0x73a7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x7320
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 0x7320
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x739b
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x73a1
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: unary_expression
int unary_expression(struct pp_node **node) {
  if((*node)->token->type == PP_PLUS) {
    *node = (*node)->next;
    return +primary_expression(node);
  } else if((*node)->token->type == PP_MINUS) {
    *node = (*node)->next;
    return -primary_expression(node);
  } else if((*node)->token->type == PP_TILDE) {
    *node = (*node)->next;
    return ~primary_expression(node);
  } else if((*node)->token->type == PP_NOT) {
    *node = (*node)->next;
    return !primary_expression(node);
  }
  return primary_expression(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0xe, (%rax)
jne 0x73ee
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6fe0
movl %eax, -0x4(%rbp)
jmp 0x74a6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x11, (%rax)
jne 0x7426
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6fe0
movl %eax, %ecx
xorl %eax, %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x74a6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x34, (%rax)
jne 0x7458
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6fe0
xorl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x74a6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x28, (%rax)
jne 0x7494
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x6fe0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x74a6
jmp 0x7496
jmp 0x7498
jmp 0x749a
movq -0x10(%rbp), %rdi
callq 0x6fe0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ShinyaKato[P]skcc/preprocess.c
// Function: multiplicative_expression
int multiplicative_expression(struct pp_node **node) {
  int result = unary_expression(node);
  while((*node) && ((*node)->token->type == PP_MUL || (*node)->token->type == PP_DIV || (*node)->token->type == PP_MOD)) {
    enum pp_token_type type = (*node)->token->type;
    *node = (*node)->next;
    int value = unary_expression(node);
    if(type == PP_MUL) {
      result = result * value;
    } else if(type == PP_DIV) {
      result = result / value;
    } else if(type == PP_MOD) {
      result = result % value;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x73b0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x15(%rbp)
je 0x7518
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x15, (%rcx)
movb %al, -0x16(%rbp)
je 0x7512
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x17, (%rcx)
movb %al, -0x16(%rbp)
je 0x7512
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x19, (%rax)
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x7521
jmp 0x758b
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 0x73b0
movl %eax, -0x14(%rbp)
cmpl $0x15, -0x10(%rbp)
jne 0x7560
movl -0xc(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x7586
cmpl $0x17, -0x10(%rbp)
jne 0x7572
movl -0xc(%rbp), %eax
cltd
idivl -0x14(%rbp)
movl %eax, -0xc(%rbp)
jmp 0x7584
cmpl $0x19, -0x10(%rbp)
jne 0x7582
movl -0xc(%rbp), %eax
cltd
idivl -0x14(%rbp)
movl %edx, -0xc(%rbp)
jmp 0x7584
jmp 0x7586
jmp 0x74c8
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: additive_expression
int additive_expression(struct pp_node **node) {
  int result = multiplicative_expression(node);
  while((*node) && ((*node)->token->type == PP_PLUS || (*node)->token->type == PP_MINUS)) {
    enum pp_token_type type = (*node)->token->type;
    *node = (*node)->next;
    int value = multiplicative_expression(node);
    if(type == PP_PLUS) {
      result = result + value;
    } else if(value == PP_MINUS) {
      result = result - value;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x74b0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x15(%rbp)
je 0x75f4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0xe, (%rcx)
movb %al, -0x16(%rbp)
je 0x75ee
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x11, (%rax)
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x75fd
jmp 0x7651
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 0x74b0
movl %eax, -0x14(%rbp)
cmpl $0xe, -0x10(%rbp)
jne 0x763b
movl -0xc(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x764c
cmpl $0x11, -0x14(%rbp)
jne 0x764a
movl -0xc(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x764c
jmp 0x75b8
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: shift_expression
int shift_expression(struct pp_node **node) {
  int result = additive_expression(node);
  while((*node) && ((*node)->token->type == PP_LSHIFT || (*node)->token->type == PP_RSHIFT)) {
    enum pp_token_type type = (*node)->token->type;
    *node = (*node)->next;
    int value = additive_expression(node);
    if(type == PP_LSHIFT) {
      result = result << value;
    } else if(type == PP_RSHIFT) {
      result = result >> value;
    }
  }
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x75a0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x15(%rbp)
je 0x76b4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpl $0x2b, (%rcx)
movb %al, -0x16(%rbp)
je 0x76ae
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x31, (%rax)
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x76bd
jmp 0x7715
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 0x75a0
movl %eax, -0x14(%rbp)
cmpl $0x2b, -0x10(%rbp)
jne 0x76fd
movl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
shll %cl, %eax
movl %eax, -0xc(%rbp)
jmp 0x7710
cmpl $0x31, -0x10(%rbp)
jne 0x770e
movl -0xc(%rbp), %eax
movl -0x14(%rbp), %ecx
sarl %cl, %eax
movl %eax, -0xc(%rbp)
jmp 0x7710
jmp 0x7678
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop