LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/liball/../util/setuidgid.c
// Function: set_user
static int
set_user(const char * username)
{
	uid_t uid;
	struct passwd * user_info;

	/* See similar code in set_gid(). */
	errno = 0;
	if ((user_info = getpwnam(username)) != NULL) {
		uid = user_info->pw_uid;
	} else if (errno) {
		warnp("getpwnam(%s)", username);
		goto err0;
	} else if (PARSENUM(&uid, username)) {
		warn0("No such user: %s", username);
		goto err0;
	}

	/* Set UID. */
	if (setuid(uid)) {
		/* We handle EPERM separately; keep it in errno. */
		if (errno != EPERM)
			warnp("setuid(%lu)", (unsigned long int)uid);
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1070
movl $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10f0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1a39
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x1b5e
callq 0x1070
cmpl $0x0, (%rax)
je 0x1a87
jmp 0x1a45
callq 0x1070
cmpl $0x0, (%rax)
je 0x1a6e
movq -0x10(%rbp), %rsi
leaq 0x187a(%rip), %rdi      # 0x32d4
movb $0x0, %al
callq 0x1e10
callq 0x1070
movl $0x0, (%rax)
jmp 0x1a80
movq -0x10(%rbp), %rsi
leaq 0x185b(%rip), %rdi      # 0x32d4
movb $0x0, %al
callq 0x2060
jmp 0x1a82
jmp 0x1bc3
callq 0x1070
movl $0x0, (%rax)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
shrl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jbe 0x1acb
movq -0x10(%rbp), %rdi
movsd 0x15ce(%rip), %xmm0     # 0x3080
movsd 0x15ce(%rip), %xmm1     # 0x3088
xorl %esi, %esi
callq 0x1be0
cvttsd2si %xmm0, %rax
movl %eax, -0x14(%rbp)
jmp 0x1b2f
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movb $0x1, %al
testb $0x1, %al
jne 0x1ada
jmp 0x1afc
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %edx
movl -0x14(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %esi
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x1c90
movl %eax, -0x14(%rbp)
jmp 0x1b2d
movq 0x34f5(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1686(%rip), %rsi      # 0x3193
leaq 0x17cd(%rip), %rdx      # 0x32e1
leaq 0x15c0(%rip), %rcx      # 0x30db
movl $0x77, %r8d
movb $0x0, %al
callq 0x1100
callq 0x1060
jmp 0x1b2f
callq 0x1070
cmpl $0x0, (%rax)
je 0x1b5a
jmp 0x1b3b
movq -0x10(%rbp), %rsi
leaq 0x17a4(%rip), %rdi      # 0x32ea
movb $0x0, %al
callq 0x2060
callq 0x1070
movl $0x0, (%rax)
jmp 0x1bc3
jmp 0x1b5c
jmp 0x1b5e
movl -0x14(%rbp), %edi
callq 0x11c0
cmpl $0x0, %eax
je 0x1bba
callq 0x1070
cmpl $0x1, (%rax)
je 0x1bb8
jmp 0x1b77
callq 0x1070
cmpl $0x0, (%rax)
je 0x1ba1
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq 0x176e(%rip), %rdi      # 0x32fb
movb $0x0, %al
callq 0x1e10
callq 0x1070
movl $0x0, (%rax)
jmp 0x1bb4
movl -0x14(%rbp), %eax
movl %eax, %esi
leaq 0x174e(%rip), %rdi      # 0x32fb
movb $0x0, %al
callq 0x2060
jmp 0x1bb6
jmp 0x1bb8
jmp 0x1bc3
movl $0x0, -0x4(%rbp)
jmp 0x1bca
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/examples/fizz_buzz_threads.c
// Function: sort_main
static void sort_main(libforks_ServerConn conn, int socket_fd) {
  // not strictly required but recommended
  assert(libforks_free_conn(conn) == libforks_OK);

  assert(dup2(socket_fd, STDIN_FILENO) != -1);

  execlp("sort", "sort", "-g", NULL);
  perror("execlp");
  abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c50
cmpl $0x0, %eax
jne 0x15bf
jmp 0x15de
leaq 0x2c21(%rip), %rdi      # 0x41e7
leaq 0x2a5c(%rip), %rsi      # 0x4029
movl $0x14, %edx
leaq 0x2c36(%rip), %rcx      # 0x420f
callq 0x10e0
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x10c0
cmpl $-0x1, %eax
je 0x15ef
jmp 0x160e
leaq 0x2c42(%rip), %rdi      # 0x4238
leaq 0x2a2c(%rip), %rsi      # 0x4029
movl $0x16, %edx
leaq 0x2c06(%rip), %rcx      # 0x420f
callq 0x10e0
leaq 0x2c47(%rip), %rsi      # 0x425c
leaq 0x2c45(%rip), %rdx      # 0x4261
xorl %eax, %eax
movl %eax, %ecx
movq %rsi, %rdi
movb $0x0, %al
callq 0x1230
leaq 0x2c33(%rip), %rdi      # 0x4264
callq 0x11f0
callq 0x1040
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/examples/fizz_buzz_threads.c
// Function: fizzer_main
static void *fizzer_main() {
  char buf[99];
  for (int i = 1; i < MAX; i++) {
    if (i % 3 == 0) {
      snprintf(buf, sizeof buf, "%d fizz\n", i);
      echo_upper(buf);
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x1, -0x74(%rbp)
cmpl $0x63, -0x74(%rbp)
jge 0x1698
movl -0x74(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x168b
leaq -0x70(%rbp), %rdi
movl -0x74(%rbp), %ecx
movl $0x63, %esi
leaq 0x2bf0(%rip), %rdx      # 0x426b
movb $0x0, %al
callq 0x10d0
leaq -0x70(%rbp), %rdi
callq 0x16b0
jmp 0x168d
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x1652
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/examples/fizz_buzz_threads.c
// Function: buzzer_main
static void *buzzer_main() {
  char buf[99];
  for (int i = 1; i < MAX; i++) {
    if (i % 5 == 0) {
      snprintf(buf, sizeof buf, "%d buzz\n", i);
      echo_upper(buf);
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x1, -0x74(%rbp)
cmpl $0x63, -0x74(%rbp)
jge 0x1b68
movl -0x74(%rbp), %eax
movl $0x5, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1b5b
leaq -0x70(%rbp), %rdi
movl -0x74(%rbp), %ecx
movl $0x63, %esi
leaq 0x29c7(%rip), %rdx      # 0x4512
movb $0x0, %al
callq 0x10d0
leaq -0x70(%rbp), %rdi
callq 0x16b0
jmp 0x1b5d
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0x1b22
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/md5/main.c
// Function: perftest
static int
perftest(void)
{

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 1, perftest_init, perftest_func, NULL, NULL)) {
		warn0("perftest_buffers");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x3b9aca00, %edi       # imm = 0x3B9ACA00
leaq 0x3edc(%rip), %rsi      # 0x5370
movl $0x3, %edx
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
movl $0x1, %r8d
leaq 0x255(%rip), %r9        # 0x1700
leaq 0x29e(%rip), %rax       # 0x1750
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x3fd0
cmpl $0x0, %eax
je 0x14f2
jmp 0x14d7
leaq 0x3b2c(%rip), %rdi      # 0x500a
movb $0x0, %al
callq 0x4830
callq 0x1070
movl $0x0, (%rax)
jmp 0x14fb
movl $0x0, -0x4(%rbp)
jmp 0x1502
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/md5/main.c
// Function: selftest
static int
selftest(void)
{
	MD5_CTX ctx;
	uint8_t hbuf[16];
	char hbuf_hex[33];
	size_t i;
	size_t failures = 0;

	for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
		printf("Computing MD5 of \"%s\"...", tests[i].s);
		MD5_Init(&ctx);
		MD5_Update(&ctx, (const uint8_t *)tests[i].s,
		    strlen(tests[i].s));
		MD5_Final(hbuf, &ctx);
		hexify(hbuf, hbuf_hex, 16);
		if (strcmp(hbuf_hex, tests[i].o)) {
			printf(" FAILED!\n");
			printf("Computed MD5: %s\n", hbuf_hex);
			printf("Correct MD5:  %s\n", tests[i].o);
			failures++;
		} else {
			printf(" PASSED!\n");
		}
	}

	if (failures)
		return (1);
	else
		return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq $0x0, -0xb0(%rbp)
movq $0x0, -0xa8(%rbp)
cmpq $0x9, -0xa8(%rbp)
jae 0x168e
movq -0xa8(%rbp), %rcx
leaq 0x6ba3(%rip), %rax      # 0x80f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
leaq 0x3abd(%rip), %rdi      # 0x501b
movb $0x0, %al
callq 0x10d0
leaq -0x5c(%rbp), %rdi
callq 0x17d0
movq -0xa8(%rbp), %rcx
leaq 0x6b74(%rip), %rax      # 0x80f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0xb8(%rbp)
movq -0xa8(%rbp), %rcx
leaq 0x6b55(%rip), %rax      # 0x80f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x10b0
movq -0xb8(%rbp), %rsi
movq %rax, %rdx
leaq -0x5c(%rbp), %rdi
callq 0x1820
leaq -0x70(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x2b70
leaq -0x70(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x10, %edx
callq 0x3da0
leaq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rcx
leaq 0x6afc(%rip), %rax      # 0x80f0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
callq 0x1110
cmpl $0x0, %eax
je 0x1667
leaq 0x3a24(%rip), %rdi      # 0x5034
movb $0x0, %al
callq 0x10d0
leaq -0xa0(%rbp), %rsi
leaq 0x3a19(%rip), %rdi      # 0x503e
movb $0x0, %al
callq 0x10d0
movq -0xa8(%rbp), %rcx
leaq 0x6ab6(%rip), %rax      # 0x80f0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
leaq 0x3a04(%rip), %rdi      # 0x5050
movb $0x0, %al
callq 0x10d0
movq -0xb0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xb0(%rbp)
jmp 0x1675
leaq 0x39f4(%rip), %rdi      # 0x5062
movb $0x0, %al
callq 0x10d0
jmp 0x1677
movq -0xa8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
jmp 0x1531
cmpq $0x0, -0xb0(%rbp)
je 0x16a1
movl $0x1, -0x4(%rbp)
jmp 0x16a8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/md5/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	MD5_CTX ctx;
	uint8_t hbuf[16];
	size_t i;

	(void)cookie; /* UNUSED */

	/* Do the hashing. */
	MD5_Init(&ctx);
	for (i = 0; i < nreps; i++)
		MD5_Update(&ctx, buf, buflen);
	MD5_Final(hbuf, &ctx);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x17d0
movq $0x0, -0x98(%rbp)
movq -0x98(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x17b1
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x1820
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x177f
leaq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x2b70
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: selclear
void
selclear(void)
{
  if (sel.ob.x == -1)
    return;
  sel.mode = SEL_IDLE;
  sel.ob.x = -1;
  tsetdirt(sel.nb.y, sel.ne.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $-0x1, 0x1b459(%rip)    # 0x22444
jne 0x6fef
jmp 0x7014
movl $0x0, 0x1b42f(%rip)     # 0x22428
movl $0xffffffff, 0x1b441(%rip) # imm = 0xFFFFFFFF
movl 0x1b42f(%rip), %edi     # 0x22438
movl 0x1b431(%rip), %esi     # 0x22440
callq 0x71d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: ttyread
size_t
ttyread(void)
{
  static char buf[BUFSIZ];
  static int buflen = 0;
  int written;
  int ret;

  /* append read bytes to unprocessed bytes */
  ret = twrite_aborted ? 1 : read(cmdfd, buf+buflen, LEN(buf)-buflen);

  switch (ret) {
  case 0:
    fputs("Found EOF in input\n", stderr);
    exit(0);
  case -1:
    die("couldn't read from shell: %s\n", strerror(errno));
  default:
    buflen += twrite_aborted ? 0 : ret;
    written = twrite(buf, buflen, 0);
    buflen -= written;
    /* keep any uncomplete utf8 char for the next call */
    if (buflen > 0)
      memmove(buf, buf + written, buflen);
  }

  if (term.scr > 0 && (unsigned int)term.scr < (histsize - 1))
    term.scr++;

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x1a381(%rip)     # 0x224e0
je 0x816c
movl $0x1, %eax
movq %rax, -0x10(%rbp)
jmp 0x819b
movl 0x1a366(%rip), %edi     # 0x224d8
movslq 0x1c377(%rip), %rax     # 0x244f0
leaq 0x1a370(%rip), %rsi     # 0x224f0
addq %rax, %rsi
movslq 0x1c366(%rip), %rax     # 0x244f0
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x6200
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $-0x1, %eax
je 0x81d5
jmp 0x81af
movl -0x14(%rbp), %eax
testl %eax, %eax
jne 0x81f2
jmp 0x81b8
movq 0x16e31(%rip), %rax     # 0x1eff0
movq (%rax), %rsi
leaq 0xe6cd(%rip), %rdi      # 0x16896
callq 0x6510
xorl %edi, %edi
callq 0x61b0
callq 0x6630
movl (%rax), %edi
callq 0x64b0
movq %rax, %rsi
leaq 0xe6bf(%rip), %rdi      # 0x168aa
movb $0x0, %al
callq 0x6c50
cmpl $0x0, 0x1a2e7(%rip)     # 0x224e0
je 0x8202
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x8208
movl -0x8(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl 0x1c2df(%rip), %eax     # 0x244f0
movl %eax, 0x1c2d9(%rip)     # 0x244f0
movl 0x1c2d3(%rip), %esi     # 0x244f0
leaq 0x1a2cc(%rip), %rdi     # 0x224f0
xorl %edx, %edx
callq 0x82b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %ecx
movl 0x1c2b9(%rip), %eax     # 0x244f0
subl %ecx, %eax
movl %eax, 0x1c2b1(%rip)     # 0x244f0
cmpl $0x0, 0x1c2aa(%rip)     # 0x244f0
jle 0x8269
movslq -0x4(%rbp), %rax
leaq 0x1a29d(%rip), %rsi     # 0x224f0
addq %rax, %rsi
movslq 0x1c293(%rip), %rdx     # 0x244f0
leaq 0x1a28c(%rip), %rdi     # 0x224f0
callq 0x6590
jmp 0x826b
cmpl $0x0, 0x1a20a(%rip)     # 0x2247c
jle 0x8299
movl 0x1a202(%rip), %eax     # 0x2247c
leaq 0x1752f(%rip), %rcx     # 0x1f7b0
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x8299
movl 0x1a1ec(%rip), %eax     # 0x2247c
addl $0x1, %eax
movl %eax, 0x1a1e3(%rip)     # 0x2247c
movslq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: kscrolldown
void
kscrolldown(const Arg* a)
{
  int n = a->i;

  if (n < 0)
    n = term.row + n;

  if (n > term.scr)
    n = term.scr;

  if (term.scr > 0) {
    term.scr -= n;
    selscroll(0, -n);
    tfulldirt();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x8547
movl 0x19f17(%rip), %eax     # 0x22458
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x19f2c(%rip), %eax     # 0x2247c
jle 0x855b
movl 0x19f24(%rip), %eax     # 0x2247c
movl %eax, -0xc(%rbp)
cmpl $0x0, 0x19f1a(%rip)     # 0x2247c
jle 0x8586
movl -0xc(%rbp), %ecx
movl 0x19f0f(%rip), %eax     # 0x2247c
subl %ecx, %eax
movl %eax, 0x19f07(%rip)     # 0x2247c
xorl %esi, %esi
subl -0xc(%rbp), %esi
xorl %edi, %edi
callq 0x91b0
callq 0x92e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: ttyresize
void
ttyresize(int tw, int th)
{
  struct winsize w;

  w.ws_row = term.row;
  w.ws_col = term.col;
  w.ws_xpixel = tw;
  w.ws_ypixel = th;
  if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
    fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x19b94(%rip), %eax     # 0x22458
movw %ax, -0x10(%rbp)
movl 0x19b8e(%rip), %eax     # 0x2245c
movw %ax, -0xe(%rbp)
movl -0x4(%rbp), %eax
movw %ax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movw %ax, -0xa(%rbp)
movl 0x19bf2(%rip), %edi     # 0x224d8
movl $0x5414, %esi           # imm = 0x5414
leaq -0x10(%rbp), %rdx
movb $0x0, %al
callq 0x6120
cmpl $0x0, %eax
jge 0x892a
movq 0x166ee(%rip), %rax     # 0x1eff0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
callq 0x6630
movl (%rax), %edi
callq 0x64b0
movq -0x18(%rbp), %rdi
movq %rax, %rdx
leaq 0xdfa8(%rip), %rsi      # 0x168cb
movb $0x0, %al
callq 0x6970
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tnew
void
tnew(int col, int row)
{
  term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };

  /* allocate history buffer */
  term.hist = (Line*)xrealloc(term.hist, (histsize+1) * sizeof(Line));
  bzero(term.hist, ((histsize+1) * sizeof(Line)));

  tresize(col, row);
  treset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq -0x88(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x60c0
leaq 0x16d45(%rip), %rax     # 0x1f7e0
movl (%rax), %eax
movl %eax, -0x50(%rbp)
leaq 0x16d35(%rip), %rax     # 0x1f7dc
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
leaq 0x199a5(%rip), %rdi     # 0x22458
leaq -0x88(%rbp), %rsi
movl $0x80, %edx
callq 0x69d0
movq 0x199a5(%rip), %rdi     # 0x22470
leaq 0x16cde(%rip), %rax     # 0x1f7b0
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x3, %rsi
callq 0x6d00
movq %rax, 0x19985(%rip)     # 0x22470
movq 0x1997e(%rip), %rdi     # 0x22470
leaq 0x16cb7(%rip), %rax     # 0x1f7b0
movl (%rax), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x60c0
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x8b30
callq 0x9060
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: treset
void
treset(void)
{
  uint i;

  term.c = (TCursor){{
    .mode = ATTR_NULL,
    .fg = defaultfg,
    .bg = defaultbg
  }, .x = 0, .y = 0, .state = CURSOR_DEFAULT};

  memset(term.tabs, 0, term.col * sizeof(*term.tabs));
  for (i = tabspaces; i < (unsigned int)term.col; i += tabspaces)
    term.tabs[i] = 1;

  term.top = 0;
  term.bot = term.row - 1;
  term.mode = MODE_WRAP|MODE_UTF8;
  memset(term.trantbl, CS_USA, sizeof(term.trantbl));
  term.charset = 0;

  for (i = 0; i < 2; i++) {
    tmoveto(0, 0);
    tcursor(CURSOR_SAVE);
    tclearregion(0, 0, term.col-1, term.row-1);
    tswapscreen();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x20(%rbp)
movw $0x0, -0x1c(%rbp)
leaq 0x16764(%rip), %rax     # 0x1f7e0
movl (%rax), %eax
movl %eax, -0x18(%rbp)
leaq 0x16754(%rip), %rax     # 0x1f7dc
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x0, -0x8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x193de(%rip)     # 0x22488
movq -0x18(%rbp), %rax
movq %rax, 0x193db(%rip)     # 0x22490
movq -0x10(%rbp), %rax
movq %rax, 0x193d8(%rip)     # 0x22498
movl -0x8(%rbp), %eax
movl %eax, 0x193d7(%rip)     # 0x224a0
movq 0x193f8(%rip), %rdi     # 0x224c8
movslq 0x19385(%rip), %rdx     # 0x2245c
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x60c0
leaq 0x166e7(%rip), %rax     # 0x1f7d0
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x19365(%rip), %eax     # 0x2245c
jae 0x911b
movq 0x193c8(%rip), %rax     # 0x224c8
movl -0x4(%rbp), %ecx
movl $0x1, (%rax,%rcx,4)
leaq 0x166bf(%rip), %rax     # 0x1f7d0
movl (%rax), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x90ee
movl $0x0, 0x19387(%rip)     # 0x224ac
movl 0x1932d(%rip), %eax     # 0x22458
subl $0x1, %eax
movl %eax, 0x1937c(%rip)     # 0x224b0
movl $0x41, 0x19376(%rip)    # 0x224b4
leaq 0x19313(%rip), %rdi     # 0x22458
addq $0x64, %rdi
movl $0x3, %esi
movl $0x4, %edx
callq 0x60c0
movl $0x0, 0x1935e(%rip)     # 0x224c0
movl $0x0, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jae 0x91aa
xorl %esi, %esi
movl %esi, %edi
callq 0x9960
xorl %edi, %edi
callq 0x9c70
movl 0x192d7(%rip), %edx     # 0x2245c
subl $0x1, %edx
movl 0x192ca(%rip), %ecx     # 0x22458
subl $0x1, %ecx
xorl %esi, %esi
movl %esi, %edi
callq 0x9a30
callq 0x9c20
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9169
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: kscrollup
void
kscrollup(const Arg* a)
{
  int n = a->i;

  if (n < 0)
    n = term.row + n;

  if ((term.histi - term.scr - n) > 0  && (unsigned int)term.scr <= (histsize-n)) {
    term.scr += n;
    selscroll(0, n);
    tfulldirt();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x9327
movl 0x19137(%rip), %eax     # 0x22458
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0x1914b(%rip), %eax     # 0x22478
subl 0x19149(%rip), %eax     # 0x2247c
subl -0xc(%rbp), %eax
cmpl $0x0, %eax
jle 0x936f
movl 0x1913b(%rip), %eax     # 0x2247c
leaq 0x16468(%rip), %rcx     # 0x1f7b0
movl (%rcx), %ecx
subl -0xc(%rbp), %ecx
cmpl %ecx, %eax
ja 0x936f
movl -0xc(%rbp), %eax
addl 0x19122(%rip), %eax     # 0x2247c
movl %eax, 0x1911c(%rip)     # 0x2247c
movl -0xc(%rbp), %esi
xorl %edi, %edi
callq 0x91b0
callq 0x92e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: iso14755
void
iso14755(const Arg *arg)
{
  FILE *p;
  char *us, *e, codepoint[9], uc[UTF_SIZ];
  unsigned long utf32;

  if (!(p = popen(ISO14755CMD, "r")))
    return;

  us = fgets(codepoint, sizeof(codepoint), p);
  pclose(p);

  if (!us || *us == '\0' || *us == '-' || strlen(us) > 7)
    return;
  if ((utf32 = strtoul(us, &e, 16)) == ULONG_MAX ||
      (*e != '\n' && *e != '\0'))
    return;

  ttywrite(uc, utf8encode(utf32, uc), 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xd23c(%rip), %rdi      # 0x1690f
leaq 0x12072(%rip), %rsi     # 0x1b74c
callq 0x69b0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x96ee
jmp 0x979b
leaq -0x29(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x9, %esi
callq 0x62f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x63c0
cmpq $0x0, -0x18(%rbp)
je 0x973b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x973b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x973b
movq -0x18(%rbp), %rdi
callq 0x63b0
cmpq $0x7, %rax
jbe 0x973d
jmp 0x979b
movq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x69c0
movq %rax, -0x38(%rbp)
cmpq $-0x1, %rax
je 0x9771
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
je 0x9773
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x9773
jmp 0x979b
leaq -0x2d(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movl %eax, %edi
leaq -0x2d(%rbp), %rsi
callq 0x6da0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x8400
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tsetscroll
void
tsetscroll(int t, int b)
{
  int temp;

  LIMIT(t, 0, term.row-1);
  LIMIT(b, 0, term.row-1);
  if (t > b) {
    temp = t;
    t = b;
    b = temp;
  }
  term.top = t;
  term.bot = b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x98b7
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x98e1
movl -0x4(%rbp), %eax
movl 0x18b98(%rip), %ecx     # 0x22458
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x98d5
movl 0x18b8b(%rip), %eax     # 0x22458
subl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x98db
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x98f4
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x991e
movl -0x8(%rbp), %eax
movl 0x18b5b(%rip), %ecx     # 0x22458
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x9912
movl 0x18b4e(%rip), %eax     # 0x22458
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9918
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x993e
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, 0x18b65(%rip)     # 0x224ac
movl -0x8(%rbp), %eax
movl %eax, 0x18b60(%rip)     # 0x224b0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tmoveto
void
tmoveto(int x, int y)
{
  int miny, maxy;

  if (term.c.state & CURSOR_ORIGIN) {
    miny = term.top;
    maxy = term.bot;
  } else {
    miny = 0;
    maxy = term.row - 1;
  }
  term.c.state &= ~CURSOR_WRAPNEXT;
  term.c.x = LIMIT(x, 0, term.col-1);
  term.c.y = LIMIT(y, miny, maxy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsbl 0x18b2f(%rip), %eax     # 0x224a0
andl $0x2, %eax
cmpl $0x0, %eax
je 0x998d
movl 0x18b2d(%rip), %eax     # 0x224ac
movl %eax, -0xc(%rbp)
movl 0x18b28(%rip), %eax     # 0x224b0
movl %eax, -0x10(%rbp)
jmp 0x99a0
movl $0x0, -0xc(%rbp)
movl 0x18abe(%rip), %eax     # 0x22458
subl $0x1, %eax
movl %eax, -0x10(%rbp)
movsbl 0x18af9(%rip), %eax     # 0x224a0
andl $-0x2, %eax
movb %al, 0x18af0(%rip)      # 0x224a0
cmpl $0x0, -0x4(%rbp)
jge 0x99bd
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x99e7
movl -0x4(%rbp), %eax
movl 0x18a96(%rip), %ecx     # 0x2245c
subl $0x1, %ecx
cmpl %ecx, %eax
jle 0x99db
movl 0x18a89(%rip), %eax     # 0x2245c
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x99e1
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl %eax, 0x18aa5(%rip)     # 0x22498
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9a03
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x9a1f
movl -0x8(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x9a13
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x9a19
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
movl %eax, 0x18a71(%rip)     # 0x2249c
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tswapscreen
void
tswapscreen(void)
{
  Line *tmp = term.line;

  term.line = term.alt;
  term.alt = tmp;
  term.mode ^= MODE_ALTSCREEN;
  tfulldirt();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x18831(%rip), %rax     # 0x22460
movq %rax, -0x8(%rbp)
movq 0x1882e(%rip), %rax     # 0x22468
movq %rax, 0x1881f(%rip)     # 0x22460
movq -0x8(%rbp), %rax
movq %rax, 0x1881c(%rip)     # 0x22468
movl 0x18862(%rip), %eax     # 0x224b4
xorl $0x4, %eax
movl %eax, 0x18859(%rip)     # 0x224b4
callq 0x92e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tdumpline
void
tdumpline(int n)
{
  char buf[UTF_SIZ];
  Glyph *bp, *end;

  bp = &term.line[n][0];
  end = &bp[MIN(tlinelen(n), term.col) - 1];
  if (bp != end || bp->u != ' ') {
    for ( ; bp <= end; ++bp)
      tprinter(buf, utf8encode(bp->u, buf));
  }
  tprinter("\n", 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq 0x17dde(%rip), %rax     # 0x22460
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
callq 0x7860
cmpl 0x17db8(%rip), %eax     # 0x2245c
jge 0xa6b3
movl -0x4(%rbp), %edi
callq 0x7860
movl %eax, -0x24(%rbp)
jmp 0xa6bc
movl 0x17da3(%rip), %eax     # 0x2245c
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0xa6e7
movq -0x10(%rbp), %rax
cmpl $0x20, (%rax)
je 0xa726
jmp 0xa6e9
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
ja 0xa724
leaq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x8(%rbp), %rsi
callq 0x6da0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0xa610
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
jmp 0xa6e9
jmp 0xa726
leaq 0xc19c(%rip), %rdi      # 0x168c9
movl $0x1, %esi
callq 0xa610
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: csiparse
void
csiparse(void)
{
  char *p = csiescseq.buf, *np;
  long int v;
  int sep = ';'; /* colon or semi-colon, but not both*/

  csiescseq.narg = 0;
  if (*p == '?') {
    csiescseq.priv = 1;
    p++;
  }

  csiescseq.buf[csiescseq.len] = '\0';
  while (p < csiescseq.buf+csiescseq.len) {
    np = NULL;
    v = strtol(p, &np, 10);
    if (np == p)
      v = 0;
    if (v == LONG_MAX || v == LONG_MIN)
      v = -1;
    csiescseq.arg[csiescseq.narg++] = v;
    p = np;
    if (sep == ';' && *p == ':')
      sep = ':'; /* allow override to colon once */
    if (*p != sep || csiescseq.narg == ESC_ARG_SIZ)
      break;
    p++;
  }
  csiescseq.mode[0] = *p++;
  csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x195c1(%rip), %rax     # 0x245a0
movq %rax, -0x8(%rbp)
movl $0x3b, -0x1c(%rbp)
movl $0x0, 0x197f8(%rip)     # 0x247ec
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0xb013
movb $0x1, 0x197a1(%rip)     # 0x247a8
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq 0x19786(%rip), %rcx     # 0x247a0
leaq 0x1957f(%rip), %rax     # 0x245a0
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
leaq 0x19570(%rip), %rcx     # 0x245a0
addq 0x19769(%rip), %rcx     # 0x247a0
cmpq %rcx, %rax
jae 0xb109
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0xa, %edx
callq 0x6520
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0xb070
movq $0x0, -0x18(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x18(%rbp)
je 0xb090
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
cmpq %rax, -0x18(%rbp)
jne 0xb098
movq $-0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edx
movl 0x19748(%rip), %eax     # 0x247ec
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1973d(%rip)     # 0x247ec
movslq %eax, %rcx
leaq 0x194e7(%rip), %rax     # 0x245a0
movl %edx, 0x20c(%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpl $0x3b, -0x1c(%rbp)
jne 0xb0e1
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0xb0e1
movl $0x3a, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0xb0f6
cmpl $0x10, 0x196f8(%rip)    # 0x247ec
jne 0xb0f8
jmp 0xb109
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xb025
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, 0x196d0(%rip)      # 0x247f0
movq -0x8(%rbp), %rax
leaq 0x19475(%rip), %rcx     # 0x245a0
addq 0x1966e(%rip), %rcx     # 0x247a0
cmpq %rcx, %rax
jae 0xb143
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0xb14a
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0xb14a
movl -0x20(%rbp), %eax
movb %al, 0x1969e(%rip)      # 0x247f1
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tdefutf8
void
tdefutf8(char ascii)
{
  if (ascii == 'G')
    term.mode |= MODE_UTF8;
  else if (ascii == '@')
    term.mode &= ~MODE_UTF8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x47, %eax
jne 0xbc04
movl 0x168bb(%rip), %eax     # 0x224b4
orl $0x40, %eax
movl %eax, 0x168b2(%rip)     # 0x224b4
jmp 0xbc1e
movsbl -0x1(%rbp), %eax
cmpl $0x40, %eax
jne 0xbc1c
movl 0x168a1(%rip), %eax     # 0x224b4
andl $-0x41, %eax
movl %eax, 0x16898(%rip)     # 0x224b4
jmp 0xbc1e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tstrsequence
void
tstrsequence(uchar c)
{
  strreset();

  switch (c) {
  case 0x90:   /* DCS -- Device Control String */
    c = 'P';
    break;
  case 0x9f:   /* APC -- Application Program Command */
    c = '_';
    break;
  case 0x9e:   /* PM -- Privacy Message */
    c = '^';
    break;
  case 0x9d:   /* OSC -- Operating System Command */
    c = ']';
    break;
  }
  strreset();
  strescseq.type = c;
  term.esc |= ESC_STR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
callq 0xce60
movzbl -0x1(%rbp), %eax
addl $0xffffff70, %eax       # imm = 0xFFFFFF70
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xf, %eax
ja 0xc841
movq -0x10(%rbp), %rax
leaq 0x9d82(%rip), %rcx      # 0x165a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x50, -0x1(%rbp)
jmp 0xc841
movb $0x5f, -0x1(%rbp)
jmp 0xc841
movb $0x5e, -0x1(%rbp)
jmp 0xc841
movb $0x5d, -0x1(%rbp)
callq 0xce60
movb -0x1(%rbp), %al
movb %al, 0x17ca9(%rip)      # 0x244f8
movl 0x15c63(%rip), %eax     # 0x224b8
orl $0x4, %eax
movl %eax, 0x15c5a(%rip)     # 0x224b8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: strparse
void
strparse(void)
{
  int c;
  char *p = strescseq.buf;

  strescseq.narg = 0;
  strescseq.buf[strescseq.len] = '\0';

  if (*p == '\0')
    return;

  while (strescseq.narg < STR_ARG_SIZ) {
    strescseq.args[strescseq.narg++] = p;
    while ((c = *p) != ';' && c != '\0')
      ++p;
    if (c == '\0')
      return;
    *p++ = '\0';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x17c85(%rip), %rax     # 0x24500
movq %rax, -0x10(%rbp)
movl $0x0, 0x17d0f(%rip)     # 0x24598
movq 0x17c70(%rip), %rax     # 0x24500
movq 0x17c79(%rip), %rcx     # 0x24510
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xc8ac
jmp 0xc92c
jmp 0xc8ae
cmpl $0x10, 0x17ce3(%rip)    # 0x24598
jge 0xc92c
movq -0x10(%rbp), %rdx
movl 0x17cd7(%rip), %eax     # 0x24598
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x17ccc(%rip)     # 0x24598
movslq %eax, %rcx
leaq 0x17c22(%rip), %rax     # 0x244f8
movq %rdx, 0x20(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movl %ecx, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x3b, %ecx
movb %al, -0x11(%rbp)
je 0xc8f9
cmpl $0x0, -0x4(%rbp)
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xc902
jmp 0xc910
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc8db
cmpl $0x0, -0x4(%rbp)
jne 0xc918
jmp 0xc92c
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
jmp 0xc8ae
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: osc_color_response
void
osc_color_response(int num, int index, int is_osc4)
{
  int n;
  char buf[32];
  unsigned char r, g, b;

  if (xgetcolor(is_osc4 ? num: index, &r, &g, &b)) {
    fprintf(stderr, "erresc: failed to fetch %s color %d\n", is_osc4 ? "osc4": "osc", is_osc4 ? num : index);
    return;
  }

  n = snprintf(buf, sizeof buf, "\033]%s%d;rgb:%02x%02x/%02x%02x/%02x%02x\007",
         is_osc4 ? "4": "", num, r, r, g, g, b, b);

  if (n < 0 || n >= sizeof(buf)) {
    fprintf(stderr, "error: %s while printing %s response\n",
        n<0 ? "snprintf failed" : "truncation occurred",
        is_osc4 ? "osc4": "osc");
  } else {
    ttywrite(buf, n, 1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xcad5
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
jmp 0xcadb
movl -0x18(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %edi
leaq -0x41(%rbp), %rsi
leaq -0x42(%rbp), %rdx
leaq -0x43(%rbp), %rcx
callq 0xe4b0
cmpl $0x0, %eax
je 0xcb50
movq 0x124f5(%rip), %rax     # 0x1eff0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x1c(%rbp), %edx
leaq 0xa05b(%rip), %rax      # 0x16b67
leaq 0xa04f(%rip), %rcx      # 0x16b62
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq %rax, -0x50(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0xcb2c
movl -0x14(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0xcb32
movl -0x18(%rbp), %eax
movl %eax, -0x5c(%rbp)
movq -0x50(%rbp), %rdx
movq -0x58(%rbp), %rdi
movl -0x5c(%rbp), %ecx
leaq 0x9ff9(%rip), %rsi      # 0x16b3d
movb $0x0, %al
callq 0x6970
jmp 0xcc24
leaq -0x40(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0xef70(%rip), %rcx      # 0x1bace
leaq 0xe4b1(%rip), %rax      # 0x1b016
cmpl $0x0, %edx
cmovneq %rax, %rcx
movl -0x14(%rbp), %r8d
movzbl -0x41(%rbp), %r9d
movzbl -0x41(%rbp), %r14d
movzbl -0x42(%rbp), %ebx
movzbl -0x42(%rbp), %r11d
movzbl -0x43(%rbp), %r10d
movzbl -0x43(%rbp), %eax
movl $0x20, %esi
leaq 0x9fd3(%rip), %rdx      # 0x16b6b
movl %r14d, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movb $0x0, %al
callq 0x60d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0xcbc8
movslq -0x20(%rbp), %rax
cmpq $0x20, %rax
jb 0xcc12
movq 0x12421(%rip), %rax     # 0x1eff0
movq (%rax), %rdi
movl -0x20(%rbp), %ecx
leaq 0x9fec(%rip), %rdx      # 0x16bc8
leaq 0x9fd5(%rip), %rax      # 0x16bb8
cmpl $0x0, %ecx
cmovlq %rax, %rdx
movl -0x1c(%rbp), %esi
leaq 0x9f73(%rip), %rcx      # 0x16b67
leaq 0x9f67(%rip), %rax      # 0x16b62
cmpl $0x0, %esi
cmovneq %rax, %rcx
leaq 0x9f89(%rip), %rsi      # 0x16b92
movb $0x0, %al
callq 0x6970
jmp 0xcc24
leaq -0x40(%rbp), %rdi
movslq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x8400
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: strreset
void
strreset(void)
{
  memset(&strescseq, 0, sizeof(strescseq));
  strescseq = (STREscape) {
    .buf = xrealloc(strescseq.buf, STR_BUF_SIZ),
    .siz = STR_BUF_SIZ,
  };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq 0x17686(%rip), %rdi     # 0x244f8
xorl %esi, %esi
movl $0xa8, %edx
callq 0x60c0
leaq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0xa8, %edx
callq 0x60c0
movq 0x17668(%rip), %rdi     # 0x24500
movl $0x200, %esi            # imm = 0x200
callq 0x6d00
movq %rax, -0xa0(%rbp)
movq $0x200, -0x98(%rbp) # imm = 0x200
leaq 0x1763d(%rip), %rdi     # 0x244f8
leaq -0xa8(%rbp), %rsi
movl $0xa8, %edx
callq 0x69d0
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tinsertblank
void
tinsertblank(int n)
{
  int dst, src, size;
  Glyph *line;

  LIMIT(n, 0, term.col - term.c.x);

  dst = term.c.x + n;
  src = term.c.x;
  size = term.col - dst;
  line = term.line[term.c.y];

  memmove(&line[dst], &line[src], size * sizeof(Glyph));
  tclearregion(src, term.c.y, dst - 1, term.c.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xd028
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd058
movl -0x4(%rbp), %eax
movl 0x1542b(%rip), %ecx     # 0x2245c
subl 0x15461(%rip), %ecx     # 0x22498
cmpl %ecx, %eax
jle 0xd04c
movl 0x1541b(%rip), %eax     # 0x2245c
subl 0x15451(%rip), %eax     # 0x22498
movl %eax, -0x20(%rbp)
jmp 0xd052
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x15434(%rip), %eax     # 0x22498
addl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl 0x15428(%rip), %eax     # 0x22498
movl %eax, -0xc(%rbp)
movl 0x153e3(%rip), %eax     # 0x2245c
subl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0x153da(%rip), %rax     # 0x22460
movslq 0x1540f(%rip), %rcx     # 0x2249c
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
callq 0x6590
movl -0xc(%rbp), %edi
movl 0x153d3(%rip), %esi     # 0x2249c
movl -0x8(%rbp), %edx
subl $0x1, %edx
movl 0x153c7(%rip), %ecx     # 0x2249c
callq 0x9a30
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tscrollup
void
tscrollup(int orig, int n, int copyhist)
{
  int i;
  Line temp;

  LIMIT(n, 0, term.bot-orig+1);

  if (copyhist) {
    term.histi = (term.histi + 1 ) % histsize;
    temp = term.hist[term.histi];
    term.hist[term.histi] = term.line[orig];
    term.line[orig] = temp;
  }

  tclearregion(0, orig, term.col-1, orig+n-1);
  tsetdirt(orig+n, term.bot);

  for (i = orig; i <= term.bot-n; i++) {
    temp = term.line[i];
    term.line[i] = term.line[i+n];
    term.line[i+n] = temp;
  }

  selscroll(orig, -n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xd15e
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd18e
movl -0x8(%rbp), %eax
movl 0x15349(%rip), %ecx     # 0x224b0
subl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0xd182
movl 0x15339(%rip), %eax     # 0x224b0
subl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd188
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xd1fe
movl 0x152d8(%rip), %eax     # 0x22478
addl $0x1, %eax
leaq 0x12606(%rip), %rcx     # 0x1f7b0
xorl %edx, %edx
divl (%rcx)
movl %edx, 0x152c4(%rip)     # 0x22478
movq 0x152b5(%rip), %rax     # 0x22470
movslq 0x152b6(%rip), %rcx     # 0x22478
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0x1528f(%rip), %rax     # 0x22460
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x15290(%rip), %rax     # 0x22470
movslq 0x15291(%rip), %rcx     # 0x22478
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0x1526a(%rip), %rax     # 0x22460
movslq -0x4(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %esi
movl 0x15255(%rip), %edx     # 0x2245c
subl $0x1, %edx
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
subl $0x1, %ecx
xorl %edi, %edi
callq 0x9a30
movl -0x4(%rbp), %edi
addl -0x8(%rbp), %edi
movl 0x1528a(%rip), %esi     # 0x224b0
callq 0x71d0
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl 0x15276(%rip), %ecx     # 0x224b0
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jg 0xd29a
movq 0x15218(%rip), %rax     # 0x22460
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0x15205(%rip), %rax     # 0x22460
movl -0x10(%rbp), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x151f1(%rip), %rax     # 0x22460
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0x151de(%rip), %rax     # 0x22460
movl -0x10(%rbp), %ecx
addl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd231
movl -0x4(%rbp), %edi
xorl %esi, %esi
subl -0x8(%rbp), %esi
callq 0x91b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tscrolldown
void
tscrolldown(int orig, int n, int copyhist)
{
  int i;
  Line temp;

  LIMIT(n, 0, term.bot-orig+1);

  if (copyhist) {
    term.histi = (term.histi - 1 + histsize) % histsize;
    temp = term.hist[term.histi];
    term.hist[term.histi] = term.line[term.bot];
    term.line[term.bot] = temp;
  }

  tsetdirt(orig, term.bot-n);
  tclearregion(0, term.bot-n+1, term.col-1, term.bot);

  for (i = term.bot; i >= orig+n; i--) {
    temp = term.line[i];
    term.line[i] = term.line[i-n];
    term.line[i-n] = temp;
  }

  selscroll(orig, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0xd2ce
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xd2fe
movl -0x8(%rbp), %eax
movl 0x151d9(%rip), %ecx     # 0x224b0
subl -0x4(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jle 0xd2f2
movl 0x151c9(%rip), %eax     # 0x224b0
subl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xd2f8
movl -0x8(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xd37d
movl 0x15168(%rip), %eax     # 0x22478
subl $0x1, %eax
leaq 0x12496(%rip), %rcx     # 0x1f7b0
addl (%rcx), %eax
leaq 0x1248d(%rip), %rcx     # 0x1f7b0
xorl %edx, %edx
divl (%rcx)
movl %edx, 0x1514b(%rip)     # 0x22478
movq 0x1513c(%rip), %rax     # 0x22470
movslq 0x1513d(%rip), %rcx     # 0x22478
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0x15116(%rip), %rax     # 0x22460
movslq 0x1515f(%rip), %rcx     # 0x224b0
movq (%rax,%rcx,8), %rdx
movq 0x15114(%rip), %rax     # 0x22470
movslq 0x15115(%rip), %rcx     # 0x22478
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0x150ee(%rip), %rax     # 0x22460
movslq 0x15137(%rip), %rcx     # 0x224b0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %edi
movl 0x1512a(%rip), %esi     # 0x224b0
subl -0x8(%rbp), %esi
callq 0x71d0
movl 0x1511c(%rip), %esi     # 0x224b0
subl -0x8(%rbp), %esi
addl $0x1, %esi
movl 0x150bc(%rip), %edx     # 0x2245c
subl $0x1, %edx
movl 0x15107(%rip), %ecx     # 0x224b0
xorl %edi, %edi
callq 0x9a30
movl 0x150fa(%rip), %eax     # 0x224b0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl -0x4(%rbp), %ecx
addl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jl 0xd41f
movq 0x15093(%rip), %rax     # 0x22460
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0x15080(%rip), %rax     # 0x22460
movl -0x10(%rbp), %ecx
subl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x1506c(%rip), %rax     # 0x22460
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq 0x15059(%rip), %rax     # 0x22460
movl -0x10(%rbp), %ecx
subl -0x8(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xd3b9
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x91b0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/st.c
// Function: tdeletechar
void
tdeletechar(int n)
{
  int dst, src, size;
  Glyph *line;

  LIMIT(n, 0, term.col - term.c.x);

  dst = term.c.x;
  src = term.c.x + n;
  size = term.col - src;
  line = term.line[term.c.y];

  memmove(&line[dst], &line[src], size * sizeof(Glyph));
  tclearregion(term.col-n, term.c.y, term.col-1, term.c.y);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0xd9e8
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0xda18
movl -0x4(%rbp), %eax
movl 0x14a6b(%rip), %ecx     # 0x2245c
subl 0x14aa1(%rip), %ecx     # 0x22498
cmpl %ecx, %eax
jle 0xda0c
movl 0x14a5b(%rip), %eax     # 0x2245c
subl 0x14a91(%rip), %eax     # 0x22498
movl %eax, -0x20(%rbp)
jmp 0xda12
movl -0x4(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl 0x14a74(%rip), %eax     # 0x22498
movl %eax, -0x8(%rbp)
movl 0x14a6b(%rip), %eax     # 0x22498
addl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl 0x14a23(%rip), %eax     # 0x2245c
subl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq 0x14a1a(%rip), %rax     # 0x22460
movslq 0x14a4f(%rip), %rcx     # 0x2249c
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x8(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movslq -0xc(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
callq 0x6590
movl 0x149d6(%rip), %edi     # 0x2245c
subl -0x4(%rbp), %edi
movl 0x14a0d(%rip), %esi     # 0x2249c
movl 0x149c7(%rip), %edx     # 0x2245c
subl $0x1, %edx
movl 0x149fe(%rip), %ecx     # 0x2249c
callq 0x9a30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mcaimi[P]st/x.c
// Function: setsel
void
setsel(char *str, Time t)
{
  if (!str)
    return;

  free(xsel.primary);
  xsel.primary = str;

  XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t);
  if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win)
    selclear();

  xclipcopy();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe129
jmp 0xe180
movq 0x16a68(%rip), %rdi     # 0x24b98
callq 0x6380
movq -0x8(%rbp), %rax
movq %rax, 0x16a58(%rip)     # 0x24b98
movq 0x16841(%rip), %rdi     # 0x24988
movq 0x1684a(%rip), %rdx     # 0x24998
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x66b0
movq 0x16825(%rip), %rdi     # 0x24988
movl $0x1, %esi
callq 0x69e0
cmpq 0x16824(%rip), %rax     # 0x24998
je 0xe17b
callq 0x6fe0
callq 0xe060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)