LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: tokenize_keyword
Keyword *tokenize_keyword(char *p) {
  for (int i = 0; i < sizeof(keywords) / sizeof(Keyword); i++) {
    Keyword *k = &keywords[i];
    int len = strlen(k->keyword);
    if (strncmp(p, k->keyword, len) == 0 && !is_alnum(p[len])) {
      return k;
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x19, %rax
jae 0xcb37
movslq -0x14(%rbp), %rcx
leaq 0x86f8(%rip), %rax      # 0x151d0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2090
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movslq -0x24(%rbp), %rdx
callq 0x2060
cmpl $0x0, %eax
jne 0xcb2a
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0xc990
testb $0x1, %al
jne 0xcb2a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcb3f
jmp 0xcb2c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcac3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: is_multi_char_operator
int is_multi_char_operator(char *p) {
  for (char **op = multi_char_ope; *op; op++) {
    if (starts_with(p, *op)) {
      return strlen(*op);
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x87fd(%rip), %rax      # 0x15360
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xcba8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0xca60
testb $0x1, %al
jne 0xcb87
jmp 0xcb98
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2090
movl %eax, -0x4(%rbp)
jmp 0xcbaf
jmp 0xcb9a
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0xcb67
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: tokenize_string_literal
static Token *tokenize_string_literal(Token *current_token, char **current_pointer) {
  string_buffer *sb = sb_init();
  char *p = *current_pointer;

  char *s = p++;
  while (*p && (*p != '"')) {
    if (*p == '\\') {
      p++;
      sb_append_char(sb, parse_escaped(*p));
    } else {
      sb_append_char(sb, *p);
    }
    p++;
  }
  if (!(*p)) {
    error_at(s, "文字列が終了していません。");
  }
  // *p がここで閉じる " を指してるので一つすすめる
  p++;

  Token *tok = new_token(TK_STR, current_token, s, p - s);
  sb_append_char(sb, '\0');
  tok->contents = my_strndup(sb_str(sb), sb_str_len(sb));
  // \0まで含めた長さ
  tok->content_length = sb_str_len(sb);

  sb_free(sb);

  *current_pointer = p;

  return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0xc100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xd01a
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xd023
jmp 0xd07d
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0xd05c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xd480
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0xc160
jmp 0xd06c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movsbl (%rax), %esi
callq 0xc160
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xcff9
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xd098
movq -0x28(%rbp), %rdi
leaq 0x3e9d(%rip), %rsi      # 0x10f2e
movb $0x0, %al
callq 0x6370
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movl %eax, %ecx
movl $0x14, %edi
callq 0xc5e0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xc160
movq -0x18(%rbp), %rdi
callq 0xc220
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc240
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x6690
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
callq 0xc240
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x18(%rbp), %rdi
callq 0xc1d0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: tokenize_char_literal
static Token *tokenize_char_literal(Token *current_token, char **current_pointer) {
  int val;
  char *p = *current_pointer;

  // この関数に入ってきた時点でpは開き"'"を指しているので、中身を見るために一つすすめる
  // sは開始位置の保存用
  char *s = p++;

  if (*p == '\\') {
    p++;
    val = parse_escaped(*p);
  } else {
    val = *p;
  }
  char *tmp = p++;
  if (!(*p)) {
    error_at(tmp, "文字が終了していません。");
  }

  // ここでpが閉じる側の"'"を指していなければエラー
  if (*p != '\'') {
    error_at(p, "\"'\" が閉じられていません。");
  }

  // この時点でpが"'"を指しているので、その次の位置でcurrent_pointerを更新
  p++;
  *current_pointer = p;

  Token *tk = new_token(TK_NUM, current_token, s, 0);
  tk->val = val;

  return tk;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0xd187
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xd480
movl %eax, -0x14(%rbp)
jmp 0xd191
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xd1bf
movq -0x30(%rbp), %rdi
leaq 0x3d9e(%rip), %rsi      # 0x10f56
movb $0x0, %al
callq 0x6370
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
je 0xd1dd
movq -0x20(%rbp), %rdi
leaq 0x3da5(%rip), %rsi      # 0x10f7b
movb $0x0, %al
callq 0x6370
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x3, %edi
xorl %ecx, %ecx
callq 0xc5e0
movq %rax, -0x38(%rbp)
movslq -0x14(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: tokenize_number
static Token *tokenize_number(Token *cur, char **cur_pos) {
  Token *tok = NULL;

  if (starts_with(*cur_pos, "0x")) {
    // 16進数
    tok = tokenize_hex_number(cur, cur_pos);
  } else if (starts_with(*cur_pos, "0b")) {
    // 2進数
    tok = tokenize_binary_number(cur, cur_pos);
  } else if (starts_with_octal(*cur_pos)) {
    // 8進数
    tok = tokenize_octal_number(cur, cur_pos);
  } else {
    // 10進数
    tok = new_token(TK_NUM, cur, *cur_pos, 0);
    tok->val = strtol(*cur_pos, cur_pos, 10);
  }

  return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d4b(%rip), %rsi      # 0x10fa1
callq 0xca60
testb $0x1, %al
jne 0xd261
jmp 0xd277
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd510
movq %rax, -0x18(%rbp)
jmp 0xd307
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x3d1f(%rip), %rsi      # 0x10fa4
callq 0xca60
testb $0x1, %al
jne 0xd290
jmp 0xd2a3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd5f0
movq %rax, -0x18(%rbp)
jmp 0xd305
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xd6d0
testb $0x1, %al
jne 0xd2b5
jmp 0xd2c8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd730
movq %rax, -0x18(%rbp)
jmp 0xd303
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x3, %edi
xorl %ecx, %ecx
callq 0xc5e0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x2120
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xd305
jmp 0xd307
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: read_file
char *read_file(char *path) {
  FILE *fp = fopen(path, "r");
  if (!fp) {
    error("cannot open %s: %s", path, strerror(errno));
  }

  // ファイルの最後の位置を調べてサイズ計算
  if (fseek(fp, 0, SEEK_END) == -1) {
    error("%s: fseek: %s", path, strerror(errno));
  }
  long file_size = ftell(fp);

  // 読むために先頭に戻す
  if (fseek(fp, 0, SEEK_SET) == -1) {
    error("%s: fseek: %s", path, strerror(errno));
  }

  // \n\0で終わらせるための2バイト追加で確保
  char *buf = calloc(1, file_size + 2);
  fread(buf, file_size, 1, fp);


  if (file_size == 0 || buf[file_size - 1] != '\n') {
    buf[file_size++] = '\n';
  }
  buf[file_size] = '\0';
  fclose(fp);

  return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2f35(%rip), %rsi      # 0x1026c
callq 0x2170
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xd370
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x21b0
movq -0x28(%rbp), %rsi
movq %rax, %rdx
leaq 0x3b30(%rip), %rdi      # 0x10e99
movb $0x0, %al
callq 0x65d0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x2150
cmpl $-0x1, %eax
jne 0xd3b0
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x21b0
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq 0x3b03(%rip), %rdi      # 0x10eac
movb $0x0, %al
callq 0x65d0
movq -0x10(%rbp), %rdi
callq 0x2110
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2150
cmpl $-0x1, %eax
jne 0xd3fa
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x21b0
movq -0x38(%rbp), %rsi
movq %rax, %rdx
leaq 0x3ab9(%rip), %rdi      # 0x10eac
movb $0x0, %al
callq 0x65d0
movq -0x18(%rbp), %rsi
addq $0x2, %rsi
movl $0x1, %edi
callq 0x20e0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x2070
cmpq $0x0, -0x18(%rbp)
je 0xd442
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0xd459
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0xa, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rdi
callq 0x2080
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: parse_escaped
static int parse_escaped(int ch) {
  switch(ch) {
    case '0':
      return 0;
    case 'n':
      return '\n';
    case 't':
      return '\t';
    case '\\':
      return '\\';
    case '"':
      return '"';
    case '\'':
      return '\'';
    default:
      return ch;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x22, %eax
je 0xd4ea
jmp 0xd494
movl -0xc(%rbp), %eax
subl $0x27, %eax
je 0xd4f3
jmp 0xd49e
movl -0xc(%rbp), %eax
subl $0x30, %eax
je 0xd4c6
jmp 0xd4a8
movl -0xc(%rbp), %eax
subl $0x5c, %eax
je 0xd4e1
jmp 0xd4b2
movl -0xc(%rbp), %eax
subl $0x6e, %eax
je 0xd4cf
jmp 0xd4bc
movl -0xc(%rbp), %eax
subl $0x74, %eax
je 0xd4d8
jmp 0xd4fc
movl $0x0, -0x4(%rbp)
jmp 0xd502
movl $0xa, -0x4(%rbp)
jmp 0xd502
movl $0x9, -0x4(%rbp)
jmp 0xd502
movl $0x5c, -0x4(%rbp)
jmp 0xd502
movl $0x22, -0x4(%rbp)
jmp 0xd502
movl $0x27, -0x4(%rbp)
jmp 0xd502
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: tokenize_hex_number
static Token *tokenize_hex_number(Token *cur, char **cur_pos) {
  long val = 0;
  char *p = *cur_pos;

  // "0x" (2文字分)を読み飛ばす
  p += 2;
  while (p && is_hex_digit(*p)) {
    val = (val << 4) + hex_val(*p);
    p++;
  }

  if (!p) {
    error_at(p, "数値が不正です");
  }

  Token *tok = new_token(TK_NUM, cur, *cur_pos, 0);
  tok->val = val;

  *cur_pos = p;

  return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0xd55a
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xd810
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xd563
jmp 0xd599
movq -0x18(%rbp), %rax
shlq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xd880
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd53f
cmpq $0x0, -0x20(%rbp)
jne 0xd5b2
movq -0x20(%rbp), %rdi
leaq 0x39fc(%rip), %rsi      # 0x10fa7
movb $0x0, %al
callq 0x6370
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x3, %edi
xorl %ecx, %ecx
callq 0xc5e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: tokenize_binary_number
static Token *tokenize_binary_number(Token *cur, char **cur_pos) {
  long val = 0;
  char *p = *cur_pos;

  // "0b" (2文字分)を読み飛ばす
  p += 2;
  while (p && is_binary_digit(*p)) {
    val = (val << 1) + binary_val(*p);
    p++;
  }

  if (!p) {
    error_at(p, "数値が不正です");
  }

  Token *tok = new_token(TK_NUM, cur, *cur_pos, 0);
  tok->val = val;

  *cur_pos = p;

  return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0xd63a
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xd8f0
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xd643
jmp 0xd678
movq -0x18(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xd920
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd61f
cmpq $0x0, -0x20(%rbp)
jne 0xd691
movq -0x20(%rbp), %rdi
leaq 0x391d(%rip), %rsi      # 0x10fa7
movb $0x0, %al
callq 0x6370
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x3, %edi
xorl %ecx, %ecx
callq 0xc5e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: starts_with_octal
static bool starts_with_octal(char *p) {
  // 前提として*pは何らかの数値というところまでわかっている
  if (*p++ != '0') {
    // 先頭が0出ない場合は8進数でない
    return false;
  }
  if (isdigit(*p)) {
    // 先頭の0につづいてまだなにかの数字があれば8進数とみなす
    return true;
  }
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
cmpl $0x30, %eax
je 0xd6f9
movb $0x0, -0x1(%rbp)
jmp 0xd723
callq 0x21d0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xd71f
movb $0x1, -0x1(%rbp)
jmp 0xd723
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: tokenize_octal_number
static Token *tokenize_octal_number(Token *cur, char **cur_pos) {
  long val = 0;
  char *p = *cur_pos;

  // "0" (1文字分)を読み飛ばす
  p += 1;
  while (p && is_octal_digit(*p)) {
    val = (val << 3) + octal_val(*p);
    p++;
  }

  if (!p) {
    error_at(p, "数値が不正です");
  }

  Token *tok = new_token(TK_NUM, cur, *cur_pos, 0);
  tok->val = val;

  *cur_pos = p;

  return tok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0xd77a
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xd940
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xd783
jmp 0xd7b9
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0xd970
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd75f
cmpq $0x0, -0x20(%rbp)
jne 0xd7d2
movq -0x20(%rbp), %rdi
leaq 0x37dc(%rip), %rsi      # 0x10fa7
movb $0x0, %al
callq 0x6370
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x3, %edi
xorl %ecx, %ecx
callq 0xc5e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: is_hex_digit
static bool is_hex_digit(char c) {
  return
    ('a' <= c && c <= 'f') ||
    ('A' <= c && c <= 'F') ||
    ('0' <= c && c <= '9');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0xd835
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x66, %ecx
movb %al, -0x2(%rbp)
jle 0xd875
movsbl -0x1(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0xd850
movsbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x46, %ecx
movb %al, -0x2(%rbp)
jle 0xd875
movsbl -0x1(%rbp), %edx
xorl %eax, %eax
movl $0x30, %ecx
cmpl %edx, %ecx
movb %al, -0x3(%rbp)
jg 0xd86f
movsbl -0x1(%rbp), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x3(%rbp)
movb -0x3(%rbp), %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/tokenize.c
// Function: hex_val
static int hex_val(char c) {
  if ('a' <= c && c <= 'f') {
    return c - 'a' + 10;
  } else if ('A' <= c && c <= 'F') {
    return c - 'A' + 10;
  }
  return c - '0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %ecx
movl $0x61, %eax
cmpl %ecx, %eax
jg 0xd8af
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0xd8af
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0xd8e0
movsbl -0x5(%rbp), %ecx
movl $0x41, %eax
cmpl %ecx, %eax
jg 0xd8d4
movsbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0xd8d4
movsbl -0x5(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0xd8e0
jmp 0xd8d6
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/type.c
// Function: new_type
static Type *new_type(TypeKind kind, int size, int align) {
  Type *t = calloc(1, sizeof(Type));
  t->kind = kind;
  t->size = size;
  t->align = align;

  return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x20e0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/type.c
// Function: array_of
Type *array_of(Type *ptr_to, int array_size) {
  Type *ty = new_type(TY_ARRAY, ptr_to->size * array_size, ptr_to->align);
  ty->ptr_to = ptr_to;
  ty->array_size = array_size;
  return ty;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
imull -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
movl $0x8, %edi
callq 0xd9d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pocari[P]compilerbook-9cc/type.c
// Function: struct_type
Type *struct_type(void) {
  // 一旦サイズゼロ、アラインメント1バイトで作成
  // 実際には構造体のメンバーのパース時に、メンバー中で一番大きいアラインメントで上書きされる。
  Type *type = new_type(TY_STRUCT, 0, 1);
  type->is_incomplete = true;
  return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x9, %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0xd9d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0xc(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_06/binio.c
// Function: main
int main(void)
{
	FILE *fp;
	int outdata[4] = { 10, -3, 200, 0 };
	int indata[4];
	int n;

	/* Open a file for writing */
	fp = fopen("file.txt", "w");
	if (!fp) {
		perror("fopen");
		return -1;
	}

	/* Try to write data to file */
	n = fwrite(outdata, sizeof(int), 4, fp);
	if (n < 4) {
		fprintf(stderr, "cannot fwrite\n");
		return -1;
	}
	printf("written %d, %d, %d, %d\n",
		outdata[0], outdata[1],
		outdata[2], outdata[3]);

	/* Writing done */
	fclose(fp);

	/* Open a file for reading */
	fp = fopen("file.txt", "r");
	if (!fp) {
		perror("fopen");
		return -1;
	}

	/* Try to read data from file */
	n = fread(indata, sizeof(int), 4, fp);
	if (n < 4) {
		if (ferror(fp))
			fprintf(stderr, "cannot fread\n");
		if (feof(fp))
			fprintf(stderr, "too few data to read\n");
		return -1;
	}
	printf("read %d, %d, %d, %d\n",
		indata[0], indata[1],
		indata[2], indata[3]);

	/* Reading done */
	fclose(fp);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movq 0xe3a(%rip), %rax       # 0x2010
movq %rax, -0x20(%rbp)
movq 0xe37(%rip), %rax       # 0x2018
movq %rax, -0x18(%rbp)
leaq 0xe34(%rip), %rdi       # 0x2020
leaq 0xe36(%rip), %rsi       # 0x2029
callq 0x1090
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x121b
leaq 0xe21(%rip), %rdi       # 0x202b
callq 0x10a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1355
leaq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %edx
movq %rdx, %rsi
callq 0x10b0
movl %eax, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jge 0x125d
movq 0x2db8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xde7(%rip), %rsi       # 0x2031
movb $0x0, %al
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1355
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xdcf(%rip), %rdi       # 0x2040
movb $0x0, %al
callq 0x1060
movq -0x10(%rbp), %rdi
callq 0x1050
leaq 0xd98(%rip), %rdi       # 0x2020
leaq 0xdc9(%rip), %rsi       # 0x2058
callq 0x1090
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12b7
leaq 0xd85(%rip), %rdi       # 0x202b
callq 0x10a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1355
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x4, %edx
movq %rdx, %rsi
callq 0x1040
movl %eax, -0x34(%rbp)
cmpl $0x4, -0x34(%rbp)
jge 0x132a
movq -0x10(%rbp), %rdi
callq 0x1030
cmpl $0x0, %eax
je 0x12fb
movq 0x2d0e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd66(%rip), %rsi       # 0x205a
movb $0x0, %al
callq 0x1070
movq -0x10(%rbp), %rdi
callq 0x1080
cmpl $0x0, %eax
je 0x1321
movq 0x2ce8(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd4e(%rip), %rsi       # 0x2068
movb $0x0, %al
callq 0x1070
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1355
movl -0x30(%rbp), %esi
movl -0x2c(%rbp), %edx
movl -0x28(%rbp), %ecx
movl -0x24(%rbp), %r8d
leaq 0xd40(%rip), %rdi       # 0x207e
movb $0x0, %al
callq 0x1060
movq -0x10(%rbp), %rdi
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/context-switches.c
// Function: stick_self_to_core
int
stick_self_to_core(int cpu)
{
	cpu_set_t cpuset;

	CPU_ZERO(&cpuset);
	CPU_SET(cpu, &cpuset);
	return sched_setaffinity(0, sizeof(cpuset), &cpuset);
}

// Assembly:
subq $0xa8, %rsp
movl %edi, 0xa4(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x10a0
movslq 0xa4(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0x1968
movq 0x18(%rsp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq 0x18(%rsp), %rcx
shrq $0x6, %rcx
orq 0x20(%rsp,%rcx,8), %rax
movq %rax, 0x20(%rsp,%rcx,8)
movq %rax, 0x8(%rsp)
jmp 0x1971
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x1971
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %edi, %edi
movl $0x80, %esi
leaq 0x20(%rsp), %rdx
callq 0x10b0
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/context-switches.c
// Function: thread_handler
void*
thread_handler(void* arg)
{
	(void)arg;
	int num_cores = sysconf(_SC_NPROCESSORS_ONLN);

	while (1) {
		int r = rand() % num_cores;
		int ndx = 0;

		while (++ndx < num_cores) {
			int n = 1000;
			_STRESS_MUST((stick_self_to_core(r) != -1),
			             "couldn't stick thread to cpu %d",
			             ndx);
			while (n-- > 0) {
				printf("Thread %lu is running on CPU %3d\n",
				       (unsigned long)pthread_self(),
				       sched_getcpu());
			}
		}
	}

	return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x54, %edi
callq 0x1120
movl %eax, 0x1c(%rsp)
callq 0x1190
cltd
idivl 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
cmpl 0x1c(%rsp), %eax
jge 0x1b17
movl $0x3e8, 0x10(%rsp)      # imm = 0x3E8
movl 0x18(%rsp), %edi
callq 0x1900
cmpl $-0x1, %eax
jne 0x1ad6
movq 0x25f5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x62b(%rip), %rsi       # 0x2038
movb $0x0, %al
callq 0x10e0
movq 0x25dd(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x619(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x10e0
movq 0x25c5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl 0x14(%rsp), %edx
leaq 0x6df(%rip), %rsi       # 0x2120
movb $0x0, %al
callq 0x10e0
movq 0x25a9(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x60c(%rip), %rsi       # 0x2065
movb $0x0, %al
callq 0x10e0
movq 0x2591(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5f7(%rip), %rsi       # 0x2068
leaq 0x6c8(%rip), %rdx       # 0x2140
movb $0x0, %al
callq 0x10e0
movq 0x2572(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5f4(%rip), %rsi       # 0x2084
movl $0x27, %edx
movb $0x0, %al
callq 0x10e0
movq 0x2555(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5b9(%rip), %rsi       # 0x2066
movb $0x0, %al
callq 0x10e0
movq 0x253d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x5cc(%rip), %rsi       # 0x2091
movb $0x0, %al
callq 0x10e0
movl $0x1, %edi
callq 0x1160
jmp 0x1ad8
jmp 0x1ada
movl 0x10(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rsp)
cmpl $0x0, %eax
jle 0x1b12
callq 0x1110
movq %rax, 0x8(%rsp)
callq 0x1140
movq 0x8(%rsp), %rsi
movl %eax, %edx
leaq 0x64e(%rip), %rdi       # 0x2157
movb $0x0, %al
callq 0x1090
jmp 0x1ada
jmp 0x19cd
jmp 0x19b7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: luaL_requiref
LUALIB_API void luaL_requiref (lua_State *L, const char *modname,
                               lua_CFunction openf, int glb) {
  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
  lua_getfield(L, -1, modname);  /* LOADED[modname] */
  if (!lua_toboolean(L, -1)) {  /* package not already loaded? */
    lua_pop(L, 1);  /* remove field */
    lua_pushcfunction(L, openf);
    lua_pushstring(L, modname);  /* argument to open function */
    lua_call(L, 1, 1);  /* call 'openf' to open module */
    lua_pushvalue(L, -1);  /* make copy of module (call result) */
    lua_setfield(L, -3, modname);  /* LOADED[modname] = module */
  }
  lua_remove(L, -2);  /* remove LOADED table */
  if (glb) {
    lua_pushvalue(L, -1);  /* copy of module */
    lua_setglobal(L, modname);  /* _G[modname] = module */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x4551f(%rip), %rdx     # 0x558a6
callq 0x102d0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xa390
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x86a0
cmpl $0x0, %eax
jne 0x10413
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d90
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x9900
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9100
movq -0x8(%rbp), %rdi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movl %edx, %esi
movq %r8, %rcx
callq 0xbfb0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7340
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xb510
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6e30
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d90
cmpl $0x0, -0x1c(%rbp)
je 0x10455
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7340
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xad70
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: luaL_checkversion_
LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
  const lua_Number *v = lua_version(L);
  if (sz != LUAL_NUMSIZES)  /* check numeric types */
    luaL_error(L, "core and library have incompatible numeric types");
  if (v != lua_version(NULL))
    luaL_error(L, "multiple Lua VMs detected");
  else if (*v != ver)
    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
                  (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)*v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6cd0
movq %rax, -0x20(%rbp)
cmpq $0x88, -0x18(%rbp)
je 0x108ce
movq -0x8(%rbp), %rdi
leaq 0x44fe7(%rip), %rsi     # 0x558ae
movb $0x0, %al
callq 0xe880
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x6cd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x108ff
movq -0x8(%rbp), %rdi
leaq 0x44fe9(%rip), %rsi     # 0x558df
movb $0x0, %al
callq 0xe880
jmp 0x10933
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
ucomisd -0x10(%rbp), %xmm0
jne 0x10912
jp 0x10912
jmp 0x10931
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
leaq 0x44fcf(%rip), %rsi     # 0x558f9
movb $0x2, %al
callq 0xe880
jmp 0x10933
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: luaK_prefix
void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {
  static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP};
  switch (op) {
    case OPR_MINUS: case OPR_BNOT:  /* use 'ef' as fake 2nd operand */
      if (constfolding(fs, op + LUA_OPUNM, e, &ef))
        break;
      /* FALLTHROUGH */
    case OPR_LEN:
      codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line);
      break;
    case OPR_NOT: codenot(fs, e); break;
    default: lua_assert(0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x2, %eax
jb 0x122b7
jmp 0x122a3
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x122f2
jmp 0x122ad
movl -0x20(%rbp), %eax
subl $0x3, %eax
je 0x122da
jmp 0x12301
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0xc, %esi
movq -0x18(%rbp), %rdx
leaq 0x43084(%rip), %rcx     # 0x55350
callq 0x12310
cmpl $0x0, %eax
je 0x122d8
jmp 0x12303
jmp 0x122da
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x19, %esi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x12410
jmp 0x12303
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x12480
jmp 0x12303
jmp 0x12303
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: tonumeral
static int tonumeral(const expdesc *e, TValue *v) {
  if (hasjumps(e))
    return 0;  /* not a numeral */
  switch (e->k) {
    case VKINT:
      if (v) setivalue(v, e->u.ival);
      return 1;
    case VKFLT:
      if (v) setfltvalue(v, e->u.nval);
      return 1;
    default: return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
je 0x12658
movl $0x0, -0x4(%rbp)
jmp 0x126df
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x5, %eax
je 0x126a4
jmp 0x12668
movl -0x2c(%rbp), %eax
subl $0x6, %eax
jne 0x126d8
jmp 0x12672
cmpq $0x0, -0x18(%rbp)
je 0x1269b
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x13, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x126df
cmpq $0x0, -0x18(%rbp)
je 0x126cf
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
movl $0x3, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x126df
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: luaD_shrinkstack
void luaD_shrinkstack (lua_State *L) {
  int inuse = stackinuse(L);
  int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
  if (goodsize > LUAI_MAXSTACK)
    goodsize = LUAI_MAXSTACK;  /* respect stack limit */
  if (L->stacksize > LUAI_MAXSTACK)  /* had been handling stack overflow? */
    luaE_freeCI(L);  /* free all CIs (list grew because of an error) */
  else
    luaE_shrinkCI(L);  /* shrink list */
  /* if thread is currently not handling a stack overflow and its
     good size is smaller than current size, shrink its stack */
  if (inuse <= (LUAI_MAXSTACK - EXTRA_STACK) &&
      goodsize < L->stacksize)
    luaD_reallocstack(L, goodsize);
  else  /* don't change stack */
    condmovestack(L,{},{});  /* (change only for debugging) */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x148c0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x8, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x14(%rbp), %eax
addl %ecx, %eax
addl $0xa, %eax
movl %eax, -0x10(%rbp)
cmpl $0xf4240, -0x10(%rbp)   # imm = 0xF4240
jle 0x14866
movl $0xf4240, -0x10(%rbp)   # imm = 0xF4240
movq -0x8(%rbp), %rax
cmpl $0xf4240, 0xb8(%rax)    # imm = 0xF4240
jle 0x14881
movq -0x8(%rbp), %rdi
callq 0x14930
jmp 0x1488a
movq -0x8(%rbp), %rdi
callq 0x149b0
cmpl $0xf423b, -0xc(%rbp)    # imm = 0xF423B
jg 0x148b0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xb8(%rcx), %eax
jge 0x148b0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x14470
jmp 0x148b2
jmp 0x148b2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: resume_error
static int resume_error (lua_State *L, const char *msg, int narg) {
  L->top -= narg;  /* remove args from the stack */
  setsvalue2s(L, L->top, luaS_new(L, msg));  /* push error message */
  api_incr_top(L);
  lua_unlock(L);
  return LUA_ERRRUN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movslq %edx, %rsi
xorl %edx, %edx
subq %rsi, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8f50
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movzbl 0x8(%rax), %ecx
orl $0x40, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x19f4e
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3f, %eax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movzbl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x19f50
cmpq $0x0, -0x8(%rbp)
je 0x19f4e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movzbl 0x9(%rax), %eax
xorl $0x3, %eax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movzbl 0x54(%rcx), %ecx
xorl $0x3, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x19f50
jmp 0x19f52
jmp 0x19f52
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x10, %rcx
movq %rcx, 0x10(%rax)
movl $0x2, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: resume
static void resume (lua_State *L, void *ud) {
  int n = *(cast(int*, ud));  /* number of arguments */
  StkId firstArg = L->top - n;  /* first argument */
  CallInfo *ci = L->ci;
  if (L->status == LUA_OK) {  /* starting a coroutine? */
    if (!luaD_precall(L, firstArg - 1, LUA_MULTRET))  /* Lua function? */
      luaV_execute(L);  /* call it */
  }
  else {  /* resuming from previous yield */
    lua_assert(L->status == LUA_YIELD);
    L->status = LUA_OK;  /* mark that it is running (again) */
    ci->func = restorestack(L, ci->extra);
    if (isLua(ci))  /* yielded inside a hook? */
      luaV_execute(L);  /* just continue running Lua code */
    else {  /* 'common' yield */
      if (ci->u.c.k != NULL) {  /* does it have a continuation function? */
        lua_unlock(L);
        n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
        lua_lock(L);
        api_checknelems(L, n);
        firstArg = L->top - n;  /* yield results come from continuation */
      }
      luaD_poscall(L, ci, firstArg, n);  /* finish 'luaD_precall' */
    }
    unroll(L, NULL);  /* run continuation */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movzbl 0xc(%rax), %eax
cmpl $0x0, %eax
jne 0x19fe7
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $-0x10, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x14ee0
cmpl $0x0, %eax
jne 0x19fe2
movq -0x8(%rbp), %rdi
callq 0x15740
jmp 0x1a087
movq -0x8(%rbp), %rax
movb $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x28(%rbp), %rax
addq 0x38(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movzwl 0x42(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1a021
movq -0x8(%rbp), %rdi
callq 0x15740
jmp 0x1a07a
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1a066
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x30(%rcx), %rdx
movl $0x1, %esi
callq *%rax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x14(%rbp), %ecx
callq 0x14ab0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1a150
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: luaopen_package
LUAMOD_API int luaopen_package (lua_State *L) {
  createclibstable(L);
  luaL_newlib(L, pk_funcs);  /* create 'package' table */
  createsearcherstable(L);
  /* set paths */
  setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT);
  setpath(L, "cpath", LUA_CPATH_VAR, LUA_CPATH_DEFAULT);
  /* store config information */
  lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n"
                     LUA_EXEC_DIR "\n" LUA_IGMARK "\n");
  lua_setfield(L, -2, "config");
  /* set field 'loaded' */
  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
  lua_setfield(L, -2, "loaded");
  /* set field 'preload' */
  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
  lua_setfield(L, -2, "preload");
  lua_pushglobaltable(L);
  lua_pushvalue(L, -2);  /* set 'package' as upvalue for next lib */
  luaL_setfuncs(L, ll_funcs, 1);  /* open lib into global table */
  lua_pop(L, 1);  /* pop global table */
  return 1;  /* return 'package' table */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c950
movq -0x8(%rbp), %rdi
movsd 0x38e97(%rip), %xmm0    # 0x556a8
movl $0x88, %esi
callq 0x10890
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x7, %edx
callq 0xa7f0
movq -0x8(%rbp), %rdi
leaq 0x46c2a(%rip), %rsi     # 0x63460
xorl %edx, %edx
callq 0x10220
movq -0x8(%rbp), %rdi
callq 0x1c9d0
movq -0x8(%rbp), %rdi
leaq 0x393c2(%rip), %rsi     # 0x55c13
leaq 0x3931a(%rip), %rdx     # 0x55b72
leaq 0x3931c(%rip), %rcx     # 0x55b7b
callq 0x1ca70
movq -0x8(%rbp), %rdi
leaq 0x393a3(%rip), %rsi     # 0x55c12
leaq 0x393a2(%rip), %rdx     # 0x55c18
leaq 0x393a5(%rip), %rcx     # 0x55c22
callq 0x1ca70
movq -0x8(%rbp), %rdi
leaq 0x393da(%rip), %rsi     # 0x55c67
callq 0x9100
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x393d0(%rip), %rdx     # 0x55c72
callq 0xb510
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x38fef(%rip), %rdx     # 0x558a6
callq 0x102d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x393ad(%rip), %rdx     # 0x55c79
callq 0xb510
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
leaq 0x3939f(%rip), %rdx     # 0x55c80
callq 0x102d0
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x39393(%rip), %rdx     # 0x55c89
callq 0xb510
movq -0x8(%rbp), %rdi
movl $0xfff0b9d8, %esi       # imm = 0xFFF0B9D8
movl $0x2, %edx
callq 0xa610
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x7340
movq -0x8(%rbp), %rdi
leaq 0x46bb9(%rip), %rsi     # 0x634e0
movl $0x1, %edx
callq 0x10220
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d90
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: setpath
static void setpath (lua_State *L, const char *fieldname,
                                   const char *envname,
                                   const char *dft) {
  const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
  const char *path = getenv(nver);  /* use versioned name */
  if (path == NULL)  /* no environment variable? */
    path = getenv(envname);  /* try unversioned name */
  if (path == NULL || noenv(L))  /* no environment variable? */
    lua_pushstring(L, dft);  /* use default */
  else {
    /* replace ";;" by ";AUXMARK;" and then AUXMARK by default path */
    path = luaL_gsub(L, path, LUA_PATH_SEP LUA_PATH_SEP,
                              LUA_PATH_SEP AUXMARK LUA_PATH_SEP);
    luaL_gsub(L, path, AUXMARK, dft);
    lua_remove(L, -2); /* remove result from 1st 'gsub' */
  }
  setprogdir(L);
  lua_setfield(L, -3, fieldname);  /* package[fieldname] = path value */
  lua_pop(L, 1);  /* pop versioned variable name */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3a054(%rip), %rsi     # 0x56aeb
leaq 0x3a052(%rip), %rcx     # 0x56af0
movb $0x0, %al
callq 0x9840
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x65a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x1caca
movq -0x18(%rbp), %rdi
callq 0x65a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1cadf
movq -0x8(%rbp), %rdi
callq 0x2b530
cmpl $0x0, %eax
je 0x1caee
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x9100
jmp 0x1cb46
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq 0x39ff8(%rip), %rdx     # 0x56af5
leaq 0x39ff4(%rip), %rcx     # 0x56af8
callq 0x10460
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x20(%rbp), %rcx
leaq 0x39fdc(%rip), %rdx     # 0x56afc
callq 0x10460
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x6e30
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d90
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0xb510
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6d90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kieselsteini[P]PiXL-old/lua53.c
// Function: setnodevector
static void setnodevector (lua_State *L, Table *t, unsigned int size) {
  if (size == 0) {  /* no elements to hash part? */
    t->node = cast(Node *, dummynode);  /* use common 'dummynode' */
    t->lsizenode = 0;
    t->lastfree = NULL;  /* signal that it is using dummy node */
  }
  else {
    int i;
    int lsize = luaO_ceillog2(size);
    if (lsize > MAXHBITS)
      luaG_runerror(L, "table overflow");
    size = twoto(lsize);
    t->node = luaM_newvector(L, size, Node);
    for (i = 0; i < (int)size; i++) {
      Node *n = gnode(t, i);
      gnext(n) = 0;
      setnilvalue(wgkey(n));
      setnilvalue(gval(n));
    }
    t->lsizenode = cast_byte(lsize);
    t->lastfree = gnode(t, size);  /* all positions are free */
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1e901
movq -0x10(%rbp), %rax
leaq 0x36d7c(%rip), %rcx     # 0x55660
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0xb(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x1e9cd
movl -0x14(%rbp), %edi
callq 0x1cc30
movl %eax, -0x1c(%rbp)
cmpl $0x1e, -0x1c(%rbp)
jle 0x1e924
movq -0x8(%rbp), %rdi
leaq 0x38aeb(%rip), %rsi     # 0x57408
movb $0x0, %al
callq 0x13600
movl -0x1c(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %ecx
shlq $0x5, %rcx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x14540
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1e9a7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e95c
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xb(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movl -0x14(%rbp), %eax
shlq $0x5, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)