LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-csi.c
// Function: register_csi_ss3_full
static void register_csi_ss3_full(TermKeyType type, TermKeySym sym, int modifier_set, int modifier_mask, unsigned char cmd)
{
  if(cmd < 0x40 || cmd >= 0x80) {
    return;
  }

  csi_ss3s[cmd - 0x40].type = type;
  csi_ss3s[cmd - 0x40].sym = sym;
  csi_ss3s[cmd - 0x40].modifier_set = modifier_set;
  csi_ss3s[cmd - 0x40].modifier_mask = modifier_mask;

  csi_handlers[cmd - 0x40] = &handle_csi_ss3_full;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
cmpl $0x40, %eax
jl 0x75ca
movzbl -0x11(%rbp), %eax
cmpl $0x80, %eax
jl 0x75cf
jmp 0x7662
movl -0x4(%rbp), %ecx
movzbl -0x11(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rdx
leaq 0x64fd(%rip), %rax      # 0xdae0
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movzbl -0x11(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rdx
leaq 0x64e0(%rip), %rax      # 0xdae0
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movzbl -0x11(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rdx
leaq 0x64c2(%rip), %rax      # 0xdae0
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0xc(%rax)
movl -0x10(%rbp), %ecx
movzbl -0x11(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rdx
leaq 0x64a4(%rip), %rax      # 0xdae0
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movzbl -0x11(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rcx
leaq 0x6ef9(%rip), %rax      # 0xe550
leaq 0x4b2(%rip), %rdx       # 0x7b10
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-csi.c
// Function: register_ss3kpalt
static void register_ss3kpalt(TermKeyType type, TermKeySym sym, unsigned char cmd, char kpalt)
{
  if(cmd < 0x40 || cmd >= 0x80) {
    return;
  }

  ss3s[cmd - 0x40].type = type;
  ss3s[cmd - 0x40].sym = sym;
  ss3s[cmd - 0x40].modifier_set = 0;
  ss3s[cmd - 0x40].modifier_mask = 0;
  ss3_kpalts[cmd - 0x40] = kpalt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x40, %eax
jl 0x7698
movzbl -0x9(%rbp), %eax
cmpl $0x80, %eax
jl 0x769d
jmp 0x772d
movl -0x4(%rbp), %ecx
movzbl -0x9(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rdx
leaq 0x682f(%rip), %rax      # 0xdee0
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movzbl -0x9(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rdx
leaq 0x6812(%rip), %rax      # 0xdee0
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movzbl -0x9(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rcx
leaq 0x67f7(%rip), %rax      # 0xdee0
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movzbl -0x9(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rcx
leaq 0x67d8(%rip), %rax      # 0xdee0
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movb -0xa(%rbp), %dl
movzbl -0x9(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rcx
leaq 0x6bb6(%rip), %rax      # 0xe2e0
movb %dl, (%rax,%rcx)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-csi.c
// Function: register_csifunc
static void register_csifunc(TermKeyType type, TermKeySym sym, int number)
{
  if(number >= NCSIFUNCS) {
    return;
  }

  csifuncs[number].type = type;
  csifuncs[number].sym = sym;
  csifuncs[number].modifier_set = 0;
  csifuncs[number].modifier_mask = 0;

  csi_handlers['~' - 0x40] = &handle_csifunc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movslq -0xc(%rbp), %rax
cmpq $0x23, %rax
jb 0x7749
jmp 0x77b8
movl -0x4(%rbp), %ecx
movslq -0xc(%rbp), %rdx
leaq 0x6bc9(%rip), %rax      # 0xe320
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movslq -0xc(%rbp), %rdx
leaq 0x6bb2(%rip), %rax      # 0xe320
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x6b9d(%rip), %rax      # 0xe320
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0xc(%rax)
movslq -0xc(%rbp), %rcx
leaq 0x6b84(%rip), %rax      # 0xe320
shlq $0x4, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
leaq 0x45f(%rip), %rax       # 0x7c10
movq %rax, 0x6f88(%rip)      # 0xe740
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-csi.c
// Function: handle_csi_u
static TermKeyResult handle_csi_u(TermKey *tk, TermKeyKey *key, int cmd, long *arg, int args)
{
  switch(cmd) {
    case 'u': {
      if(args > 1 && arg[1] != -1)
        key->modifiers = arg[1] - 1;
      else
        key->modifiers = 0;

      int mod = key->modifiers;
      key->type = TERMKEY_TYPE_KEYSYM;
      (*tk->method.emit_codepoint)(tk, arg[0], key);
      key->modifiers |= mod;

      return TERMKEY_RES_KEY;
    }
    default:
      return TERMKEY_RES_NONE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x75, %eax
jne 0x785e
jmp 0x77e5
cmpl $0x1, -0x2c(%rbp)
jle 0x780d
movq -0x28(%rbp), %rax
cmpq $-0x1, 0x8(%rax)
je 0x780d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x7818
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x10(%rbp), %rax
movq 0x2a8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x7865
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-csi.c
// Function: handle_csi_m
static TermKeyResult handle_csi_m(TermKey *tk, TermKeyKey *key, int cmd, long *arg, int args)
{
  int initial = cmd >> 8;
  cmd &= 0xff;

  switch(cmd) {
    case 'M':
    case 'm':
      break;
    default:
      return TERMKEY_RES_NONE;
  }

  if(!initial && args >= 3) { // rxvt protocol
    key->type = TERMKEY_TYPE_MOUSE;
    key->code.mouse[0] = arg[0];

    key->modifiers     = (key->code.mouse[0] & 0x1c) >> 2;
    key->code.mouse[0] &= ~0x1c;

    termkey_key_set_linecol(key, arg[1], arg[2]);

    return TERMKEY_RES_KEY;
  }

  if(initial == '<' && args >= 3) { // SGR protocol
    key->type = TERMKEY_TYPE_MOUSE;
    key->code.mouse[0] = arg[0];

    key->modifiers     = (key->code.mouse[0] & 0x1c) >> 2;
    key->code.mouse[0] &= ~0x1c;

    termkey_key_set_linecol(key, arg[1], arg[2]);

    if(cmd == 'm') // release
      key->code.mouse[3] |= 0x80;

    return TERMKEY_RES_KEY;
  }

  return TERMKEY_RES_NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
sarl $0x8, %eax
movl %eax, -0x30(%rbp)
movzbl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
orl $0x20, %eax
subl $0x6d, %eax
je 0x78a8
jmp 0x78aa
jmp 0x78b6
movl $0x0, -0x4(%rbp)
jmp 0x79b9
cmpl $0x0, -0x30(%rbp)
jne 0x7928
cmpl $0x3, -0x2c(%rbp)
jl 0x7928
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x18(%rbp), %rax
movsbl 0x8(%rax), %ecx
andl $0x1c, %ecx
sarl $0x2, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movsbl 0x8(%rax), %ecx
andl $-0x1d, %ecx
movb %cl, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
callq 0x7d80
movl $0x1, -0x4(%rbp)
jmp 0x79b9
cmpl $0x3c, -0x30(%rbp)
jne 0x79b2
cmpl $0x3, -0x2c(%rbp)
jl 0x79b2
movq -0x18(%rbp), %rax
movl $0x3, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x18(%rbp), %rax
movsbl 0x8(%rax), %ecx
andl $0x1c, %ecx
sarl $0x2, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movsbl 0x8(%rax), %ecx
andl $-0x1d, %ecx
movb %cl, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl %eax, %edx
callq 0x7d80
cmpl $0x6d, -0x1c(%rbp)
jne 0x79a9
movq -0x18(%rbp), %rax
movsbl 0xb(%rax), %ecx
orl $0x80, %ecx
movb %cl, 0xb(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x79b9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-csi.c
// Function: handle_csi_R
static TermKeyResult handle_csi_R(TermKey *tk, TermKeyKey *key, int cmd, long *arg, int args)
{
  switch(cmd) {
    case 'R'|'?'<<8:
      if(args < 2)
        return TERMKEY_RES_NONE;

      key->type = TERMKEY_TYPE_POSITION;
      termkey_key_set_linecol(key, arg[1], arg[0]);
      return TERMKEY_RES_KEY;

    default:
      return handle_csi_ss3_full(tk, key, cmd, arg, args);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x3f52, %eax           # imm = 0x3F52
jne 0x7a35
jmp 0x79f7
cmpl $0x2, -0x2c(%rbp)
jge 0x7a06
movl $0x0, -0x4(%rbp)
jmp 0x7a50
movq -0x18(%rbp), %rax
movl $0x4, (%rax)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %esi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl %eax, %edx
callq 0x7d80
movl $0x1, -0x4(%rbp)
jmp 0x7a50
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x7b10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-csi.c
// Function: handle_csi_y
static TermKeyResult handle_csi_y(TermKey *tk, TermKeyKey *key, int cmd, long *arg, int args)
{
  switch(cmd) {
    case 'y'|'$'<<16:
    case 'y'|'$'<<16 | '?'<<8:
      if(args < 2)
        return TERMKEY_RES_NONE;

      key->type = TERMKEY_TYPE_MODEREPORT;
      key->code.mouse[0] = (cmd >> 8);
      key->code.mouse[1] = arg[0] >> 8;
      key->code.mouse[2] = arg[0] & 0xff;
      key->code.mouse[3] = arg[1];
      return TERMKEY_RES_KEY;

    default:
      return TERMKEY_RES_NONE;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x30(%rbp)
subl $0x240079, %eax         # imm = 0x240079
je 0x7a92
jmp 0x7a86
movl -0x30(%rbp), %eax
subl $0x243f79, %eax         # imm = 0x243F79
jne 0x7afe
jmp 0x7a92
cmpl $0x2, -0x2c(%rbp)
jge 0x7aa1
movl $0x0, -0x4(%rbp)
jmp 0x7b05
movq -0x18(%rbp), %rax
movl $0x5, (%rax)
movl -0x1c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
sarq $0x8, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0xb(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x7b05
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-csi.c
// Function: handle_csi_ss3_full
static TermKeyResult handle_csi_ss3_full(TermKey *tk, TermKeyKey *key, int cmd, long *arg, int args)
{
  if(args > 1 && arg[1] != -1)
    key->modifiers = arg[1] - 1;
  else
    key->modifiers = 0;

  key->type = csi_ss3s[cmd - 0x40].type;
  key->code.sym = csi_ss3s[cmd - 0x40].sym;
  key->modifiers &= ~(csi_ss3s[cmd - 0x40].modifier_mask);
  key->modifiers |= csi_ss3s[cmd - 0x40].modifier_set;

  if(key->code.sym == TERMKEY_SYM_UNKNOWN)
    return TERMKEY_RES_NONE;

  return TERMKEY_RES_KEY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jle 0x7b4f
movq -0x28(%rbp), %rax
cmpq $-0x1, 0x8(%rax)
je 0x7b4f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x7b5a
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0x1c(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rcx
leaq 0x5f76(%rip), %rax      # 0xdae0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rcx
leaq 0x5f57(%rip), %rax      # 0xdae0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rcx
leaq 0x5f36(%rip), %rax      # 0xdae0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
xorl $-0x1, %ecx
movq -0x18(%rbp), %rax
andl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movl -0x1c(%rbp), %eax
subl $0x40, %eax
movslq %eax, %rcx
leaq 0x5f0f(%rip), %rax      # 0xdae0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x7bf8
movl $0x0, -0x4(%rbp)
jmp 0x7bff
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-csi.c
// Function: handle_csifunc
static TermKeyResult handle_csifunc(TermKey *tk, TermKeyKey *key, int cmd, long *arg, int args)
{
  if(args > 1 && arg[1] != -1)
    key->modifiers = arg[1] - 1;
  else
    key->modifiers = 0;

  key->type = TERMKEY_TYPE_KEYSYM;

  if(arg[0] == 27) {
    int mod = key->modifiers;
    (*tk->method.emit_codepoint)(tk, arg[2], key);
    key->modifiers |= mod;
  }
  else if(arg[0] >= 0 && arg[0] < NCSIFUNCS) {
    key->type = csifuncs[arg[0]].type;
    key->code.sym = csifuncs[arg[0]].sym;
    key->modifiers &= ~(csifuncs[arg[0]].modifier_mask);
    key->modifiers |= csifuncs[arg[0]].modifier_set;
  }
  else
    key->code.sym = TERMKEY_SYM_UNKNOWN;

  if(key->code.sym == TERMKEY_SYM_UNKNOWN) {
#ifdef DEBUG
    fprintf(stderr, "CSI: Unknown function key %ld\n", arg[0]);
#endif
    return TERMKEY_RES_NONE;
  }

  return TERMKEY_RES_KEY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
cmpl $0x1, -0x2c(%rbp)
jle 0x7c53
movq -0x28(%rbp), %rax
cmpq $-0x1, 0x8(%rax)
je 0x7c53
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x7c5e
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x1b, (%rax)
jne 0x7cab
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x2a8(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x7d59
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jl 0x7d4c
movq -0x28(%rbp), %rax
cmpq $0x23, (%rax)
jae 0x7d4c
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0x664b(%rip), %rax      # 0xe320
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0x662e(%rip), %rax      # 0xe320
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0x660f(%rip), %rax      # 0xe320
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
xorl $-0x1, %ecx
movq -0x18(%rbp), %rax
andl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
leaq 0x65ea(%rip), %rax      # 0xe320
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movq -0x18(%rbp), %rax
orl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
jmp 0x7d57
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
jmp 0x7d59
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x7d6c
movl $0x0, -0x4(%rbp)
jmp 0x7d73
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: new_driver
static void *new_driver(TermKey *tk, const char *term)
{
  TermKeyTI *ti = malloc(sizeof *ti);
  if(!ti)
    return NULL;

  ti->tk = tk;
  ti->root = NULL;
  ti->start_string = NULL;
  ti->stop_string = NULL;

#ifdef HAVE_UNIBILIUM
  ti->unibi = unibi_from_term(term);
  int saved_errno = errno;
  if(!ti->unibi && saved_errno != ENOENT) {
    free(ti);
    return NULL;
  }
  /* ti->unibi may be NULL if errno == ENOENT. That means the terminal wasn't
   * known. Lets keep going because if we get getstr hook that might invent
   * new strings for us
   */
#else
  {
    int err;

    ti->term = NULL;

    /* Have to cast away the const. But it's OK - we know terminfo won't really
    * modify term */
    if(setupterm((char*)term, 1, &err) == OK)
      ti->term = strdup(term);
  }
#endif

  return ti;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x28, %edi
callq 0x31f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x84cf
movq $0x0, -0x8(%rbp)
jmp 0x853d
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq -0x24(%rbp), %rdx
callq 0x3230
cmpl $0x0, %eax
jne 0x8535
movq -0x18(%rbp), %rdi
callq 0x32d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: free_driver
static void free_driver(void *info)
{
  TermKeyTI *ti = info;

  free_trie(ti->root);

  if(ti->start_string)
    free(ti->start_string);

  if(ti->stop_string)
    free(ti->stop_string);

#ifdef HAVE_UNIBILIUM
  if(ti->unibi)
    unibi_destroy(ti->unibi);
#else
  if(ti->term)
    free(ti->term);
#endif

  free(ti);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x89e0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x8589
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3050
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x85a1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3050
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x85b9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3050
movq -0x10(%rbp), %rdi
callq 0x3050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: start_driver
static int start_driver(TermKey *tk, void *info)
{
  TermKeyTI *ti = info;
  struct stat statbuf;
  char *start_string;
  size_t len;

  if(!ti->root)
    load_terminfo(ti);

  start_string = ti->start_string;

  if(tk->fd == -1 || !start_string)
    return 1;

  /* The terminfo database will contain keys in application cursor key mode.
   * We may need to enable that mode
   */

  /* There's no point trying to write() to a pipe */
  if(fstat(tk->fd, &statbuf) == -1)
    return 0;

#ifndef _WIN32
  if(S_ISFIFO(statbuf.st_mode))
    return 1;
#endif

  // Can't call putp or tputs because they suck and don't give us fd control
  len = strlen(start_string);
  while(len) {
    size_t written = write(tk->fd, start_string, len);
    if(written == -1)
      return 0;
    start_string += written;
    len -= written;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x85ff
movq -0x20(%rbp), %rdi
callq 0x8a90
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x8621
cmpq $0x0, -0xb8(%rbp)
jne 0x862d
movl $0x1, -0x4(%rbp)
jmp 0x86f4
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0xb0(%rbp), %rsi
callq 0x32f0
cmpl $-0x1, %eax
jne 0x8650
movl $0x0, -0x4(%rbp)
jmp 0x86f4
movl -0x98(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x866e
movl $0x1, -0x4(%rbp)
jmp 0x86f4
movq -0xb8(%rbp), %rdi
callq 0x3100
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0xc0(%rbp)
je 0x86ed
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0x30f0
movq %rax, -0xc8(%rbp)
cmpq $-0x1, -0xc8(%rbp)
jne 0x86be
movl $0x0, -0x4(%rbp)
jmp 0x86f4
movq -0xc8(%rbp), %rax
addq -0xb8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xc8(%rbp), %rcx
movq -0xc0(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xc0(%rbp)
jmp 0x8681
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: stop_driver
static int stop_driver(TermKey *tk, void *info)
{
  TermKeyTI *ti = info;
  struct stat statbuf;
  char *stop_string = ti->stop_string;
  size_t len;

  if(tk->fd == -1 || !stop_string)
    return 1;

  /* There's no point trying to write() to a pipe */
  if(fstat(tk->fd, &statbuf) == -1)
    return 0;

#ifndef _WIN32
  if(S_ISFIFO(statbuf.st_mode))
    return 1;
#endif

  /* The terminfo database will contain keys in application cursor key mode.
   * We may need to enable that mode
   */

  // Can't call putp or tputs because they suck and don't give us fd control
  len = strlen(stop_string);
  while(len) {
    size_t written = write(tk->fd, stop_string, len);
    if(written == -1)
      return 0;
    stop_string += written;
    len -= written;
  }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, (%rax)
je 0x873d
cmpq $0x0, -0xb8(%rbp)
jne 0x8749
movl $0x1, -0x4(%rbp)
jmp 0x8810
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0xb0(%rbp), %rsi
callq 0x32f0
cmpl $-0x1, %eax
jne 0x876c
movl $0x0, -0x4(%rbp)
jmp 0x8810
movl -0x98(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x878a
movl $0x1, -0x4(%rbp)
jmp 0x8810
movq -0xb8(%rbp), %rdi
callq 0x3100
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0xc0(%rbp)
je 0x8809
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0xb8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
callq 0x30f0
movq %rax, -0xc8(%rbp)
cmpq $-0x1, -0xc8(%rbp)
jne 0x87da
movl $0x0, -0x4(%rbp)
jmp 0x8810
movq -0xc8(%rbp), %rax
addq -0xb8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xc8(%rbp), %rcx
movq -0xc0(%rbp), %rax
subq %rcx, %rax
movq %rax, -0xc0(%rbp)
jmp 0x879d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: free_trie
static void free_trie(struct trie_node *n)
{
  switch(n->type) {
  case TYPE_KEY:
    break;
  case TYPE_ARR:
    {
      struct trie_node_arr *nar = (struct trie_node_arr*)n;
      int i;
      for(i = nar->min; i <= nar->max; i++)
        if(nar->arr[i - nar->min])
          free_trie(nar->arr[i - nar->min]);
      break;
    }
  }

  free(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x8a05
jmp 0x89fb
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x8a07
jmp 0x8a72
jmp 0x8a72
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
cmpl %ecx, %eax
jg 0x8a70
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x4(%rdx), %edx
subl %edx, %ecx
movslq %ecx, %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x8a63
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rdx
movzbl 0x4(%rdx), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x89e0
jmp 0x8a65
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8a1a
jmp 0x8a72
movq -0x8(%rbp), %rdi
callq 0x3050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: new_node_arr
static struct trie_node *new_node_arr(unsigned char min, unsigned char max)
{
  struct trie_node_arr *n = malloc(sizeof(*n) + ((int)max-min+1) * sizeof(n->arr[0]));
  if(!n)
    return NULL;

  n->type = TYPE_ARR;
  n->min = min; n->max = max;

  int i;
  for(i = min; i <= max; i++)
    n->arr[i-min] = NULL;

  return (struct trie_node*)n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x9(%rbp)
movb %al, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
movzbl -0x9(%rbp), %ecx
subl %ecx, %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
addq $0x8, %rdi
callq 0x31f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8e96
movq $0x0, -0x8(%rbp)
jmp 0x8ef2
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x4(%rax)
movb -0xa(%rbp), %cl
movq -0x18(%rbp), %rax
movb %cl, 0x5(%rax)
movzbl -0x9(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movzbl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jg 0x8eea
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl -0x9(%rbp), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movq $0x0, 0x8(%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8ebb
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: try_load_terminfo_key
static bool try_load_terminfo_key(TermKeyTI *ti, const char *name, struct keyinfo *info)
{
  const char *value = NULL;

#ifdef HAVE_UNIBILIUM
  if(ti->unibi)
    value = unibi_get_str_by_name(ti->unibi, name);
#else
  if(ti->term)
    value = tigetstr(name);
#endif

  if(ti->tk->ti_getstr_hook)
    value = (ti->tk->ti_getstr_hook)(name, value, ti->tk->ti_getstr_hook_data);

  if(!value || value == (char*)-1 || !value[0])
    return false;

  struct trie_node *node = new_node_key(info->type, info->sym, info->modifier_mask, info->modifier_set);
  insert_seq(ti, value, node);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8f34
movq -0x18(%rbp), %rdi
callq 0x3290
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x78(%rax)
je 0x8f69
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x78(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x80(%rcx), %rdx
callq *%rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8f86
movq $-0x1, %rax
cmpq %rax, -0x28(%rbp)
je 0x8f86
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x8f8c
movb $0x0, -0x1(%rbp)
jmp 0x8fc5
movq -0x20(%rbp), %rax
movl (%rax), %edi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
callq 0x8fd0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9050
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: new_node_key
static struct trie_node *new_node_key(TermKeyType type, TermKeySym sym, int modmask, int modset)
{
  struct trie_node_key *n = malloc(sizeof(*n));
  if(!n)
    return NULL;

  n->type = TYPE_KEY;

  n->key.type = type;
  n->key.sym  = sym;
  n->key.modifier_mask = modmask;
  n->key.modifier_set  = modset;

  return (struct trie_node*)n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x14, %edi
callq 0x31f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x9003
movq $0x0, -0x8(%rbp)
jmp 0x903d
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: compress_trie
static struct trie_node *compress_trie(struct trie_node *n)
{
  if(!n)
    return NULL;

  switch(n->type) {
  case TYPE_KEY:
    return n;
  case TYPE_ARR:
    {
      struct trie_node_arr *nar = (struct trie_node_arr*)n;
      unsigned char min, max;
      // Find the real bounds
      for(min = 0; !nar->arr[min]; min++)
        if(min == 255 && !nar->arr[min]) {
          free(nar);
          return new_node_arr(1, 0);
        }

      for(max = 0xff; !nar->arr[max]; max--)
        ;

      struct trie_node_arr *new = (struct trie_node_arr*)new_node_arr(min, max);
      int i;
      for(i = min; i <= max; i++)
        new->arr[i - min] = compress_trie(nar->arr[i]);

      free(nar);
      return (struct trie_node*)new;
    }
  }

  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x9210
movq $0x0, -0x8(%rbp)
jmp 0x9341
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
testl %eax, %eax
je 0x922c
jmp 0x921f
movl -0x30(%rbp), %eax
subl $0x1, %eax
je 0x9239
jmp 0x9339
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9341
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rax
movzbl -0x19(%rbp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x925e
jmp 0x92a3
movzbl -0x19(%rbp), %eax
cmpl $0xff, %eax
jne 0x9297
movq -0x18(%rbp), %rax
movzbl -0x19(%rbp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
jne 0x9297
movq -0x18(%rbp), %rdi
callq 0x3050
movl $0x1, %edi
xorl %esi, %esi
callq 0x8e50
movq %rax, -0x8(%rbp)
jmp 0x9341
jmp 0x9299
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x9245
movb $-0x1, -0x1a(%rbp)
movq -0x18(%rbp), %rax
movzbl -0x1a(%rbp), %ecx
cmpq $0x0, 0x8(%rax,%rcx,8)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x92c0
jmp 0x92cc
jmp 0x92c2
movb -0x1a(%rbp), %al
addb $-0x1, %al
movb %al, -0x1a(%rbp)
jmp 0x92a7
movb -0x19(%rbp), %al
movzbl %al, %edi
movzbl -0x1a(%rbp), %esi
callq 0x8e50
movq %rax, -0x28(%rbp)
movzbl -0x19(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movzbl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jg 0x9326
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rdi
callq 0x91f0
movq %rax, %rdx
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movzbl -0x19(%rbp), %esi
subl %esi, %ecx
movslq %ecx, %rcx
movq %rdx, 0x8(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x92e6
movq -0x18(%rbp), %rdi
callq 0x3050
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9341
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libtermkey/driver-ti.c
// Function: lookup_next
static struct trie_node *lookup_next(struct trie_node *n, unsigned char b)
{
  switch(n->type) {
  case TYPE_KEY:
    fprintf(stderr, "ABORT: lookup_next within a TYPE_KEY node\n");
    abort();
  case TYPE_ARR:
    {
      struct trie_node_arr *nar = (struct trie_node_arr*)n;
      if(b < nar->min || b > nar->max)
        return NULL;
      return nar->arr[b - nar->min];
    }
  }

  return NULL; // Never reached but keeps compiler happy
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x937b
jmp 0x9371
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x9398
jmp 0x93ea
movq 0x3c76(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x11be(%rip), %rsi      # 0xa54a
movb $0x0, %al
callq 0x3190
callq 0x3080
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movzbl -0x11(%rbp), %eax
movq -0x20(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
cmpl %ecx, %eax
jl 0x93c0
movzbl -0x11(%rbp), %eax
movq -0x20(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
cmpl %ecx, %eax
jle 0x93ca
movq $0x0, -0x8(%rbp)
jmp 0x93f2
movq -0x20(%rbp), %rax
movzbl -0x11(%rbp), %ecx
movq -0x20(%rbp), %rdx
movzbl 0x4(%rdx), %edx
subl %edx, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x93f2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_07/find.c
// Function: main
int main(int argc, char *argv[])
{
  if (!parse_arg_list(argc, argv))
  {
    exit(EXIT_FAILURE);
  }

  if (argc - pattern_arg_pos > 1)
  {
    for (int file_arg_pos = pattern_arg_pos + 1; file_arg_pos < argc; file_arg_pos++)
    {
      FILE *file_p;
      if ((file_p = fopen(argv[file_arg_pos], "r")) == NULL)
      {
        fprintf(stderr, "%s: can't open %s.\n", program_name, argv[file_arg_pos]);
        exit(EXIT_FAILURE);
      }
      printf("%s\n", argv[file_arg_pos]);
      find_pattern(argv[pattern_arg_pos], file_p);
      fclose(file_p);

      if (file_arg_pos < argc - 1)
      {
        putc('\n', stdout);
      }
    }
  }
  else
  {
    find_pattern(argv[pattern_arg_pos], stdin);
  }

  exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1300
cmpl $0x0, %eax
jne 0x11e1
movl $0x1, %edi
callq 0x1090
movl -0x8(%rbp), %eax
subl 0x2e7e(%rip), %eax      # 0x4068
cmpl $0x1, %eax
jle 0x12d0
movl 0x2e6f(%rip), %eax      # 0x4068
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12ce
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xde6(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x1262
movq 0x2dc4(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2e42(%rip), %rdx      # 0x4080
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq 0xdb5(%rip), %rsi       # 0x2006
movb $0x0, %al
callq 0x1070
movl $0x1, %edi
callq 0x1090
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xda5(%rip), %rdi       # 0x201a
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movslq 0x2de1(%rip), %rcx      # 0x4068
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
callq 0x1430
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x14(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x12be
movq 0x2d1f(%rip), %rax      # 0x3fd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x1060
jmp 0x12c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11ff
jmp 0x12ee
movq -0x10(%rbp), %rax
movslq 0x2d8d(%rip), %rcx      # 0x4068
movq (%rax,%rcx,8), %rdi
movq 0x2cf2(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
callq 0x1430
xorl %edi, %edi
callq 0x1090
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_07/find.c
// Function: parse_arg_list
boolean parse_arg_list(int argc, char *argv[])
{
  program_name = argv[0];

  if (argc < 3)
  {
    fprintf(stderr, "Usage: %s [-xn]... PATTERN [FILE]...\n", program_name);
    return false;
  }

  while (--argc > 0 && (*++argv)[0] == '-')
  {
    int c;
    while ((c = *++argv[0]))
    {
      switch (c)
      {
      case 'x':
        except = true;
        break;

      case 'n':
        number = true;
        break;

      default:
        fprintf(stderr, "%s: illegal option %c.\n", program_name, c);
        return false;
        break;
      }
    }

    ++pattern_arg_pos;
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x2d63(%rip)      # 0x4080
cmpl $0x3, -0x8(%rbp)
jge 0x134e
movq 0x2cce(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2d4c(%rip), %rdx      # 0x4080
leaq 0xce3(%rip), %rsi       # 0x201e
movb $0x0, %al
callq 0x1070
movl $0x0, -0x4(%rbp)
jmp 0x1424
jmp 0x1350
movl -0x8(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jle 0x1382
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x138e
jmp 0x141d
jmp 0x1390
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movsbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x1409
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x6e, %eax
je 0x13d0
jmp 0x13ba
movl -0x1c(%rbp), %eax
subl $0x78, %eax
jne 0x13dc
jmp 0x13c4
movl $0x1, 0x2caa(%rip)      # 0x4078
jmp 0x1407
movl $0x1, 0x2ca2(%rip)      # 0x407c
jmp 0x1407
movq 0x2c15(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq 0x2c93(%rip), %rdx      # 0x4080
movl -0x14(%rbp), %ecx
leaq 0xc4d(%rip), %rsi       # 0x2044
movb $0x0, %al
callq 0x1070
movl $0x0, -0x4(%rbp)
jmp 0x1424
jmp 0x1390
movl 0x2c59(%rip), %eax      # 0x4068
addl $0x1, %eax
movl %eax, 0x2c50(%rip)      # 0x4068
jmp 0x1350
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_7/exercise_7_07/find.c
// Function: find_pattern
void find_pattern(char *pattern, FILE *file_p)
{
  size_t line_number = 1;
  char line[MAX_LINE_LEN];
  while (fgets(line, MAX_LINE_LEN, file_p) != NULL)
  {
    if ((strstr(line, pattern) != NULL) != except)
    {
      if (number)
      {
        printf("%ld: ", line_number);
      }
      printf("%s", line);
    }
    ++line_number;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x400, %rsp            # imm = 0x400
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
leaq -0x400(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x1050
cmpq $0x0, %rax
je 0x14c8
leaq -0x400(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x10a0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
cmpl 0x2bf0(%rip), %eax      # 0x4078
je 0x14ba
cmpl $0x0, 0x2beb(%rip)      # 0x407c
je 0x14a5
movq -0x18(%rbp), %rsi
leaq 0xbbe(%rip), %rdi       # 0x205c
movb $0x0, %al
callq 0x1040
leaq -0x400(%rbp), %rsi
leaq 0xbaf(%rip), %rdi       # 0x2062
movb $0x0, %al
callq 0x1040
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x144b
addq $0x400, %rsp            # imm = 0x400
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/flappy.cc
// Function: print_scores(Display&, HighScores&)
void print_scores(Display &display, HighScores &scores) {
  attron(A_BOLD);
  mvprintw(0, display.width + 4, "== High Scores ==");
  attroff(A_BOLD);
  int i = 1;
  for (auto &line : scores.top_scores()) {
    mvprintw(i, display.width + 1, "%s", line.name.c_str());
    clrtoeol();
    mvprintw(i, display.width + 24, "%d", line.score);
    i++;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xaa979(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %eax, %eax
movl %eax, %edx
callq 0x7180
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
addl $0x4, %esi
xorl %edi, %edi
leaq 0x8c995(%rip), %rdx     # 0x94020
movb $0x0, %al
callq 0x73d0
movq 0xaa947(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x200000, %esi         # imm = 0x200000
xorl %eax, %eax
movl %eax, %edx
callq 0x73c0
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xaf00
leaq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7b70
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7ba0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7bd0
testb $0x1, %al
jne 0x76ff
leaq -0x38(%rbp), %rdi
callq 0x7c50
jmp 0x77a3
leaq -0x40(%rbp), %rdi
callq 0x7c10
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
incl %eax
movl %eax, -0x60(%rbp)
movq -0x50(%rbp), %rdi
callq 0x7120
movl -0x64(%rbp), %edi
movl -0x60(%rbp), %esi
movq %rax, %rcx
leaq 0x9181c(%rip), %rdx     # 0x98f53
xorl %eax, %eax
callq 0x73d0
jmp 0x7740
movq 0xaa899(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
callq 0x7300
jmp 0x7751
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %esi
addl $0x18, %esi
movq -0x50(%rbp), %rax
movl 0x20(%rax), %ecx
leaq 0x8c9d4(%rip), %rdx     # 0x94140
xorl %eax, %eax
callq 0x73d0
jmp 0x7775
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x7c30
jmp 0x76e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x7c50
jmp 0x77a9
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x7500
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/flappy.cc
// Function: Display::Display(int, int)
Display(int width = 40, int height = 20) : height{height}, width{width} {
    initscr();
    start_color();
    raw();
    timeout(0);
    noecho();
    curs_set(0);
    keypad(stdscr, TRUE);
    erase();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
callq 0x7460
callq 0x7070
callq 0x70d0
movq 0xaa2f5(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x7350
callq 0x7340
xorl %edi, %edi
callq 0x7250
movq 0xaa2d8(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x7100
movq -0x18(%rbp), %rdi
callq 0x8300
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/flappy.cc
// Function: Display::block_getch()
int block_getch() {
    refresh();
    timeout(-1);
    int c = getch();
    timeout(0);
    return c;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9f20
movq 0xa9d84(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7350
movq 0xa9d70(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
callq 0x70f0
movl %eax, -0xc(%rbp)
movq 0xa9d5e(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
xorl %esi, %esi
callq 0x7350
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/flappy.cc
// Function: Display::erase()
void erase() {
    ::erase();
    for (int y = 0; y < height; y++) {
      mvaddch(y, 0, '|');
      mvaddch(y, width - 1, '|');
    }
    for (int x = 0; x < width; x++) {
      mvaddch(0, x, '-');
      mvaddch(height - 1, x, '-');
    }
    mvaddch(0, 0, '/');
    mvaddch(height - 1, 0, '\\');
    mvaddch(0, width - 1, '\\');
    mvaddch(height - 1, width - 1, '/');
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x7310
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0x839c
movq 0xa9cae(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl -0xc(%rbp), %esi
xorl %edx, %edx
callq 0x72f0
cmpl $-0x1, %eax
jne 0x8346
jmp 0x835a
movq 0xa9c93(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x7c, %esi
callq 0x70b0
movq -0x18(%rbp), %rax
movq 0xa9c7b(%rip), %rcx     # 0xb1fe0
movq (%rcx), %rdi
movl -0xc(%rbp), %esi
movl 0x4(%rax), %edx
subl $0x1, %edx
callq 0x72f0
cmpl $-0x1, %eax
jne 0x837d
jmp 0x8391
movq 0xa9c5c(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x7c, %esi
callq 0x70b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8320
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x841f
movq 0xa9c2a(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x72f0
cmpl $-0x1, %eax
jne 0x83ca
jmp 0x83de
movq 0xa9c0f(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x2d, %esi
callq 0x70b0
movq -0x18(%rbp), %rax
movq 0xa9bf7(%rip), %rcx     # 0xb1fe0
movq (%rcx), %rdi
movl (%rax), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x72f0
cmpl $-0x1, %eax
jne 0x8400
jmp 0x8414
movq 0xa9bd9(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x2d, %esi
callq 0x70b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x83a3
movq 0xa9bba(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x72f0
cmpl $-0x1, %eax
jne 0x8439
jmp 0x844d
movq 0xa9ba0(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x2f, %esi
callq 0x70b0
movq -0x18(%rbp), %rax
movq 0xa9b88(%rip), %rcx     # 0xb1fe0
movq (%rcx), %rdi
movl (%rax), %esi
subl $0x1, %esi
xorl %edx, %edx
callq 0x72f0
cmpl $-0x1, %eax
jne 0x846e
jmp 0x8482
movq 0xa9b6b(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x5c, %esi
callq 0x70b0
movq -0x18(%rbp), %rax
movq 0xa9b53(%rip), %rcx     # 0xb1fe0
movq (%rcx), %rdi
movl 0x4(%rax), %edx
subl $0x1, %edx
xorl %esi, %esi
callq 0x72f0
cmpl $-0x1, %eax
jne 0x84a4
jmp 0x84b8
movq 0xa9b35(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x5c, %esi
callq 0x70b0
movq -0x18(%rbp), %rax
movq 0xa9b1d(%rip), %rcx     # 0xb1fe0
movq (%rcx), %rdi
movl (%rax), %esi
subl $0x1, %esi
movl 0x4(%rax), %edx
subl $0x1, %edx
callq 0x72f0
cmpl $-0x1, %eax
jne 0x84dd
jmp 0x84f1
movq 0xa9afc(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x2f, %esi
callq 0x70b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]flappy/flappy.cc
// Function: Bird::draw()
void draw() {
    init_pair(1, COLOR_YELLOW, COLOR_BLACK);
    attron(COLOR_PAIR(1) | A_BOLD);
    draw('@');
    attroff(COLOR_PAIR(1) | A_BOLD);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %edi
movl $0x3, %esi
xorl %edx, %edx
callq 0x7050
movq 0xa8534(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x200100, %esi         # imm = 0x200100
xorl %eax, %eax
movl %eax, %edx
callq 0x7180
movq -0x10(%rbp), %rdi
movl $0x40, %esi
callq 0xa010
movq 0xa850e(%rip), %rax     # 0xb1fe0
movq (%rax), %rdi
movl $0x200100, %esi         # imm = 0x200100
xorl %eax, %eax
movl %eax, %edx
callq 0x73c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)