LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/common.c
// Function: ignore_signal
int ignore_signal(int signum)
{
	struct sigaction action;
	int ret;

	ret = sigaction(signum, NULL, &action);
	if (ret < 0)
		return -errno;
	action.sa_handler = SIG_IGN;
	ret = sigaction(signum, &action, NULL);
	if (ret < 0)
		return -errno;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
leaq -0xa0(%rbp), %rdx
callq 0x1050
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
jge 0x2c41
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x2c87
movl $0x1, %eax
movq %rax, -0xa0(%rbp)
movl -0x8(%rbp), %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1050
movl %eax, -0xa4(%rbp)
cmpl $0x0, -0xa4(%rbp)
jge 0x2c80
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x2c87
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/common.c
// Function: send_block
int send_block(int sd, const void *buff, unsigned int length)
{
	const unsigned char *bp = buff;
	unsigned int rest = length;
	ssize_t chunk;

	while (rest > 0) {
		chunk = send(sd, bp, rest, 0);
		if (chunk < 0) {
			if (errno == EINTR)
				continue;
			return -errno;
		}

		bp += chunk;
		rest -= chunk;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jbe 0x2d1c
movl -0x8(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x10b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jge 0x2d01
callq 0x1040
cmpl $0x4, (%rax)
jne 0x2cf0
jmp 0x2cc0
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x2d23
movq -0x30(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x24(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x24(%rbp)
jmp 0x2cc0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/common.c
// Function: recv_block
int recv_block(int sd, void *buff, unsigned int length)
{
	unsigned int rest = length;
	unsigned char *bp = buff;
	ssize_t chunk;

	while (rest > 0) {
		chunk = recv(sd, bp, rest, MSG_WAITALL);
		if (chunk < 0) {
			if (errno == EINTR)
				continue;
			return -errno;
		}
		if (!chunk)
			return -EINVAL;

		bp += chunk;
		rest -= chunk;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jbe 0x2dbf
movl -0x8(%rbp), %edi
movq -0x20(%rbp), %rsi
movl -0x18(%rbp), %eax
movl %eax, %edx
movl $0x100, %ecx            # imm = 0x100
callq 0x1030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x2d94
callq 0x1040
cmpl $0x4, (%rax)
jne 0x2d83
jmp 0x2d50
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x2dc6
cmpq $0x0, -0x28(%rbp)
jne 0x2da4
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x2dc6
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x18(%rbp)
jmp 0x2d50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mkubecek[P]nperf/common.c
// Function: ctrl_recv_msg
int ctrl_recv_msg(int sd, void *buff, unsigned int length)
{
	const struct __common_ctrl_header *hdr = buff;
	unsigned int rest = length;
	unsigned char *bp = buff;
	ssize_t chunk;

	while (rest > length - sizeof(*hdr)) {
		chunk = recv(sd, bp, rest, 0);
		if (chunk < 0) {
			if (errno == EINTR)
				continue;
			return -errno;
		}
		if (!chunk)
			return -EINVAL;

		bp += chunk;
		rest -= chunk;
	}

	if (ntohl(hdr->length) != length || ntohl(hdr->version) != CTRL_VERSION)
		return -EINVAL;

	while (rest > 0) {
		chunk = recv(sd, bp, rest, MSG_WAITALL);
		if (chunk < 0)
			return -errno;

		bp += chunk;
		rest -= chunk;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
subq $0x8, %rcx
cmpq %rcx, %rax
jbe 0x2ea3
movl -0x8(%rbp), %edi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x1030
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x2e75
callq 0x1040
cmpl $0x4, (%rax)
jne 0x2e61
jmp 0x2e28
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f29
cmpq $0x0, -0x38(%rbp)
jne 0x2e88
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x2f29
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x24(%rbp)
jmp 0x2e28
movq -0x20(%rbp), %rax
movl (%rax), %edi
callq 0x1230
cmpl -0x14(%rbp), %eax
jne 0x2ec4
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x1230
cmpl $0x1, %eax
je 0x2ecd
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0x2f29
jmp 0x2ecf
cmpl $0x0, -0x24(%rbp)
jbe 0x2f22
movl -0x8(%rbp), %edi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
movl $0x100, %ecx            # imm = 0x100
callq 0x1030
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x2f07
callq 0x1040
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
movl %eax, -0x4(%rbp)
jmp 0x2f29
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
subq %rcx, %rax
movl %eax, -0x24(%rbp)
jmp 0x2ecf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/encoding.c
// Function: vterm_lookup_encoding
VTermEncoding *vterm_lookup_encoding(VTermEncodingType type, char designation)
{
  for(int i = 0; encodings[i].designation; i++)
    if(encodings[i].type == type && encodings[i].designation == designation)
      return encodings[i].enc;
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movl %edi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x15e11(%rip), %rax     # 0x18120
shlq $0x4, %rcx
addq %rcx, %rax
cmpb $0x0, 0x4(%rax)
je 0x237c
movslq -0x14(%rbp), %rcx
leaq 0x15df9(%rip), %rax     # 0x18120
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x236f
movslq -0x14(%rbp), %rcx
leaq 0x15de0(%rip), %rax     # 0x18120
shlq $0x4, %rcx
addq %rcx, %rax
movsbl 0x4(%rax), %eax
movsbl -0xd(%rbp), %ecx
cmpl %ecx, %eax
jne 0x236f
movslq -0x14(%rbp), %rcx
leaq 0x15dc2(%rip), %rax     # 0x18120
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2384
jmp 0x2371
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2304
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/encoding.c
// Function: decode_table
static void decode_table(VTermEncoding *enc, void *data,
                         uint32_t cp[], int *cpi, int cplen,
                         const char bytes[], size_t *pos, size_t bytelen)
{
  struct StaticTableEncoding *table = (struct StaticTableEncoding *)enc;
  int is_gr = bytes[*pos] & 0x80;

  for(; *pos < bytelen && *cpi < cplen; (*pos)++) {
    unsigned char c = bytes[*pos] ^ is_gr;

    if(c < 0x20 || c == 0x7f || c >= 0x80)
      return;

    if(table->chars[c])
      cp[(*cpi)++] = table->chars[c];
    else
      cp[(*cpi)++] = c;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
andl $0x80, %eax
movl %eax, -0x3c(%rbp)
movq 0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq 0x18(%rbp), %rcx
movb %al, -0x3e(%rbp)
jae 0x28c4
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
setl %al
movb %al, -0x3e(%rbp)
movb -0x3e(%rbp), %al
testb $0x1, %al
jne 0x28d0
jmp 0x2968
movq -0x30(%rbp), %rax
movq 0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
xorl -0x3c(%rbp), %eax
movb %al, -0x3d(%rbp)
movzbl -0x3d(%rbp), %eax
cmpl $0x20, %eax
jl 0x2902
movzbl -0x3d(%rbp), %eax
cmpl $0x7f, %eax
je 0x2902
movzbl -0x3d(%rbp), %eax
cmpl $0x80, %eax
jl 0x2904
jmp 0x2968
movq -0x38(%rbp), %rax
movzbl -0x3d(%rbp), %ecx
cmpl $0x0, 0x10(%rax,%rcx,4)
je 0x2938
movq -0x38(%rbp), %rax
movzbl -0x3d(%rbp), %ecx
movl 0x10(%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2953
movzbl -0x3d(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2955
movq 0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x28a3
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/encoding.c
// Function: decode_usascii
static void decode_usascii(VTermEncoding *enc, void *data,
                           uint32_t cp[], int *cpi, int cplen,
                           const char bytes[], size_t *pos, size_t bytelen)
{
  int is_gr = bytes[*pos] & 0x80;

  for(; *pos < bytelen && *cpi < cplen; (*pos)++) {
    unsigned char c = bytes[*pos] ^ is_gr;

    if(c < 0x20 || c == 0x7f || c >= 0x80)
      return;

    cp[(*cpi)++] = c;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
andl $0x80, %eax
movl %eax, -0x34(%rbp)
movq 0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq 0x18(%rbp), %rcx
movb %al, -0x36(%rbp)
jae 0x29cc
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
setl %al
movb %al, -0x36(%rbp)
movb -0x36(%rbp), %al
testb $0x1, %al
jne 0x29d5
jmp 0x2a37
movq -0x30(%rbp), %rax
movq 0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rax,%rcx), %eax
xorl -0x34(%rbp), %eax
movb %al, -0x35(%rbp)
movzbl -0x35(%rbp), %eax
cmpl $0x20, %eax
jl 0x2a07
movzbl -0x35(%rbp), %eax
cmpl $0x7f, %eax
je 0x2a07
movzbl -0x35(%rbp), %eax
cmpl $0x80, %eax
jl 0x2a09
jmp 0x2a37
movzbl -0x35(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x29ab
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/keyboard.c
// Function: vterm_keyboard_unichar
void vterm_keyboard_unichar(VTerm *vt, uint32_t c, VTermModifier mod)
{
  /* The shift modifier is never important for Unicode characters
   * apart from Space
   */
  if(c != ' ')
    mod &= ~VTERM_MOD_SHIFT;

  if(mod == 0) {
    // Normal text - ignore just shift
    char str[6];
    int seqlen = fill_utf8(c, str);
    vterm_push_output_bytes(vt, str, seqlen);
    return;
  }

  int needs_CSIu;
  switch(c) {
    /* Special Ctrl- letters that can't be represented elsewise */
    case 'i': case 'j': case 'm': case '[':
      needs_CSIu = 1;
      break;
    /* Ctrl-\ ] ^ _ don't need CSUu */
    case '\\': case ']': case '^': case '_':
      needs_CSIu = 0;
      break;
    /* Shift-space needs CSIu */
    case ' ':
      needs_CSIu = !!(mod & VTERM_MOD_SHIFT);
      break;
    /* All other characters needs CSIu except for letters a-z */
    default:
      needs_CSIu = (c < 'a' || c > 'z');
  }

  /* ALT we can just prefix with ESC; anything else requires CSI u */
  if(needs_CSIu && (mod & ~VTERM_MOD_ALT)) {
    vterm_push_output_sprintf_ctrl(vt, C1_CSI, "%d;%du", c, mod+1);
    return;
  }

  if(mod & VTERM_MOD_CTRL)
    c &= 0x1f;

  vterm_push_output_sprintf(vt, "%s%c", mod & VTERM_MOD_ALT ? ESC_S : "", c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x20, -0xc(%rbp)
je 0x2a61
movl -0x10(%rbp), %eax
andl $-0x2, %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x2a8e
movl -0xc(%rbp), %eax
movl %eax, %edi
leaq -0x16(%rbp), %rsi
callq 0x2b80
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x16(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x11c50
jmp 0x2b78
movl -0xc(%rbp), %eax
addl $-0x20, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x4d, %eax
ja 0x2adf
movq -0x28(%rbp), %rax
leaq 0x1056a(%rip), %rcx     # 0x13014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x20(%rbp)
jmp 0x2aff
movl $0x0, -0x20(%rbp)
jmp 0x2aff
movl -0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
jmp 0x2aff
movb $0x1, %al
cmpl $0x61, -0xc(%rbp)
movb %al, -0x29(%rbp)
jb 0x2af4
cmpl $0x7a, -0xc(%rbp)
seta %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x2b34
movl -0x10(%rbp), %eax
andl $-0x3, %eax
cmpl $0x0, %eax
je 0x2b34
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
addl $0x1, %r8d
movl $0x9b, %esi
leaq 0x1065d(%rip), %rdx     # 0x13188
movb $0x0, %al
callq 0x11e00
jmp 0x2b78
movl -0x10(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2b48
movl -0xc(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %ecx
andl $0x2, %ecx
leaq 0x10645(%rip), %rdx     # 0x1319e
leaq 0x10634(%rip), %rax     # 0x13194
cmpl $0x0, %ecx
cmovneq %rax, %rdx
movl -0xc(%rbp), %ecx
leaq 0x1061e(%rip), %rsi     # 0x1318f
movb $0x0, %al
callq 0x11d60
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/utf8.h
// Function: fill_utf8
static int fill_utf8(long codepoint, char *str)
{
  int nbytes = utf8_seqlen(codepoint);

  // This is easier done backwards
  int b = nbytes;
  while(b > 1) {
    b--;
    str[b] = 0x80 | (codepoint & 0x3f);
    codepoint >>= 6;
  }

  switch(nbytes) {
    case 1: str[0] =        (codepoint & 0x7f); break;
    case 2: str[0] = 0xc0 | (codepoint & 0x1f); break;
    case 3: str[0] = 0xe0 | (codepoint & 0x0f); break;
    case 4: str[0] = 0xf0 | (codepoint & 0x07); break;
    case 5: str[0] = 0xf8 | (codepoint & 0x03); break;
    case 6: str[0] = 0xfc | (codepoint & 0x01); break;
  }

  return nbytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3080
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jle 0x2bda
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
andq $0x3f, %rax
orq $0x80, %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
sarq $0x6, %rax
movq %rax, -0x8(%rbp)
jmp 0x2ba2
movl -0x14(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x2c8a
movq -0x20(%rbp), %rax
leaq 0x10553(%rip), %rcx     # 0x1314c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
andq $0x7f, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x2c8a
movq -0x8(%rbp), %rax
andq $0x1f, %rax
orq $0xc0, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x2c8a
movq -0x8(%rbp), %rax
andq $0xf, %rax
orq $0xe0, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x2c8a
movq -0x8(%rbp), %rax
andq $0x7, %rax
orq $0xf0, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x2c8a
movq -0x8(%rbp), %rax
andq $0x3, %rax
orq $0xf8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0x2c8a
movq -0x8(%rbp), %rax
andq $0x1, %rax
orq $0xfc, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/utf8.h
// Function: utf8_seqlen
static inline unsigned int utf8_seqlen(long codepoint)
{
  if(codepoint < 0x0000080) return 1;
  if(codepoint < 0x0000800) return 2;
  if(codepoint < 0x0010000) return 3;
  if(codepoint < 0x0200000) return 4;
  if(codepoint < 0x4000000) return 5;
  return 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x80, -0x10(%rbp)
jge 0x309b
movl $0x1, -0x4(%rbp)
jmp 0x30ee
cmpq $0x800, -0x10(%rbp)     # imm = 0x800
jge 0x30ae
movl $0x2, -0x4(%rbp)
jmp 0x30ee
cmpq $0x10000, -0x10(%rbp)   # imm = 0x10000
jge 0x30c1
movl $0x3, -0x4(%rbp)
jmp 0x30ee
cmpq $0x200000, -0x10(%rbp)  # imm = 0x200000
jge 0x30d4
movl $0x4, -0x4(%rbp)
jmp 0x30ee
cmpq $0x4000000, -0x10(%rbp) # imm = 0x4000000
jge 0x30e7
movl $0x5, -0x4(%rbp)
jmp 0x30ee
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/mouse.c
// Function: vterm_mouse_move
void vterm_mouse_move(VTerm *vt, int row, int col, VTermModifier mod)
{
  VTermState *state = vt->state;

  if(col == state->mouse_col && row == state->mouse_row)
    return;

  state->mouse_col = col;
  state->mouse_row = row;

  if((state->mouse_flags & MOUSE_WANT_DRAG && state->mouse_buttons) ||
     (state->mouse_flags & MOUSE_WANT_MOVE)) {
    int button = state->mouse_buttons & 0x01 ? 1 :
                 state->mouse_buttons & 0x02 ? 2 :
                 state->mouse_buttons & 0x04 ? 3 : 4;
    output_mouse(state, button-1 + 0x20, 1, mod, col, row);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jne 0x3141
movl -0xc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x7c(%rcx), %eax
jne 0x3141
jmp 0x3210
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x78(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x7c(%rax)
movq -0x20(%rbp), %rax
movl 0x84(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x3174
movq -0x20(%rbp), %rax
cmpl $0x0, 0x80(%rax)
jne 0x318a
movq -0x20(%rbp), %rax
movl 0x84(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x3210
movq -0x20(%rbp), %rax
movl 0x80(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x31a6
movl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x31e8
movq -0x20(%rbp), %rax
movl 0x80(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x31c2
movl $0x2, %eax
movl %eax, -0x2c(%rbp)
jmp 0x31e2
movq -0x20(%rbp), %rax
movl 0x80(%rax), %edx
andl $0x4, %edx
movl $0x4, %eax
movl $0x3, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
subl $0x1, %esi
addl $0x20, %esi
movl -0x14(%rbp), %ecx
movl -0x10(%rbp), %r8d
movl -0xc(%rbp), %r9d
movl $0x1, %edx
callq 0x3220
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/mouse.c
// Function: vterm_mouse_button
void vterm_mouse_button(VTerm *vt, int button, bool pressed, VTermModifier mod)
{
  VTermState *state = vt->state;

  int old_buttons = state->mouse_buttons;

  if(button > 0 && button <= 3) {
    if(pressed)
      state->mouse_buttons |= (1 << (button-1));
    else
      state->mouse_buttons &= ~(1 << (button-1));
  }

  /* Most of the time we don't get button releases from 4/5 */
  if(state->mouse_buttons == old_buttons && button < 4)
    return;

  if(!state->mouse_flags)
    return;

  if(button < 4) {
    output_mouse(state, button-1, pressed, mod, state->mouse_col, state->mouse_row);
  }
  else if(button < 8) {
    output_mouse(state, button-4 + 0x40, pressed, mod, state->mouse_col, state->mouse_row);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x128(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x80(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x349c
cmpl $0x3, -0xc(%rbp)
jg 0x349c
testb $0x1, -0xd(%rbp)
je 0x3478
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
orl 0x80(%rax), %ecx
movl %ecx, 0x80(%rax)
jmp 0x349a
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
xorl $-0x1, %ecx
movq -0x20(%rbp), %rax
andl 0x80(%rax), %ecx
movl %ecx, 0x80(%rax)
jmp 0x349c
movq -0x20(%rbp), %rax
movl 0x80(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x34b3
cmpl $0x4, -0xc(%rbp)
jge 0x34b3
jmp 0x3529
movq -0x20(%rbp), %rax
cmpl $0x0, 0x84(%rax)
jne 0x34c2
jmp 0x3529
cmpl $0x4, -0xc(%rbp)
jge 0x34f4
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl 0x78(%rax), %r8d
movq -0x20(%rbp), %rax
movl 0x7c(%rax), %r9d
callq 0x3220
jmp 0x3529
cmpl $0x8, -0xc(%rbp)
jge 0x3527
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
subl $0x4, %esi
addl $0x40, %esi
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl 0x78(%rax), %r8d
movq -0x20(%rbp), %rax
movl 0x7c(%rax), %r9d
callq 0x3220
jmp 0x3529
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/parser.c
// Function: do_control
static void do_control(VTerm *vt, unsigned char control)
{
  if(vt->parser.callbacks && vt->parser.callbacks->control)
    if((*vt->parser.callbacks->control)(control, vt->parser.cbdata))
      return;

  DEBUG_LOG("libvterm: Unhandled control 0x%02x\n", control);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x426d
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x426d
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq 0x8(%rax), %rax
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rdx
movq 0xe0(%rdx), %rsi
movzbl %cl, %edi
callq *%rax
cmpl $0x0, %eax
je 0x426b
jmp 0x426d
jmp 0x426d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/parser.c
// Function: do_csi
static void do_csi(VTerm *vt, char command)
{
#ifdef DEBUG_PARSER
  printf("Parsed CSI args as:\n", arglen, args);
  printf(" leader: %s\n", vt->parser.v.csi.leader);
  for(int argi = 0; argi < vt->parser.v.csi.argi; argi++) {
    printf(" %lu", CSI_ARG(vt->parser.v.csi.args[argi]));
    if(!CSI_ARG_HAS_MORE(vt->parser.v.csi.args[argi]))
      printf("\n");
  printf(" intermed: %s\n", vt->parser.intermed);
  }
#endif

  if(vt->parser.callbacks && vt->parser.callbacks->csi)
    if((*vt->parser.callbacks->csi)(
          vt->parser.v.csi.leaderlen ? vt->parser.v.csi.leader : NULL, 
          vt->parser.v.csi.args,
          vt->parser.v.csi.argi,
          vt->parser.intermedlen ? vt->parser.intermed : NULL,
          command,
          vt->parser.cbdata))
      return;

  DEBUG_LOG("libvterm: Unhandled CSI %c\n", command);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x43a0
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x43a0
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0x431d
movq -0x8(%rbp), %rax
addq $0x20, %rax
addq $0x20, %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
jmp 0x4325
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x4325
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rax
addq $0x20, %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x4367
movq -0x8(%rbp), %rax
addq $0x20, %rax
addq $0xc, %rax
movq %rax, -0x40(%rbp)
jmp 0x436f
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x436f
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %edx
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rcx
movb -0x9(%rbp), %r8b
movq -0x8(%rbp), %r9
movq 0xe0(%r9), %r9
movsbl %r8b, %r8d
callq *%rax
cmpl $0x0, %eax
je 0x439e
jmp 0x43a0
jmp 0x43a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/parser.c
// Function: do_escape
static void do_escape(VTerm *vt, char command)
{
  char seq[INTERMED_MAX+1];

  size_t len = vt->parser.intermedlen;
  strncpy(seq, vt->parser.intermed, len);
  seq[len++] = command;
  seq[len]   = 0;

  if(vt->parser.callbacks && vt->parser.callbacks->escape)
    if((*vt->parser.callbacks->escape)(seq, len, vt->parser.cbdata))
      return;

  DEBUG_LOG("libvterm: Unhandled escape ESC 0x%02x\n", command);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movslq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
addq $0xc, %rsi
movq -0x28(%rbp), %rdx
callq 0x2070
movb -0x9(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, -0x20(%rbp,%rax)
movq -0x28(%rbp), %rax
movb $0x0, -0x20(%rbp,%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x4453
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x4453
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq 0x10(%rax), %rax
leaq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rcx
movq 0xe0(%rcx), %rdx
callq *%rax
cmpl $0x0, %eax
je 0x4451
jmp 0x4453
jmp 0x4453
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/pen.c
// Function: vterm_state_newpen
INTERNAL void vterm_state_newpen(VTermState *state)
{
  // 90% grey so that pure white is brighter
  vterm_color_rgb(&state->default_fg, 240, 240, 240);
  vterm_color_rgb(&state->default_bg, 0, 0, 0);
  vterm_state_set_default_colors(state, &state->default_fg, &state->default_bg);

  for(int col = 0; col < 16; col++)
    lookup_default_colour_ansi(col, &state->colors[col]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movl $0xf0, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x4580
movq -0x8(%rbp), %rdi
addq $0x144, %rdi            # imm = 0x144
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x4580
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x140, %rsi            # imm = 0x140
movq -0x8(%rbp), %rdx
addq $0x144, %rdx            # imm = 0x144
callq 0x21e0
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x4571
movslq -0xc(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x148, %rsi            # imm = 0x148
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x4640
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4541
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/include/vterm.h
// Function: vterm_color_rgb
static inline void vterm_color_rgb(VTermColor *col, uint8_t red, uint8_t green,
                                   uint8_t blue)
{
  col->type = VTERM_COLOR_RGB;
  col->rgb.red   = red;
  col->rgb.green = green;
  col->rgb.blue  = blue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x8(%rbp)
movb %dl, -0x9(%rbp)
movb %cl, -0xa(%rbp)
movb %al, -0xb(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movb -0xa(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movb -0xb(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/pen.c
// Function: vterm_state_set_default_colors
void vterm_state_set_default_colors(VTermState *state, const VTermColor *default_fg, const VTermColor *default_bg)
{
  if(default_fg) {
    state->default_fg = *default_fg;
    state->default_fg.type = (state->default_fg.type & ~VTERM_COLOR_DEFAULT_MASK)
                           | VTERM_COLOR_DEFAULT_FG;
  }

  if(default_bg) {
    state->default_bg = *default_bg;
    state->default_bg.type = (state->default_bg.type & ~VTERM_COLOR_DEFAULT_MASK)
                           | VTERM_COLOR_DEFAULT_BG;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4604
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x140(%rax)
movq -0x8(%rbp), %rax
movzbl 0x140(%rax), %eax
andl $-0x7, %eax
orl $0x2, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x140(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x4638
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x144(%rax)
movq -0x8(%rbp), %rax
movzbl 0x144(%rax), %eax
andl $-0x7, %eax
orl $0x4, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x144(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/pen.c
// Function: lookup_default_colour_ansi
static void lookup_default_colour_ansi(long idx, VTermColor *col)
{
  if (idx >= 0 && idx < 16) {
    vterm_color_rgb(
        col,
        ansi_colors[idx].red, ansi_colors[idx].green, ansi_colors[idx].blue);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jl 0x46a3
cmpq $0x10, -0x8(%rbp)
jge 0x46a3
movq -0x10(%rbp), %rdi
leaq 0xec87(%rip), %rax      # 0x132f0
imulq $0x3, -0x8(%rbp), %rcx
addq %rcx, %rax
movb (%rax), %dl
leaq 0xec76(%rip), %rax      # 0x132f0
imulq $0x3, -0x8(%rbp), %rcx
addq %rcx, %rax
movb 0x1(%rax), %cl
leaq 0xec64(%rip), %rax      # 0x132f0
imulq $0x3, -0x8(%rbp), %rsi
addq %rsi, %rax
movzbl %dl, %esi
movzbl %cl, %edx
movzbl 0x2(%rax), %ecx
callq 0x4580
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/pen.c
// Function: vterm_state_savepen
INTERNAL void vterm_state_savepen(VTermState *state, int save)
{
  if(save) {
    state->saved.pen = state->pen;
  }
  else {
    state->pen = state->saved.pen;

    setpenattr_bool(state, VTERM_ATTR_BOLD,      state->pen.bold);
    setpenattr_int (state, VTERM_ATTR_UNDERLINE, state->pen.underline);
    setpenattr_bool(state, VTERM_ATTR_ITALIC,    state->pen.italic);
    setpenattr_bool(state, VTERM_ATTR_BLINK,     state->pen.blink);
    setpenattr_bool(state, VTERM_ATTR_REVERSE,   state->pen.reverse);
    setpenattr_bool(state, VTERM_ATTR_CONCEAL,   state->pen.conceal);
    setpenattr_bool(state, VTERM_ATTR_STRIKE,    state->pen.strike);
    setpenattr_int (state, VTERM_ATTR_FONT,      state->pen.font);
    setpenattr_bool(state, VTERM_ATTR_SMALL,     state->pen.small);
    setpenattr_int (state, VTERM_ATTR_BASELINE,  state->pen.baseline);

    setpenattr_col( state, VTERM_ATTR_FOREGROUND, state->pen.fg);
    setpenattr_col( state, VTERM_ATTR_BACKGROUND, state->pen.bg);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x49cc
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x134(%rcx), %rdx
movq %rdx, 0x198(%rax)
movl 0x13c(%rcx), %ecx
movl %ecx, 0x1a0(%rax)
jmp 0x4b81
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x198(%rcx), %rdx
movq %rdx, 0x134(%rax)
movl 0x1a0(%rcx), %ecx
movl %ecx, 0x13c(%rax)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
andw $0x1, %ax
movzwl %ax, %edx
movl $0x1, %esi
callq 0x48d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
shrw %ax
andw $0x3, %ax
movzwl %ax, %edx
movl $0x2, %esi
callq 0x4910
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
shrw $0x3, %ax
andw $0x1, %ax
movzwl %ax, %edx
movl $0x3, %esi
callq 0x48d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
shrw $0x4, %ax
andw $0x1, %ax
movzwl %ax, %edx
movl $0x4, %esi
callq 0x48d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
shrw $0x5, %ax
andw $0x1, %ax
movzwl %ax, %edx
movl $0x5, %esi
callq 0x48d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
shrw $0x6, %ax
andw $0x1, %ax
movzwl %ax, %edx
movl $0x6, %esi
callq 0x48d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
shrw $0x7, %ax
andw $0x1, %ax
movzwl %ax, %edx
movl $0x7, %esi
callq 0x48d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
shrw $0x8, %ax
andw $0xf, %ax
movzwl %ax, %edx
movl $0x8, %esi
callq 0x4910
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
shrw $0xc, %ax
andw $0x1, %ax
movzwl %ax, %edx
movl $0xb, %esi
callq 0x48d0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movw 0x13c(%rax), %ax
shrw $0xd, %ax
andw $0x3, %ax
movzwl %ax, %edx
movl $0xc, %esi
callq 0x4910
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x134(%rax), %edx
movl $0x9, %esi
callq 0x4950
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x138(%rax), %edx
movl $0xa, %esi
callq 0x4950
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/pen.c
// Function: vterm_color_is_equal
int vterm_color_is_equal(const VTermColor *a, const VTermColor *b)
{
  /* First make sure that the two colours are of the same type (RGB/Indexed) */
  if (a->type != b->type) {
    return false;
  }

  /* Depending on the type inspect the corresponding members */
  if (VTERM_COLOR_IS_INDEXED(a)) {
    return a->indexed.idx == b->indexed.idx;
  }
  else if (VTERM_COLOR_IS_RGB(a)) {
    return    (a->rgb.red   == b->rgb.red)
           && (a->rgb.green == b->rgb.green)
           && (a->rgb.blue  == b->rgb.blue);
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x4bba
movl $0x0, -0x4(%rbp)
jmp 0x4c57
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x4be8
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x4c57
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x4c4e
movq -0x10(%rbp), %rax
movzbl 0x1(%rax), %ecx
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jne 0x4c41
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %ecx
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jne 0x4c41
movq -0x10(%rbp), %rax
movzbl 0x3(%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x4c57
jmp 0x4c50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/pen.c
// Function: lookup_colour_palette
static bool lookup_colour_palette(const VTermState *state, long index, VTermColor *col)
{
  if(index >= 0 && index < 16) {
    // Normal 8 colours or high intensity - parse as palette 0
    return lookup_colour_ansi(state, index, col);
  }
  else if(index >= 16 && index < 232) {
    // 216-colour cube
    index -= 16;

    vterm_color_rgb(col, ramp6[index/6/6 % 6],
                         ramp6[index/6   % 6],
                         ramp6[index     % 6]);

    return true;
  }
  else if(index >= 232 && index < 256) {
    // 24 greyscales
    index -= 232;

    vterm_color_rgb(col, ramp24[index], ramp24[index], ramp24[index]);

    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x4d0d
cmpq $0x10, -0x18(%rbp)
jge 0x4d0d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6260
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x4e2b
cmpq $0x10, -0x18(%rbp)
jl 0x4dbb
cmpq $0xe8, -0x18(%rbp)
jge 0x4dbb
movq -0x18(%rbp), %rax
subq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl $0x6, %ecx
cqto
idivq %rcx
movl $0x6, %ecx
cqto
idivq %rcx
movl $0x6, %ecx
cqto
idivq %rcx
leaq 0x13671(%rip), %rax     # 0x183d0
movl (%rax,%rdx,4), %eax
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rax
movl $0x6, %ecx
cqto
idivq %rcx
movl $0x6, %ecx
cqto
idivq %rcx
leaq 0x1364c(%rip), %rax     # 0x183d0
movl (%rax,%rdx,4), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movl $0x6, %esi
cqto
idivq %rsi
movq %rdx, %rsi
movb -0x21(%rbp), %dl
leaq 0x1362c(%rip), %rax     # 0x183d0
movl (%rax,%rsi,4), %eax
movzbl %dl, %esi
movzbl %cl, %edx
movzbl %al, %ecx
callq 0x4580
movb $0x1, -0x1(%rbp)
jmp 0x4e2b
cmpq $0xe8, -0x18(%rbp)
jl 0x4e23
cmpq $0x100, -0x18(%rbp)     # imm = 0x100
jge 0x4e23
movq -0x18(%rbp), %rax
subq $0xe8, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
leaq 0x13604(%rip), %rax     # 0x183f0
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq -0x18(%rbp), %rcx
leaq 0x135f4(%rip), %rax     # 0x183f0
movl (%rax,%rcx,4), %eax
movb %al, %cl
movq -0x18(%rbp), %rsi
leaq 0x135e4(%rip), %rax     # 0x183f0
movl (%rax,%rsi,4), %eax
movzbl %dl, %esi
movzbl %cl, %edx
movzbl %al, %ecx
callq 0x4580
movb $0x1, -0x1(%rbp)
jmp 0x4e2b
jmp 0x4e25
jmp 0x4e27
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/pen.c
// Function: lookup_colour
static int lookup_colour(const VTermState *state, int palette, const long args[], int argcount, VTermColor *col)
{
  switch(palette) {
  case 2: // RGB mode - 3 args contain colour values directly
    if(argcount < 3)
      return argcount;

    vterm_color_rgb(col, CSI_ARG(args[0]), CSI_ARG(args[1]), CSI_ARG(args[2]));

    return 3;

  case 5: // XTerm 256-colour mode
    if (!argcount || CSI_ARG_IS_MISSING(args[0])) {
      return argcount ? 1 : 0;
    }

    vterm_color_indexed(col, args[0]);

    return argcount ? 1 : 0;

  default:
    DEBUG_LOG("Unrecognised colour palette %d\n", palette);
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
subl $0x2, %eax
je 0x59c4
jmp 0x59b7
movl -0x34(%rbp), %eax
subl $0x5, %eax
je 0x5a1d
jmp 0x5a75
cmpl $0x3, -0x24(%rbp)
jge 0x59d5
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5a7c
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movb %al, %dl
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movb %al, %cl
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movzbl %dl, %esi
movzbl %cl, %edx
movzbl %al, %ecx
callq 0x4580
movl $0x3, -0x4(%rbp)
jmp 0x5a7c
cmpl $0x0, -0x24(%rbp)
je 0x5a38
movq -0x20(%rbp), %rax
movq (%rax), %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jne 0x5a4d
movl -0x24(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5a7c
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movzbl %al, %esi
callq 0x62b0
movl -0x24(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5a7c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/pen.c
// Function: lookup_colour_ansi
static bool lookup_colour_ansi(const VTermState *state, long index, VTermColor *col)
{
  if(index >= 0 && index < 16) {
    *col = state->colors[index];
    return true;
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x6299
cmpq $0x10, -0x18(%rbp)
jge 0x6299
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl 0x148(%rcx,%rdx,4), %ecx
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x629d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/screen.c
// Function: vterm_screen_free
INTERNAL void vterm_screen_free(VTermScreen *screen)
{
  vterm_allocator_free(screen->vt, screen->buffers[BUFIDX_PRIMARY]);
  if(screen->buffers[BUFIDX_ALTSCREEN])
    vterm_allocator_free(screen->vt, screen->buffers[BUFIDX_ALTSCREEN]);

  vterm_allocator_free(screen->vt, screen->sb_buffer);

  vterm_allocator_free(screen->vt, screen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
callq 0x11ae0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x631f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rsi
callq 0x11ae0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rsi
callq 0x11ae0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x11ae0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/screen.c
// Function: vterm_screen_reset
void vterm_screen_reset(VTermScreen *screen, int hard)
{
  screen->damaged.start_row = -1;
  screen->pending_scrollrect.start_row = -1;
  vterm_state_reset(screen->state, hard);
  vterm_screen_flush_damage(screen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x2110
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/screen.c
// Function: vterm_screen_flush_damage
void vterm_screen_flush_damage(VTermScreen *screen)
{
  if(screen->pending_scrollrect.start_row != -1) {
    vterm_scroll_rect(screen->pending_scrollrect, screen->pending_scroll_downward, screen->pending_scroll_rightward,
        moverect_user, erase_user, screen);

    screen->pending_scrollrect.start_row = -1;
  }

  if(screen->damaged.start_row != -1) {
    if(screen->callbacks && screen->callbacks->damage)
      (*screen->callbacks->damage)(screen->damaged, screen->cbdata);

    screen->damaged.start_row = -1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x38(%rax)
je 0x63f6
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x48(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x4c(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x38(%rsi), %rdi
movq 0x40(%rsi), %rsi
leaq 0xb55(%rip), %r8        # 0x6f30
leaq 0xbfe(%rip), %r9        # 0x6fe0
movq %rax, (%rsp)
callq 0x2170
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x28(%rax)
je 0x6445
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x643a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
je 0x643a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rdx
movq 0x18(%rdx), %rdx
movq 0x28(%rcx), %rdi
movq 0x30(%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/screen.c
// Function: getcell
static inline ScreenCell *getcell(const VTermScreen *screen, int row, int col)
{
  if(row < 0 || row >= screen->rows)
    return NULL;
  if(col < 0 || col >= screen->cols)
    return NULL;
  return screen->buffer + (screen->cols * row) + col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x6a90
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jl 0x6a9a
movq $0x0, -0x8(%rbp)
jmp 0x6ae2
cmpl $0x0, -0x18(%rbp)
jl 0x6aac
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jl 0x6ab6
movq $0x0, -0x8(%rbp)
jmp 0x6ae2
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x54(%rcx), %ecx
imull -0x14(%rbp), %ecx
movslq %ecx, %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
imulq $0x24, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/screen.c
// Function: vterm_screen_is_eol
int vterm_screen_is_eol(const VTermScreen *screen, VTermPos pos)
{
  /* This cell is EOL if this and every cell to the right is black */
  for(; pos.col < screen->cols; pos.col++) {
    ScreenCell *cell = getcell(screen, pos.row, pos.col);
    if(cell->chars[0] != 0)
      return 0;
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jge 0x6b3e
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x6a70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x6b31
movl $0x0, -0x4(%rbp)
jmp 0x6b45
jmp 0x6b33
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x6b00
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/neovim[P]libvterm/src/screen.c
// Function: vterm_obtain_screen
VTermScreen *vterm_obtain_screen(VTerm *vt)
{
  if(vt->screen)
    return vt->screen;

  VTermScreen *screen = screen_new(vt);
  vt->screen = screen;

  return screen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x130(%rax)
je 0x6b7b
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x6b9f
movq -0x10(%rbp), %rdi
callq 0x6bb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x130(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)