LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/state.c
// Function: grow_combine_buffer
static void grow_combine_buffer(VTermState *state)
{
  size_t    new_size = state->combine_chars_size * 2;
  uint32_t *new_chars = vterm_allocator_malloc(state->vt, new_size * sizeof(new_chars[0]));

  memcpy(new_chars, state->combine_chars, state->combine_chars_size * sizeof(new_chars[0]));

  vterm_allocator_free(state->vt, state->combine_chars);

  state->combine_chars = new_chars;
  state->combine_chars_size = new_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
shlq %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
shlq $0x2, %rsi
callq 0x11a20
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdx
shlq $0x2, %rdx
callq 0x2130
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x11ae0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x98(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/state.c
// Function: putglyph
static void putglyph(VTermState *state, const uint32_t chars[], int width, VTermPos pos)
{
  VTermGlyphInfo info = {
    .chars = chars,
    .width = width,
    .protected_cell = state->protected_cell,
    .dwl = state->lineinfo[pos.row].doublewidth,
    .dhl = state->lineinfo[pos.row].doubleheight,
  };

  if(state->callbacks && state->callbacks->putglyph)
    if((*state->callbacks->putglyph)(&info, pos, state->cbdata))
      return;

  DEBUG_LOG("libvterm: Unhandled putglyph U+%04x at (%d,%d)\n", chars[0], pos.col, pos.row);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rcx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movb 0x18c(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movb -0x24(%rbp), %al
andb $0x1, %cl
andb $-0x2, %al
orb %cl, %al
movb %al, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x8(%rbp), %rcx
movb (%rax,%rcx,4), %al
andb $0x1, %al
movzbl %al, %eax
movb %al, %cl
movb -0x24(%rbp), %al
andb $0x1, %cl
shlb %cl
andb $-0x3, %al
orb %cl, %al
movb %al, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0x8(%rbp), %rcx
movb (%rax,%rcx,4), %al
shrb %al
andb $0x3, %al
movzbl %al, %eax
movb %al, %cl
movb -0x24(%rbp), %al
andb $0x3, %cl
shlb $0x2, %cl
andb $-0xd, %al
orb %cl, %al
movb %al, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xf48f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
je 0xf48f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq *%rax
cmpl $0x0, %eax
je 0xf48d
jmp 0xf48f
jmp 0xf48f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/state.c
// Function: linefeed
static void linefeed(VTermState *state)
{
  if(state->pos.row == SCROLLREGION_BOTTOM(state) - 1) {
    VTermRect rect = {
      .start_row = state->scrollregion_top,
      .end_row   = SCROLLREGION_BOTTOM(state),
      .start_col = SCROLLREGION_LEFT(state),
      .end_col   = SCROLLREGION_RIGHT(state),
    };

    scroll(state, rect, 1, 0);
  }
  else if(state->pos.row < state->rows-1)
    state->pos.row++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
jle 0xf4cc
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0xf4d6
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0xf5d4
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
jle 0xf513
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0xf51d
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movw 0xac(%rax), %ax
shrw $0xc, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xf559
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0xf560
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0xf560
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x18(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movw 0xac(%rax), %ax
shrw $0xc, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xf5a6
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
jle 0xf5a6
movq -0x8(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x4c(%rbp)
jmp 0xf5b0
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0xf600
jmp 0xf5f8
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x30(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xf5f6
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0xf5f8
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/state.c
// Function: updatecursor
static void updatecursor(VTermState *state, VTermPos *oldpos, int cancel_phantom)
{
  if(state->pos.col == oldpos->col && state->pos.row == oldpos->row)
    return;

  if(cancel_phantom)
    state->at_phantom = 0;

  if(state->callbacks && state->callbacks->movecursor)
    if((*state->callbacks->movecursor)(state->pos, *oldpos, state->mode.cursor_visible, state->cbdata))
      return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0xfa04
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xfa04
jmp 0xfa73
cmpl $0x0, -0x14(%rbp)
je 0xfa15
movq -0x8(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xfa73
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0xfa73
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rcx
movw 0xac(%rcx), %cx
shrw $0x5, %cx
andw $0x1, %cx
movzwl %cx, %edx
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq 0x38(%rdi), %rdi
movq (%rsi), %rsi
callq *%rax
cmpl $0x0, %eax
je 0xfa71
jmp 0xfa73
jmp 0xfa73
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/state.c
// Function: tab
static void tab(VTermState *state, int count, int direction)
{
  while(count > 0) {
    if(direction > 0) {
      if(state->pos.col >= THISROWWIDTH(state)-1)
        return;

      state->pos.col++;
    }
    else if(direction < 0) {
      if(state->pos.col < 1)
        return;

      state->pos.col--;
    }

    if(is_col_tabstop(state, state->pos.col))
      count--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0xfb49
cmpl $0x0, -0x10(%rbp)
jle 0xfb05
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x38(%rcx), %rcx
movb (%rax,%rcx,4), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xfadd
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
jmp 0xfae7
movq -0x8(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0xfaf6
jmp 0xfb49
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
jmp 0xfb26
cmpl $0x0, -0x10(%rbp)
jge 0xfb24
movq -0x8(%rbp), %rax
cmpl $0x1, 0x3c(%rax)
jge 0xfb17
jmp 0xfb49
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3c(%rax)
jmp 0xfb26
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %esi
callq 0xfb50
cmpl $0x0, %eax
je 0xfb44
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfa92
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/state.c
// Function: savecursor
static void savecursor(VTermState *state, int save)
{
  if(save) {
    state->saved.pos = state->pos;
    state->saved.mode.cursor_visible = state->mode.cursor_visible;
    state->saved.mode.cursor_blink   = state->mode.cursor_blink;
    state->saved.mode.cursor_shape   = state->mode.cursor_shape;

    vterm_state_savepen(state, 1);
  }
  else {
    VTermPos oldpos = state->pos;

    state->pos = state->saved.pos;

    settermprop_bool(state, VTERM_PROP_CURSORVISIBLE, state->saved.mode.cursor_visible);
    settermprop_bool(state, VTERM_PROP_CURSORBLINK,   state->saved.mode.cursor_blink);
    settermprop_int (state, VTERM_PROP_CURSORSHAPE,   state->saved.mode.cursor_shape);

    vterm_state_savepen(state, 0);

    updatecursor(state, &oldpos, 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xfc64
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, 0x190(%rax)
movq -0x8(%rbp), %rax
movw 0xac(%rax), %ax
shrw $0x5, %ax
andw $0x1, %ax
movzwl %ax, %ecx
movq -0x8(%rbp), %rax
movb %cl, %dl
movb 0x1a4(%rax), %cl
andb $0x1, %dl
andb $-0x2, %cl
orb %dl, %cl
movb %cl, 0x1a4(%rax)
movq -0x8(%rbp), %rax
movw 0xac(%rax), %ax
shrw $0x6, %ax
andw $0x1, %ax
movzwl %ax, %ecx
movq -0x8(%rbp), %rax
movb %cl, %dl
movb 0x1a4(%rax), %cl
andb $0x1, %dl
shlb %dl
andb $-0x3, %cl
orb %dl, %cl
movb %cl, 0x1a4(%rax)
movq -0x8(%rbp), %rax
movw 0xac(%rax), %ax
shrw $0x7, %ax
andw $0x3, %ax
movzwl %ax, %ecx
movq -0x8(%rbp), %rax
movb %cl, %dl
movb 0x1a4(%rax), %cl
andb $0x3, %dl
shlb $0x2, %dl
andb $-0xd, %cl
orb %dl, %cl
movb %cl, 0x1a4(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x4990
jmp 0xfcfc
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x190(%rcx), %rcx
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movb 0x1a4(%rax), %al
andb $0x1, %al
movzbl %al, %edx
movl $0x1, %esi
callq 0xa420
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movb 0x1a4(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %edx
movl $0x2, %esi
callq 0xa420
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movb 0x1a4(%rax), %al
shrb $0x2, %al
andb $0x3, %al
movzbl %al, %edx
movl $0x7, %esi
callq 0xa450
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4990
movq -0x8(%rbp), %rdi
leaq -0x14(%rbp), %rsi
movl $0x1, %edx
callq 0xf9d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/state.c
// Function: is_cursor_in_scrollregion
static int is_cursor_in_scrollregion(const VTermState *state)
{
  if(state->pos.row < state->scrollregion_top ||
     state->pos.row >= SCROLLREGION_BOTTOM(state))
    return 0;
  if(state->pos.col < SCROLLREGION_LEFT(state) ||
     state->pos.col >= SCROLLREGION_RIGHT(state))
    return 0;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jl 0xfd5c
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x48(%rax)
jle 0xfd48
movq -0x10(%rbp), %rax
movl 0x48(%rax), %eax
movl %eax, -0x18(%rbp)
jmp 0xfd52
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
cmpl %ecx, %eax
jl 0xfd68
movl $0x0, -0x4(%rbp)
jmp 0xfe09
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movw 0xac(%rax), %ax
shrw $0xc, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xfd99
movq -0x10(%rbp), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0xfda0
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0xfda0
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jl 0xfdf9
movq -0x10(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movw 0xac(%rax), %ax
shrw $0xc, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xfde5
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x50(%rax)
jle 0xfde5
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x28(%rbp)
jmp 0xfdef
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
cmpl %ecx, %eax
jl 0xfe02
movl $0x0, -0x4(%rbp)
jmp 0xfe09
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/state.c
// Function: set_mode
static void set_mode(VTermState *state, int num, int val)
{
  switch(num) {
  case 4: // IRM - ECMA-48 7.2.10
    state->mode.insert = val;
    break;

  case 20: // LNM - ANSI X3.4-1977
    state->mode.newline = val;
    break;

  default:
    DEBUG_LOG("libvterm: Unknown mode %d\n", num);
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x4, %eax
je 0xfe35
jmp 0xfe2b
movl -0x14(%rbp), %eax
subl $0x14, %eax
je 0xfe5e
jmp 0xfe87
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movw %cx, %dx
movw 0xac(%rax), %cx
andw $0x1, %dx
shlw $0x3, %dx
andw $-0x9, %cx
orw %dx, %cx
movw %cx, 0xac(%rax)
jmp 0xfe89
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movw %cx, %dx
movw 0xac(%rax), %cx
andw $0x1, %dx
shlw $0x4, %dx
andw $-0x11, %cx
orw %dx, %cx
movw %cx, 0xac(%rax)
jmp 0xfe89
jmp 0xfe89
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/state.c
// Function: unbase64one
static uint8_t unbase64one(char c)
{
  if(c >= 'A' && c <= 'Z')
    return c - 'A';
  else if(c >= 'a' && c <= 'z')
    return c - 'a' + 26;
  else if(c >= '0' && c <= '9')
    return c - '0' + 52;
  else if(c == '+')
    return 62;
  else if(c == '/')
    return 63;

  return 0xFF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x41, %eax
jl 0x10e28
movsbl -0x2(%rbp), %eax
cmpl $0x5a, %eax
jg 0x10e28
movsbl -0x2(%rbp), %eax
subl $0x41, %eax
movb %al, -0x1(%rbp)
jmp 0x10e94
movsbl -0x2(%rbp), %eax
cmpl $0x61, %eax
jl 0x10e49
movsbl -0x2(%rbp), %eax
cmpl $0x7a, %eax
jg 0x10e49
movsbl -0x2(%rbp), %eax
subl $0x61, %eax
addl $0x1a, %eax
movb %al, -0x1(%rbp)
jmp 0x10e94
movsbl -0x2(%rbp), %eax
cmpl $0x30, %eax
jl 0x10e6a
movsbl -0x2(%rbp), %eax
cmpl $0x39, %eax
jg 0x10e6a
movsbl -0x2(%rbp), %eax
subl $0x30, %eax
addl $0x34, %eax
movb %al, -0x1(%rbp)
jmp 0x10e94
movsbl -0x2(%rbp), %eax
cmpl $0x2b, %eax
jne 0x10e79
movb $0x3e, -0x1(%rbp)
jmp 0x10e94
movsbl -0x2(%rbp), %eax
cmpl $0x2f, %eax
jne 0x10e88
movb $0x3f, -0x1(%rbp)
jmp 0x10e94
jmp 0x10e8a
jmp 0x10e8c
jmp 0x10e8e
jmp 0x10e90
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/unicode.c
// Function: bisearch
static int bisearch(uint32_t ucs, const struct interval *table, int max) {
  int min = 0;
  int mid;

  if (ucs < table[0].first || ucs > table[max].last)
    return 0;
  while (max >= min) {
    mid = (min + max) / 2;
    if (ucs > table[mid].last)
      min = mid + 1;
    else if (ucs < table[mid].first)
      max = mid - 1;
    else
      return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jb 0x11571
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jbe 0x1157a
movl $0x0, -0x4(%rbp)
jmp 0x115e0
jmp 0x1157c
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jl 0x115d9
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jbe 0x115b1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x115d7
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,8), %eax
jae 0x115cc
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x115d5
movl $0x1, -0x4(%rbp)
jmp 0x115e0
jmp 0x115d7
jmp 0x1157c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_new
VTerm *vterm_new(int rows, int cols)
{
  return vterm_build(&(const struct VTermBuilder){
      .rows = rows,
      .cols = cols,
    });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2100
movl -0x4(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_build
VTerm *vterm_build(const struct VTermBuilder *builder)
{
  const VTermAllocatorFunctions *allocator = DEFAULT(builder->allocator, &default_allocator);

  /* Need to bootstrap using the allocator function directly */
  VTerm *vt = (*allocator->malloc)(sizeof(VTerm), builder->allocdata);

  vt->allocator = allocator;
  vt->allocdata = builder->allocdata;

  vt->rows = builder->rows;
  vt->cols = builder->cols;

  vt->parser.state = NORMAL;

  vt->parser.callbacks = NULL;
  vt->parser.cbdata    = NULL;

  vt->parser.emit_nul  = false;

  vt->outfunc = NULL;
  vt->outdata = NULL;

  vt->outbuffer_len = DEFAULT(builder->outbuffer_len, 4096);
  vt->outbuffer_cur = 0;
  vt->outbuffer = vterm_allocator_malloc(vt, vt->outbuffer_len);

  vt->tmpbuffer_len = DEFAULT(builder->tmpbuffer_len, 4096);
  vt->tmpbuffer = vterm_allocator_malloc(vt, vt->tmpbuffer_len);

  return vt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x11845
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x11852
leaq 0x6c6c(%rip), %rax      # 0x184b8
movq %rax, -0x20(%rbp)
jmp 0x11852
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rsi
movl $0x138, %edi            # imm = 0x138
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xd8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xe0(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0xe9(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xf0(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0xf8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x11916
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x11921
movl $0x1000, %eax           # imm = 0x1000
movq %rax, -0x28(%rbp)
jmp 0x11921
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x108(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x110(%rax)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x108(%rax), %rsi
callq 0x11a20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x100(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1197a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x11985
movl $0x1000, %eax           # imm = 0x1000
movq %rax, -0x30(%rbp)
jmp 0x11985
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x120(%rax)
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x120(%rax), %rsi
callq 0x11a20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x118(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_new_with_allocator
VTerm *vterm_new_with_allocator(int rows, int cols, VTermAllocatorFunctions *funcs, void *allocdata)
{
  return vterm_build(&(const struct VTermBuilder){
      .rows = rows,
      .cols = cols,
      .allocator = funcs,
      .allocdata = allocdata,
    });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20d0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_free
void vterm_free(VTerm *vt)
{
  if(vt->screen)
    vterm_screen_free(vt->screen);

  if(vt->state)
    vterm_state_free(vt->state);

  vterm_allocator_free(vt, vt->outbuffer);
  vterm_allocator_free(vt, vt->tmpbuffer);

  vterm_allocator_free(vt, vt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x130(%rax)
je 0x11a7a
movq -0x8(%rbp), %rax
movq 0x130(%rax), %rdi
callq 0x62e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x128(%rax)
je 0x11a98
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rdi
callq 0x9c10
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rsi
callq 0x11ae0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rsi
callq 0x11ae0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x11ae0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_get_size
void vterm_get_size(const VTerm *vt, int *rowsp, int *colsp)
{
  if(rowsp)
    *rowsp = vt->rows;
  if(colsp)
    *colsp = vt->cols;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11b34
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x11b48
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_set_size
void vterm_set_size(VTerm *vt, int rows, int cols)
{
  if(rows < 1 || cols < 1)
    return;

  vt->rows = rows;
  vt->cols = cols;

  if(vt->parser.callbacks && vt->parser.callbacks->resize)
    (*vt->parser.callbacks->resize)(rows, cols, vt->parser.cbdata);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x1, -0xc(%rbp)
jl 0x11b6e
cmpl $0x1, -0x10(%rbp)
jge 0x11b70
jmp 0x11bc6
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x11bc6
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x11bc6
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq 0x48(%rax), %rax
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x8(%rbp), %rcx
movq 0xe0(%rcx), %rdx
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_push_output_bytes
INTERNAL void vterm_push_output_bytes(VTerm *vt, const char *bytes, size_t len)
{
  if(vt->outfunc) {
    (vt->outfunc)(bytes, len, vt->outdata);
    return;
  }

  if(len > vt->outbuffer_len - vt->outbuffer_cur)
    return;

  memcpy(vt->outbuffer + vt->outbuffer_cur, bytes, len);
  vt->outbuffer_cur += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xf0(%rax)
je 0x11c94
movq -0x8(%rbp), %rax
movq 0xf0(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq 0xf8(%rcx), %rdx
callq *%rax
jmp 0x11cee
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x108(%rcx), %rcx
movq -0x8(%rbp), %rdx
subq 0x110(%rdx), %rcx
cmpq %rcx, %rax
jbe 0x11cb5
jmp 0x11cee
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rdi
movq -0x8(%rbp), %rax
addq 0x110(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2130
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x110(%rax), %rcx
movq %rcx, 0x110(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_push_output_sprintf_ctrl
INTERNAL void vterm_push_output_sprintf_ctrl(VTerm *vt, unsigned char ctrl, const char *fmt, ...)
{
  size_t cur;

  if(ctrl >= 0x80 && !vt->mode.ctrl8bit)
    cur = snprintf(vt->tmpbuffer, vt->tmpbuffer_len,
        ESC_S "%c", ctrl - 0x40);
  else
    cur = snprintf(vt->tmpbuffer, vt->tmpbuffer_len,
        "%c", ctrl);

  if(cur >= vt->tmpbuffer_len)
    return;

  va_list args;
  va_start(args, fmt);
  cur += vsnprintf(vt->tmpbuffer + cur, vt->tmpbuffer_len - cur,
      fmt, args);
  va_end(args);

  if(cur >= vt->tmpbuffer_len)
    return;

  vterm_push_output_bytes(vt, vt->tmpbuffer, cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x11e3b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movzbl -0x9(%rbp), %eax
cmpl $0x80, %eax
jl 0x11eaf
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x11eaf
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rsi
movzbl -0x9(%rbp), %ecx
subl $0x40, %ecx
leaq 0x12ff(%rip), %rdx      # 0x1319f
movb $0x0, %al
callq 0x20f0
cltq
movq %rax, -0x20(%rbp)
jmp 0x11edd
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rsi
movzbl -0x9(%rbp), %ecx
leaq 0x12d0(%rip), %rdx      # 0x131a0
movb $0x0, %al
callq 0x20f0
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x120(%rcx), %rax
jb 0x11ef3
jmp 0x11f7b
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rdi
addq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x120(%rax), %rsi
subq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x2090
cltq
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rax
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x120(%rcx), %rax
jb 0x11f63
jmp 0x11f7b
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x118(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x11c50
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_output_read
size_t vterm_output_read(VTerm *vt, char *buffer, size_t len)
{
  if(len > vt->outbuffer_cur)
    len = vt->outbuffer_cur;

  memcpy(buffer, vt->outbuffer, len);

  if(len < vt->outbuffer_cur)
    memmove(vt->outbuffer, vt->outbuffer + len, vt->outbuffer_cur - len);

  vt->outbuffer_cur -= len;

  return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jbe 0x12234
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x2130
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x110(%rcx), %rax
jae 0x1228b
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x100(%rax), %rsi
addq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rdx
subq -0x18(%rbp), %rdx
callq 0x21b0
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x110(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x110(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_get_attr_type
VTermValueType vterm_get_attr_type(VTermAttr attr)
{
  switch(attr) {
    case VTERM_ATTR_BOLD:       return VTERM_VALUETYPE_BOOL;
    case VTERM_ATTR_UNDERLINE:  return VTERM_VALUETYPE_INT;
    case VTERM_ATTR_ITALIC:     return VTERM_VALUETYPE_BOOL;
    case VTERM_ATTR_BLINK:      return VTERM_VALUETYPE_BOOL;
    case VTERM_ATTR_REVERSE:    return VTERM_VALUETYPE_BOOL;
    case VTERM_ATTR_CONCEAL:    return VTERM_VALUETYPE_BOOL;
    case VTERM_ATTR_STRIKE:     return VTERM_VALUETYPE_BOOL;
    case VTERM_ATTR_FONT:       return VTERM_VALUETYPE_INT;
    case VTERM_ATTR_FOREGROUND: return VTERM_VALUETYPE_COLOR;
    case VTERM_ATTR_BACKGROUND: return VTERM_VALUETYPE_COLOR;
    case VTERM_ATTR_SMALL:      return VTERM_VALUETYPE_BOOL;
    case VTERM_ATTR_BASELINE:   return VTERM_VALUETYPE_INT;

    case VTERM_N_ATTRS: return 0;
  }
  return 0; /* UNREACHABLE */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xc, %eax
ja 0x12354
movq -0x10(%rbp), %rax
leaq 0x1e7a(%rip), %rcx      # 0x14150
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x1235b
movl $0x2, -0x4(%rbp)
jmp 0x1235b
movl $0x1, -0x4(%rbp)
jmp 0x1235b
movl $0x1, -0x4(%rbp)
jmp 0x1235b
movl $0x1, -0x4(%rbp)
jmp 0x1235b
movl $0x1, -0x4(%rbp)
jmp 0x1235b
movl $0x1, -0x4(%rbp)
jmp 0x1235b
movl $0x2, -0x4(%rbp)
jmp 0x1235b
movl $0x4, -0x4(%rbp)
jmp 0x1235b
movl $0x4, -0x4(%rbp)
jmp 0x1235b
movl $0x1, -0x4(%rbp)
jmp 0x1235b
movl $0x2, -0x4(%rbp)
jmp 0x1235b
movl $0x0, -0x4(%rbp)
jmp 0x1235b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_get_prop_type
VTermValueType vterm_get_prop_type(VTermProp prop)
{
  switch(prop) {
    case VTERM_PROP_CURSORVISIBLE: return VTERM_VALUETYPE_BOOL;
    case VTERM_PROP_CURSORBLINK:   return VTERM_VALUETYPE_BOOL;
    case VTERM_PROP_ALTSCREEN:     return VTERM_VALUETYPE_BOOL;
    case VTERM_PROP_TITLE:         return VTERM_VALUETYPE_STRING;
    case VTERM_PROP_ICONNAME:      return VTERM_VALUETYPE_STRING;
    case VTERM_PROP_REVERSE:       return VTERM_VALUETYPE_BOOL;
    case VTERM_PROP_CURSORSHAPE:   return VTERM_VALUETYPE_INT;
    case VTERM_PROP_MOUSE:         return VTERM_VALUETYPE_INT;
    case VTERM_PROP_FOCUSREPORT:   return VTERM_VALUETYPE_BOOL;

    case VTERM_N_PROPS: return 0;
  }
  return 0; /* UNREACHABLE */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x9, %eax
ja 0x123e5
movq -0x10(%rbp), %rax
leaq 0x1e02(%rip), %rcx      # 0x14184
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x123ec
movl $0x1, -0x4(%rbp)
jmp 0x123ec
movl $0x1, -0x4(%rbp)
jmp 0x123ec
movl $0x3, -0x4(%rbp)
jmp 0x123ec
movl $0x3, -0x4(%rbp)
jmp 0x123ec
movl $0x1, -0x4(%rbp)
jmp 0x123ec
movl $0x2, -0x4(%rbp)
jmp 0x123ec
movl $0x2, -0x4(%rbp)
jmp 0x123ec
movl $0x1, -0x4(%rbp)
jmp 0x123ec
movl $0x0, -0x4(%rbp)
jmp 0x123ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_copy_cells
void vterm_copy_cells(VTermRect dest,
    VTermRect src,
    void (*copycell)(VTermPos dest, VTermPos src, void *user),
    void *user)
{
  int downward  = src.start_row - dest.start_row;
  int rightward = src.start_col - dest.start_col;

  int init_row, test_row, init_col, test_col;
  int inc_row, inc_col;

  if(downward < 0) {
    init_row = dest.end_row - 1;
    test_row = dest.start_row - 1;
    inc_row = -1;
  }
  else /* downward >= 0 */ {
    init_row = dest.start_row;
    test_row = dest.end_row;
    inc_row = +1;
  }

  if(rightward < 0) {
    init_col = dest.end_col - 1;
    test_col = dest.start_col - 1;
    inc_col = -1;
  }
  else /* rightward >= 0 */ {
    init_col = dest.start_col;
    test_col = dest.end_col;
    inc_col = +1;
  }

  VTermPos pos;
  for(pos.row = init_row; pos.row != test_row; pos.row += inc_row)
    for(pos.col = init_col; pos.col != test_col; pos.col += inc_col) {
      VTermPos srcpos = { pos.row + downward, pos.col + rightward };
      (*copycell)(pos, srcpos, user);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl -0x20(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x18(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x34(%rbp)
jge 0x125d3
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x3c(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
movl $0xffffffff, -0x4c(%rbp) # imm = 0xFFFFFFFF
jmp 0x125e6
movl -0x10(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x40(%rbp)
movl $0x1, -0x4c(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x12607
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x44(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x48(%rbp)
movl $0xffffffff, -0x50(%rbp) # imm = 0xFFFFFFFF
jmp 0x1261a
movl -0x8(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x48(%rbp)
movl $0x1, -0x50(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
cmpl -0x40(%rbp), %eax
je 0x12672
movl -0x44(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x48(%rbp), %eax
je 0x12665
movl -0x58(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x54(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rdx
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq *%rax
movl -0x50(%rbp), %eax
addl -0x54(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x1262e
jmp 0x12667
movl -0x4c(%rbp), %eax
addl -0x58(%rbp), %eax
movl %eax, -0x58(%rbp)
jmp 0x12620
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: vterm_check_version
void vterm_check_version(int major, int minor)
{
  if(major != VTERM_VERSION_MAJOR) {
    fprintf(stderr, "libvterm major version mismatch; %d (wants) != %d (library)\n",
        major, VTERM_VERSION_MAJOR);
    exit(1);
  }

  if(minor > VTERM_VERSION_MINOR) {
    fprintf(stderr, "libvterm minor version mismatch; %d (wants) > %d (library)\n",
        minor, VTERM_VERSION_MINOR);
    exit(1);
  }

  // Happy
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x126bb
movq 0x595d(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x1b04(%rip), %rsi      # 0x141ac
xorl %ecx, %ecx
movb $0x0, %al
callq 0x2120
movl $0x1, %edi
callq 0x21f0
cmpl $0x3, -0x8(%rbp)
jle 0x126eb
movq 0x5930(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x1b14(%rip), %rsi      # 0x141e9
movl $0x3, %ecx
movb $0x0, %al
callq 0x2120
movl $0x1, %edi
callq 0x21f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/vterm.c
// Function: default_malloc
static void *default_malloc(size_t size, void *allocdata)
{
  void *ptr = malloc(size);
  if(ptr)
    memset(ptr, 0, size);
  return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12733
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x2100
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/csidh_util.c
// Function: pprint_ss
void pprint_ss(uint64_t *x)
{
    /* for p512 we print 8 64bit little endian values as hex. */
    int ceiling = 7;
    int i;
    for(i=ceiling; i >= 0; --i){
        printf("%.16" PRIX64 "", x[i]);
    }
    printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x7, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jl 0x1319
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x3d96(%rip), %rdi      # 0x509b
movb $0x0, %al
callq 0x1050
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x12e9
leaq 0x3ed9(%rip), %rdi      # 0x51f9
movb $0x0, %al
callq 0x1050
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/csidh_util.c
// Function: save_file
void save_file(char *file, void *buf, size_t len) {
  FILE *fhandle;
  if (file != NULL) {
    fhandle = fopen(file, "w");
    if (fhandle == NULL) {
      fprintf(stderr, "Unable to open %s\n", file);
      exit(1);
    }
    for (size_t i = 0; i < len; ++i)
      fprintf(fhandle, "%02hhx", ((uint8_t *)buf)[i]);
    fprintf(fhandle, "\n");
    fclose(fhandle);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x13f2
movq 0x20(%rsp), %rdi
leaq 0x3d47(%rip), %rsi      # 0x50a2
callq 0x10d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1394
movq 0x5c84(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x3d21(%rip), %rsi      # 0x50a4
movb $0x0, %al
callq 0x10a0
movl $0x1, %edi
callq 0x1100
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x13d5
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x3cd4(%rip), %rsi      # 0x5094
movb $0x0, %al
callq 0x10a0
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x139c
movq 0x8(%rsp), %rdi
leaq 0x3e18(%rip), %rsi      # 0x51f9
movb $0x0, %al
callq 0x10a0
movq 0x8(%rsp), %rdi
callq 0x1040
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/csidh_util.c
// Function: read_file
uint64_t read_file(const char *file, uint8_t *buf, size_t len) {
  size_t c = 0;
  FILE *fhandle;
  fhandle = fopen(file, "r");
  if (fhandle == NULL) {
    fprintf(stderr, "Unable to open %s\n", file);
    exit(3);
  }
  for (uint64_t i = 0; i < len; ++i) {
    c += fscanf(fhandle, "%02hhx", &buf[i]);
  }
  fclose(fhandle);
  return c;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x3ff8(%rip), %rsi      # 0x5450
callq 0x10d0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1491
movq 0x5b87(%rip), %rax      # 0x6ff8
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
leaq 0x3c24(%rip), %rsi      # 0x50a4
movb $0x0, %al
callq 0x10a0
movl $0x3, %edi
callq 0x1100
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x14df
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rdx
addq 0x8(%rsp), %rdx
leaq 0x3bd8(%rip), %rsi      # 0x5094
movb $0x0, %al
callq 0x1030
cltq
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x149a
movq 0x10(%rsp), %rdi
callq 0x1040
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ioerror[P]csidh-reference-implementation/csidh_util.c
// Function: read_stdin
uint64_t read_stdin(uint8_t *buf, uint64_t len) {
  uint64_t c = 0;
  for (uint64_t i = 0; i < len; ++i) {
    c += fscanf(stdin, "%02hhx", &buf[i]);
  }
  return c;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x156a
movq 0x5a9d(%rip), %rax      # 0x6fd0
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
addq 0x8(%rsp), %rdx
leaq 0x3b4d(%rip), %rsi      # 0x5094
movb $0x0, %al
callq 0x1030
cltq
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1520
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: fd_type
static bool
fd_type(int fd, mode_t type)
{
	struct stat sb;
	bool rv = false;

	if (fstat(fd, &sb) < 0)
		return rv;

	switch (type) {
	case FD_ISOPEN:
		rv = true;
		break;
	case FD_ISDIROK:
		if (S_ISDIR(sb.st_mode))
			rv = sb.st_nlink > 0;
		break;
	case FD_ISREGOK:
		if (S_ISREG(sb.st_mode))
			rv = sb.st_nlink > 0;
		break;
	case FD_ISDIR:
	case FD_ISREG:
		rv = (sb.st_mode & FD_TMASK) == type;
		break;
	}
	return rv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xa1(%rbp)
movl -0x8(%rbp), %edi
leaq -0xa0(%rbp), %rsi
callq 0x2390
cmpl $0x0, %eax
jge 0x2bcc
movb -0xa1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2c8f
movl -0xc(%rbp), %eax
movl %eax, -0xa8(%rbp)
subl $0x1, %eax
je 0x2c14
jmp 0x2bdc
movl -0xa8(%rbp), %eax
subl $0x2, %eax
je 0x2c1d
jmp 0x2be9
movl -0xa8(%rbp), %eax
subl $0x4, %eax
je 0x2c44
jmp 0x2bf6
movl -0xa8(%rbp), %eax
subl $0x4000, %eax           # imm = 0x4000
je 0x2c6b
jmp 0x2c05
movl -0xa8(%rbp), %eax
subl $0x8000, %eax           # imm = 0x8000
je 0x2c6b
jmp 0x2c84
movb $0x1, -0xa1(%rbp)
jmp 0x2c84
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x2c42
cmpq $0x0, -0x90(%rbp)
seta %al
andb $0x1, %al
movb %al, -0xa1(%rbp)
jmp 0x2c84
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x2c69
cmpq $0x0, -0x90(%rbp)
seta %al
andb $0x1, %al
movb %al, -0xa1(%rbp)
jmp 0x2c84
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl -0xc(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0xa1(%rbp)
movb -0xa1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: fd_free
static void
fd_free(void)
{
	long fd_max;
	int fd;

	fd_max = sysconf(_SC_OPEN_MAX);
	if (fd_max < FDFREEMIN || fd_max > FDFREEMAX)
		fd_max = FDFREEMIN;
	for (fd = (int)fd_max - 1; fd > DUPFD0; fd--)
		(void)close(fd);
	for (fd--; fd > FD2; fd--)
		(void)close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x4, %edi
callq 0x2340
movq %rax, -0x8(%rbp)
cmpq $0x14, -0x8(%rbp)
jl 0x2d07
cmpq $0x1000, -0x8(%rbp)     # imm = 0x1000
jle 0x2d0f
movq $0x14, -0x8(%rbp)
movq -0x8(%rbp), %rax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jle 0x2d32
movl -0xc(%rbp), %edi
callq 0x21d0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d19
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jle 0x2d54
movl -0xc(%rbp), %edi
callq 0x21d0
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d3b
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: rc_init
static void
rc_init(int *rcflag)
{
	char path[PATHMAX];
	const char *file;

	while (*rcflag <= DO_INIT_DONE) {
		file = NULL;
		switch (*rcflag) {
		case DO_SYSTEM_LOGIN:
			file = PATH_SYSTEM_LOGIN;
			break;
		case DO_SYSTEM_OSHRC:
			if (!is_login)
				(*rcflag)++;
			file = PATH_SYSTEM_OSHRC;
			break;
		case DO_DOT_LOGIN:
			file = pn_build(path, FILE_DOT_LOGIN, sizeof(path));
			break;
		case DO_DOT_OSHRC:
			file = pn_build(path, FILE_DOT_OSHRC, sizeof(path));
			break;
		case DO_INIT_DONE:
			if (dup2(dupfd0, FD0) == -1)
				err(SH_ERR,FMT2S,getmyname(),strerror(errno));
			shtype &= ~ST_RCFILE;
			(*rcflag)++;
			return;
		default:
			shtype &= ~ST_RCFILE;
			return;
		}
		(*rcflag)++;
		if (rc_open(file))
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x5, (%rax)
jg 0x2eef
movq $0x0, -0x1018(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x1020(%rbp)
subl $0x4, %eax
ja 0x2eba
movq -0x1020(%rbp), %rax
leaq 0x8339(%rip), %rcx      # 0xb108
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8c34(%rip), %rax      # 0xba13
movq %rax, -0x1018(%rbp)
jmp 0x2ecb
testb $0x1, 0xb456(%rip)      # 0xe248
jne 0x2dff
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq 0x8c26(%rip), %rax      # 0xba2c
movq %rax, -0x1018(%rbp)
jmp 0x2ecb
leaq -0x1010(%rbp), %rdi
leaq 0x8c25(%rip), %rsi      # 0xba45
movl $0x1000, %edx           # imm = 0x1000
callq 0x8900
movq %rax, -0x1018(%rbp)
jmp 0x2ecb
leaq -0x1010(%rbp), %rdi
leaq 0x8bfa(%rip), %rsi      # 0xba3e
movl $0x1000, %edx           # imm = 0x1000
callq 0x8900
movq %rax, -0x1018(%rbp)
jmp 0x2ecb
movl 0x1051f(%rip), %edi     # 0x1337c
xorl %esi, %esi
callq 0x2160
cmpl $-0x1, %eax
jne 0x2e9e
callq 0x8df0
movq %rax, -0x1028(%rbp)
callq 0x2070
movl (%rax), %edi
callq 0x2380
movq -0x1028(%rbp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x890a(%rip), %rsi      # 0xb7a1
movb $0x0, %al
callq 0x8af0
movl 0xb398(%rip), %eax      # 0xe23c
andl $-0x9, %eax
movl %eax, 0xb38f(%rip)      # 0xe23c
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2eef
movl 0xb37c(%rip), %eax      # 0xe23c
andl $-0x9, %eax
movl %eax, 0xb373(%rip)      # 0xe23c
jmp 0x2eef
movq -0x8(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x1018(%rbp), %rdi
callq 0x89d0
testb $0x1, %al
jne 0x2ee8
jmp 0x2eea
jmp 0x2eef
jmp 0x2d8f
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/s3lase[P]v6shell/osh.c
// Function: hist_open
static void
hist_open(void)
{
	char path[PATHMAX];
	const char *file;
	int fd, fdw;

	hwfd = -1;
	file = pn_build(path, FILE_DOT_HISTORY, sizeof(path));
	if ((fd = open(file, O_WRONLY | O_APPEND | O_NONBLOCK)) == -1)
		return;
	if (!fd_type(fd, FD_ISREG)) {
		(void)close(fd);
		return;
	}
	if ((fdw = dup2(fd, HWFD)) == -1 ||
	     fcntl(fdw, F_SETFL, (O_WRONLY | O_APPEND) & ~O_NONBLOCK) == -1 ||
	     fcntl(fdw, F_SETFD, FD_CLOEXEC) == -1) {
		(void)close(fd);
		(void)close(fdw);
		return;
	}
	(void)close(fd);
	hwfd = fdw;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
movl $0xffffffff, 0xb2e3(%rip) # imm = 0xFFFFFFFF
leaq -0x1000(%rbp), %rdi
leaq 0x8b68(%rip), %rsi      # 0xba8b
movl $0x1000, %edx           # imm = 0x1000
callq 0x8900
movq %rax, -0x1008(%rbp)
movq -0x1008(%rbp), %rdi
movl $0xc01, %esi            # imm = 0xC01
movb $0x0, %al
callq 0x2320
movl %eax, -0x100c(%rbp)
cmpl $-0x1, %eax
jne 0x2f57
jmp 0x2ffd
movl -0x100c(%rbp), %edi
movl $0x8000, %esi           # imm = 0x8000
callq 0x2b90
testb $0x1, %al
jne 0x2f7b
movl -0x100c(%rbp), %edi
callq 0x21d0
jmp 0x2ffd
movl -0x100c(%rbp), %edi
movl $0xb, %esi
callq 0x2160
movl %eax, -0x1010(%rbp)
cmpl $-0x1, %eax
je 0x2fce
movl -0x1010(%rbp), %edi
movl $0x4, %esi
movl $0x401, %edx            # imm = 0x401
movb $0x0, %al
callq 0x20d0
cmpl $-0x1, %eax
je 0x2fce
movl -0x1010(%rbp), %edi
movl $0x2, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x20d0
cmpl $-0x1, %eax
jne 0x2fe6
movl -0x100c(%rbp), %edi
callq 0x21d0
movl -0x1010(%rbp), %edi
callq 0x21d0
jmp 0x2ffd
movl -0x100c(%rbp), %edi
callq 0x21d0
movl -0x1010(%rbp), %eax
movl %eax, 0xb1fb(%rip)      # 0xe1f8
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
nopw %cs:(%rax,%rax)