LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/testing_programs.c
// Function: tp1_main
int tp1_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp1_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x75ec
cmpl 0x98ac(%rip), %eax      # 0x231a0
jne 0x19912
movq %rbx, %rdi
xorl %esi, %esi
callq 0x787d
movl (%rax), %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16eb(%rip), %rdi      # 0x1b004
leaq 0x3261(%rip), %rsi      # 0x1cb81
leaq 0x33fd(%rip), %rcx      # 0x1cd24
movl $0x33, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x16f2(%rip), %rdi      # 0x1b02c
leaq 0x3398(%rip), %rsi      # 0x1ccd9
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x18a3(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x199a0
movl %r14d, %r15d
leaq 0x16a5(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x1998a
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/testing_programs.c
// Function: tp2_main
int tp2_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp2_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    int b = IntRef_value(IntRefVector_get(args, 1));
    return a + b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x75ec
cmpl 0x97e6(%rip), %eax      # 0x231b0
jne 0x199fc
movq %rbx, %rdi
xorl %esi, %esi
callq 0x787d
movl (%rax), %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x787d
addl (%rax), %r14d
movl %r14d, %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1601(%rip), %rdi      # 0x1b004
leaq 0x3177(%rip), %rsi      # 0x1cb81
leaq 0x3338(%rip), %rcx      # 0x1cd49
movl $0x3e, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x1608(%rip), %rdi      # 0x1b02c
leaq 0x32ae(%rip), %rsi      # 0x1ccd9
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x17b9(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x19a8a
movl %r14d, %r15d
leaq 0x15bb(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x19a74
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/testing_programs.c
// Function: tp3_main
int tp3_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp3_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    int b = IntRef_value(IntRefVector_get(args, 1));
    return a - b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x75ec
cmpl 0x970c(%rip), %eax      # 0x231c0
jne 0x19ae6
movq %rbx, %rdi
xorl %esi, %esi
callq 0x787d
movl (%rax), %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x787d
subl (%rax), %r14d
movl %r14d, %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1517(%rip), %rdi      # 0x1b004
leaq 0x308d(%rip), %rsi      # 0x1cb81
leaq 0x3273(%rip), %rcx      # 0x1cd6e
movl $0x4b, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x151e(%rip), %rdi      # 0x1b02c
leaq 0x31c4(%rip), %rsi      # 0x1ccd9
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x16cf(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x19b74
movl %r14d, %r15d
leaq 0x14d1(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x19b5e
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/testing_programs.c
// Function: tp4_main
int tp4_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp4_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    a = a + 1;
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x75ec
cmpl 0x9632(%rip), %eax      # 0x231d0
jne 0x19bbe
movq %rbx, %rdi
xorl %esi, %esi
callq 0x787d
movl (%rax), %eax
incl %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x143f(%rip), %rdi      # 0x1b004
leaq 0x2fb5(%rip), %rsi      # 0x1cb81
leaq 0x31c5(%rip), %rcx      # 0x1cd98
movl $0x58, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x1446(%rip), %rdi      # 0x1b02c
leaq 0x30ec(%rip), %rsi      # 0x1ccd9
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x15f7(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x19c4c
movl %r14d, %r15d
leaq 0x13f9(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x19c36
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/testing_programs.c
// Function: tp5_main
int tp5_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp5_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    int b = IntRef_value(IntRefVector_get(args, 1));
    int c = a;
    while((b - 1) > 0) {
        b = b - 1;
        a = a + c;
    }
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x75ec
cmpl 0x956a(%rip), %eax      # 0x231e0
jne 0x19cb8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x787d
movl (%rax), %r15d
movl $0x1, %r14d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x787d
movl (%rax), %eax
cmpl $0x2, %eax
cmovgel %eax, %r14d
imull %r15d, %r14d
movl %r14d, %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1345(%rip), %rdi      # 0x1b004
leaq 0x2ebb(%rip), %rsi      # 0x1cb81
leaq 0x31a5(%rip), %rcx      # 0x1ce72
movl $0x6c, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x134c(%rip), %rdi      # 0x1b02c
leaq 0x2ff2(%rip), %rsi      # 0x1ccd9
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x14fd(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x19d46
movl %r14d, %r15d
leaq 0x12ff(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x19d30
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/testing_programs.c
// Function: tp6_main
int tp6_main(IntRefVector *args) {
    if(IntRefVector_size(args) != tp6_arity) {
        ERROR("Incorrect number of arguments given to a test program");
    }
    int a = IntRef_value(IntRefVector_get(args, 0));
    return tp6_foo(a) + a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movq %rdi, %rbx
callq 0x75ec
cmpl 0x9477(%rip), %eax      # 0x231f0
jne 0x19d9e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x787d
movl (%rax), %eax
leal 0xa(,%rax,2), %eax
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x125f(%rip), %rdi      # 0x1b004
leaq 0x2dd5(%rip), %rsi      # 0x1cb81
leaq 0x3165(%rip), %rcx      # 0x1cf18
movl $0x85, %edx
xorl %eax, %eax
callq 0x6100
leaq 0x1266(%rip), %rdi      # 0x1b02c
leaq 0x2f0c(%rip), %rsi      # 0x1ccd9
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x1417(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x19e2c
movl %r14d, %r15d
leaq 0x1219(%rip), %r14      # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x19e16
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/alexj136[P]minijit/src/testing_programs.c
// Function: get_test_program
TestProgram *get_test_program(int number) {
    if(!test_program_vector) { ERROR("Testing programs not prepared"); }

    if(number >= TestProgramVector_size(test_program_vector)) {
        ERROR("test program at given index does not exist");
    }
    else { return TestProgramVector_get(test_program_vector, number); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1f40, %rsp           # imm = 0x1F40
movl %edi, %esi
movq 0x91dc(%rip), %rdi      # 0x232c0
testq %rdi, %rdi
je 0x1a105
cmpl %esi, (%rdi)
jle 0x1a19c
addq $0x1f40, %rsp           # imm = 0x1F40
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x189b1
leaq 0xef8(%rip), %rdi       # 0x1b004
leaq 0x2a6e(%rip), %rsi      # 0x1cb81
leaq 0x2e42(%rip), %rcx      # 0x1cf5c
movl $0xa6, %edx
xorl %eax, %eax
callq 0x6100
leaq 0xeff(%rip), %rdi       # 0x1b02c
leaq 0x2e39(%rip), %rsi      # 0x1cf6d
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x10b0(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x1a22a
movl %r14d, %r15d
leaq 0xeae(%rip), %r14       # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x1a181
jmp 0x1a22a
leaq 0xe61(%rip), %rdi       # 0x1b004
leaq 0x29d7(%rip), %rsi      # 0x1cb81
leaq 0x2dab(%rip), %rcx      # 0x1cf5c
movl $0xa9, %edx
xorl %eax, %eax
callq 0x6100
leaq 0xe68(%rip), %rdi       # 0x1b02c
leaq 0x2dc0(%rip), %rsi      # 0x1cf8b
xorl %eax, %eax
callq 0x6100
leaq -0x1f60(%rbp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x60e0
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x60b0
movq %rax, %rbx
leaq 0x1019(%rip), %rdi      # 0x1b216
callq 0x6070
testl %r14d, %r14d
jle 0x1a22a
movl %r14d, %r15d
leaq 0xe1b(%rip), %r14       # 0x1b02c
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x6100
incq %r12
cmpq %r12, %r15
jne 0x1a214
movl $0x1, %edi
callq 0x61a0
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]libcperciva/tests/setuidgid/main.c
// Function: main
int
main(int argc, char * argv[])
{
	const char * opt_username_groupname;

	WARNP_INIT;

	/* Print usage, if necessary. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_setuid "
		    "{USERNAME | :GROUPNAME | USERNAME:GROUPNAME}\n");
		goto err0;
	}
	opt_username_groupname = argv[1];

	/* Change username (and groupname). */
	if (setuidgid(opt_username_groupname, SETUIDGID_SGROUP_LEAVE_WARN)) {
		if (errno == EPERM) {
			warn0("Insufficient permissions to change your user"
			    " or group(s).");
			goto nopermission;
		}
		goto err0;
	}

	/* Success! */
	return (0);

nopermission:
	/* Failure! */
	exit(EX_NOPERM);

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1451
callq 0x1924
cmpl $0x2, %ebp
jne 0x1471
movq 0x8(%rbx), %rdi
movl $0x1, %esi
callq 0x14ac
testl %eax, %eax
jne 0x1480
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1210
movl $0x1, %edi
callq 0x11b0
callq 0x1060
cmpl $0x1, (%rax)
jne 0x1476
movq %rax, %rbx
leaq 0xbb1(%rip), %rdi       # 0x2045
xorl %eax, %eax
callq 0x1ac3
movl $0x0, (%rbx)
movl $0x4d, %edi
callq 0x11b0
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %esi, %ebx
callq 0x2aef
testl %eax, %eax
jne 0x15e0
movl %ebx, %edi
xorl %esi, %esi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x15ff
leaq 0x1c70(%rip), %rdi      # 0x3238
leaq 0x1a5a(%rip), %rsi      # 0x3029
leaq 0x1c39(%rip), %rcx      # 0x320f
movl $0x16, %edx
callq 0x10e0
leaq 0x1c00(%rip), %rdi      # 0x31e7
leaq 0x1a3b(%rip), %rsi      # 0x3029
leaq 0x1c1a(%rip), %rcx      # 0x320f
movl $0x14, %edx
callq 0x10e0
leaq 0x1c56(%rip), %rdi      # 0x325c
leaq 0x1c54(%rip), %rdx      # 0x3261
movq %rdi, %rsi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1220
leaq 0x1c44(%rip), %rdi      # 0x3264
callq 0x11e0
callq 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl $0x1, %ebx
movl $0xaaaaaaab, %r12d      # imm = 0xAAAAAAAB
leaq 0x1c24(%rip), %r14      # 0x326b
movq %rsp, %r15
movl %ebx, %eax
imulq %r12, %rax
shrq $0x21, %rax
leal (%rax,%rax,2), %eax
cmpl %eax, %ebx
jne 0x1677
movl $0x63, %esi
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
callq 0x168c
incl %ebx
cmpl $0x63, %ebx
jne 0x164a
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/motet-a[P]libforks/examples/fizz_buzz_threads.c
// Function: echo_upper_main
static void echo_upper_main(libforks_ServerConn conn, int socket_fd) {
  // not strictly required but recommended
  assert(libforks_free_conn(conn) == libforks_OK);

  int out, ready_fd;
  char c;
  assert(libforks_read_socket_fds(socket_fd, &c, 1, &out, 1) == 0);
  assert(c == 'a');
  assert(libforks_read_socket_fds(socket_fd, &c, 1, &ready_fd, 1) == 0);
  assert(c == 'b');

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

  // Inform the parent process that we’re ready to receive input
  assert(write(ready_fd, "c", 1) == 1);
  close(ready_fd);

  execlp("tr", "tr", "[:lower:]", "[:upper:]", NULL); // uppercase!
  perror("execlp");
  abort();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
callq 0x2aef
testl %eax, %eax
jne 0x198e
leaq 0x7(%rsp), %rsi
leaq 0xc(%rsp), %rcx
movl $0x1, %edx
movl $0x1, %r8d
movl %ebx, %edi
callq 0x1b44
testl %eax, %eax
jne 0x19ad
cmpb $0x61, 0x7(%rsp)
jne 0x19cc
leaq 0x7(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movl $0x1, %edx
movl $0x1, %r8d
movl %ebx, %edi
callq 0x1b44
testl %eax, %eax
jne 0x19eb
cmpb $0x62, 0x7(%rsp)
jne 0x1a0a
movl %ebx, %edi
xorl %esi, %esi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x1a29
leaq 0x18c2(%rip), %rdi      # 0x3238
leaq 0x16ac(%rip), %rsi      # 0x3029
leaq 0x1a83(%rip), %rcx      # 0x3407
movl $0x28, %edx
callq 0x10e0
leaq 0x1852(%rip), %rdi      # 0x31e7
leaq 0x168d(%rip), %rsi      # 0x3029
leaq 0x1a64(%rip), %rcx      # 0x3407
movl $0x1f, %edx
callq 0x10e0
leaq 0x1a82(%rip), %rdi      # 0x3436
leaq 0x166e(%rip), %rsi      # 0x3029
leaq 0x1a45(%rip), %rcx      # 0x3407
movl $0x23, %edx
callq 0x10e0
leaq 0x1a9c(%rip), %rdi      # 0x346f
leaq 0x164f(%rip), %rsi      # 0x3029
leaq 0x1a26(%rip), %rcx      # 0x3407
movl $0x24, %edx
callq 0x10e0
leaq 0x1a86(%rip), %rdi      # 0x3478
leaq 0x1630(%rip), %rsi      # 0x3029
leaq 0x1a07(%rip), %rcx      # 0x3407
movl $0x25, %edx
callq 0x10e0
leaq 0x1aa5(%rip), %rdi      # 0x34b6
leaq 0x1611(%rip), %rsi      # 0x3029
leaq 0x19e8(%rip), %rcx      # 0x3407
movl $0x26, %edx
callq 0x10e0
movl 0xc(%rsp), %edi
movl $0x1, %esi
callq 0x10c0
cmpl $-0x1, %eax
jne 0x1a5b
leaq 0x1a7c(%rip), %rdi      # 0x34bf
leaq 0x15df(%rip), %rsi      # 0x3029
leaq 0x19b6(%rip), %rcx      # 0x3407
movl $0x29, %edx
callq 0x10e0
movl %ebx, %edi
callq 0x10f0
movl 0xc(%rsp), %edi
callq 0x10f0
movl 0x8(%rsp), %edi
leaq 0x15ce(%rip), %rsi      # 0x3044
movl $0x1, %edx
callq 0x1080
cmpq $0x1, %rax
jne 0x1ac2
movl 0x8(%rsp), %edi
callq 0x10f0
leaq 0x1a65(%rip), %rdi      # 0x34fb
leaq 0x1a61(%rip), %rdx      # 0x34fe
leaq 0x1a64(%rip), %rcx      # 0x3508
movq %rdi, %rsi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x1220
leaq 0x17ac(%rip), %rdi      # 0x3264
callq 0x11e0
callq 0x1040
leaq 0x1a15(%rip), %rdi      # 0x34de
leaq 0x1559(%rip), %rsi      # 0x3029
leaq 0x1930(%rip), %rcx      # 0x3407
movl $0x2e, %edx
callq 0x10e0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl $0x1, %ebx
movl $0xcccccccd, %r12d      # imm = 0xCCCCCCCD
leaq 0x1a14(%rip), %r14      # 0x3512
movq %rsp, %r15
movl %ebx, %eax
imulq %r12, %rax
shrq $0x22, %rax
leal (%rax,%rax,4), %eax
cmpl %eax, %ebx
jne 0x1b2e
movl $0x63, %esi
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10d0
movq %r15, %rdi
callq 0x168c
incl %ebx
cmpl $0x63, %ebx
jne 0x1b01
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl $0x8, %ebx
leaq 0x40(%rsp), %r14
leaq 0x10(%rsp), %r12
xorl %r15d, %r15d
leaq 0x5439(%rip), %rax      # 0x6d60
movq -0x8(%rbx,%rax), %rbp
movq (%rbx,%rax), %r13
leaq 0x26e4(%rip), %rdi      # 0x401b
movq %rbp, %rsi
xorl %eax, %eax
callq 0x10e0
movq %r14, %rdi
callq 0x1aa8
movq %rbp, %rdi
callq 0x10c0
movq %r14, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x1abb
movq %rsp, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x231b
movl $0x10, %edx
movq %rbp, %rdi
movq %r12, %rsi
callq 0x2bb4
movq %r12, %rdi
movq %r13, %rsi
callq 0x1130
testl %eax, %eax
je 0x19bf
leaq 0x29c7(%rip), %rdi      # 0x435a
callq 0x1090
leaq 0x2695(%rip), %rdi      # 0x4034
movq %r12, %rsi
xorl %eax, %eax
callq 0x10e0
leaq 0x2696(%rip), %rdi      # 0x4046
movq %r13, %rsi
xorl %eax, %eax
callq 0x10e0
incq %r15
jmp 0x19cb
leaq 0x298b(%rip), %rdi      # 0x4351
callq 0x1090
addq $0x10, %rbx
cmpq $0x98, %rbx
jne 0x1920
xorl %eax, %eax
testq %r15, %r15
setne %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x10(%rsp), %rdi
callq 0x1aa8
testq %rbx, %rbx
je 0x1a8a
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1abb
decq %rbx
jne 0x1a77
movq %rsp, %rdi
leaq 0x10(%rsp), %rsi
callq 0x231b
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
cmpl $-0x1, 0x17304(%rip)    # 0x1e684
je 0x73a7
movl $0x0, 0x172dc(%rip)     # 0x1e668
movl $0xffffffff, 0x172ee(%rip) # imm = 0xFFFFFFFF
movl 0x172dc(%rip), %edi     # 0x1e678
movl 0x172de(%rip), %esi     # 0x1e680
jmp 0x74a4
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl $0x1, %ebx
cmpb $0x0, 0x168d1(%rip)     # 0x1e720
jne 0x7e78
movl 0x168c1(%rip), %edi     # 0x1e718
movslq 0x188d2(%rip), %rax     # 0x20730
leaq 0x168cb(%rip), %rsi     # 0x1e730
addq %rax, %rsi
movl $0x2000, %edx           # imm = 0x2000
subq %rax, %rdx
callq 0x6200
movq %rax, %rbx
cmpl $-0x1, %ebx
je 0x7efc
testl %ebx, %ebx
je 0x7f19
xorl %eax, %eax
cmpb $0x0, 0x16892(%rip)     # 0x1e720
movl %ebx, %esi
cmovnel %eax, %esi
addl 0x18897(%rip), %esi     # 0x20730
movl %esi, 0x18891(%rip)     # 0x20730
leaq 0x1688a(%rip), %r14     # 0x1e730
movq %r14, %rdi
xorl %edx, %edx
callq 0x7f1e
movl 0x1887a(%rip), %ecx     # 0x20730
subl %eax, %ecx
movl %ecx, 0x18872(%rip)     # 0x20730
jle 0x7ed0
movslq %eax, %rsi
addq %r14, %rsi
movl %ecx, %edx
movq %r14, %rdi
callq 0x6580
movl 0x167e6(%rip), %eax     # 0x1e6bc
testl %eax, %eax
jle 0x7ef1
leaq 0x1569f(%rip), %rcx     # 0x1d580
movl (%rcx), %ecx
decl %ecx
cmpl %ecx, %eax
jae 0x7ef1
incl %eax
movl %eax, 0x167cb(%rip)     # 0x1e6bc
movslq %ebx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x6620
movl (%rax), %edi
callq 0x64b0
leaq 0xa74b(%rip), %rdi      # 0x1265a
movq %rax, %rsi
xorl %eax, %eax
callq 0x714f
callq 0x6ca2
// File: /workspace/github_c_makefile_star2_O1/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:
movl 0x165bc(%rip), %eax     # 0x1e6bc
testl %eax, %eax
jle 0x8167
pushq %rbx
movl (%rdi), %ecx
movl %ecx, %esi
sarl $0x1f, %esi
andl 0x16586(%rip), %esi     # 0x1e698
addl %ecx, %esi
cmpl %eax, %esi
cmovgel %eax, %esi
subl %esi, %eax
movl %eax, 0x1659b(%rip)     # 0x1e6bc
negl %esi
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x8aef
movb $0x0, 0x1651d(%rip)     # 0x1e650
movl 0x1655f(%rip), %edx     # 0x1e698
decl %edx
movl %edx, %eax
sarl $0x1f, %eax
andl %edx, %eax
cltq
movl %edx, %ecx
negl %ecx
cmovsl %edx, %ecx
incl %ecx
shlq $0x2, %rax
addq 0x16568(%rip), %rax     # 0x1e6c0
movl $0x1, (%rax,%rbx,4)
incq %rbx
cmpl %ebx, %ecx
jne 0x8158
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movzwl 0x1635f(%rip), %eax     # 0x1e698
movq %rsp, %rdx
movw %ax, (%rdx)
movzwl 0x16356(%rip), %eax     # 0x1e69c
movw %ax, 0x2(%rdx)
movw %di, 0x4(%rdx)
movw %si, 0x6(%rdx)
movl 0x163c0(%rip), %edi     # 0x1e718
movl $0x5414, %esi           # imm = 0x5414
xorl %eax, %eax
callq 0x6120
testl %eax, %eax
js 0x836a
popq %rax
retq
callq 0x6cc0
jmp 0x8368
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
leaq 0x15162(%rip), %rax     # 0x1d5b0
movl (%rax), %eax
leaq 0x15155(%rip), %rcx     # 0x1d5ac
movl (%rcx), %ecx
xorps %xmm0, %xmm0
movups %xmm0, 0x16245(%rip)    # 0x1e6a8
movups %xmm0, 0x1622e(%rip)    # 0x1e698
movups %xmm0, 0x16247(%rip)    # 0x1e6b8
movq $0x0, 0x1624c(%rip) # 0x1e6c8
movl %eax, 0x1624e(%rip)     # 0x1e6d0
movl %ecx, 0x1624c(%rip)     # 0x1e6d4
movups %xmm0, 0x16249(%rip)    # 0x1e6d8
movups %xmm0, 0x16252(%rip)    # 0x1e6e8
movups %xmm0, 0x1625b(%rip)    # 0x1e6f8
movups %xmm0, 0x16264(%rip)    # 0x1e708
movq 0x16205(%rip), %rdi     # 0x1e6b0
leaq 0x150ce(%rip), %r14     # 0x1d580
movl (%r14), %esi
incl %esi
shlq $0x3, %rsi
callq 0x71e9
movq %rax, 0x161e9(%rip)     # 0x1e6b0
movl (%r14), %edx
incl %edx
shlq $0x3, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x60c0
movl %ebp, %edi
movl %ebx, %esi
callq 0x84ec
popq %rbx
popq %r14
popq %rbp
jmp 0x8985
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x14c20(%rip), %rax     # 0x1d5b0
movl (%rax), %eax
leaq 0x14c13(%rip), %rcx     # 0x1d5ac
movl (%rcx), %ecx
movl $0x0, 0x15d23(%rip)     # 0x1e6c8
movw $0x0, 0x15d1e(%rip)     # 0x1e6cc
movl %eax, 0x15d1c(%rip)     # 0x1e6d0
movl %ecx, 0x15d1a(%rip)     # 0x1e6d4
movq $0x0, 0x15d13(%rip) # 0x1e6d8
movb $0x0, 0x15d14(%rip)     # 0x1e6e0
movq 0x15d35(%rip), %rdi     # 0x1e708
movslq 0x15cc2(%rip), %rbx     # 0x1e69c
movq %rbx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x60c0
leaq 0x14bb1(%rip), %rax     # 0x1d5a0
movl (%rax), %ecx
cmpl %ebx, %ecx
jae 0x8a11
movq 0x15d0c(%rip), %rdx     # 0x1e708
movl 0x15c9a(%rip), %esi     # 0x1e69c
movl %ecx, %edi
movl $0x1, (%rdx,%rdi,4)
addl (%rax), %ecx
cmpl %esi, %ecx
jb 0x8a02
movl $0x0, 0x15cd1(%rip)     # 0x1e6ec
movl 0x15c77(%rip), %eax     # 0x1e698
decl %eax
movl %eax, 0x15cc7(%rip)     # 0x1e6f0
movl $0x41, 0x15cc1(%rip)    # 0x1e6f4
movq $0x3030303, 0x15cbe(%rip) # imm = 0x3030303
movl $0x1, %ebx
leaq 0x17ff6(%rip), %r14     # 0x20a40
movb 0x15c90(%rip), %dl      # 0x1e6e0
movl 0x15c42(%rip), %ecx     # 0x1e698
movl %edx, %eax
andb $-0x2, %al
movb %al, 0x15c80(%rip)      # 0x1e6e0
decl %ecx
movl %ecx, %esi
movl $0x0, %eax
testb $0x2, %dl
je 0x8a7a
movl 0x15c7c(%rip), %esi     # 0x1e6f0
movl 0x15c72(%rip), %eax     # 0x1e6ec
movl 0x15c1c(%rip), %edx     # 0x1e69c
decl %edx
movl %esi, %edi
sarl $0x1f, %edi
andl %esi, %edi
movl %edx, %esi
sarl $0x1f, %esi
andl %edx, %esi
testl %eax, %eax
cmovgl %eax, %edi
movl %esi, 0x15c3d(%rip)     # 0x1e6d8
movl %edi, 0x15c3b(%rip)     # 0x1e6dc
movl 0x15c4d(%rip), %eax     # 0x1e6f4
shrl $0x2, %eax
andl $0x1, %eax
leaq (%rax,%rax,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rax, %rsi
movups 0x15c09(%rip), %xmm0    # 0x1e6c8
movups %xmm0, (%r14,%rsi)
movups 0x15c09(%rip), %xmm0    # 0x1e6d4
movups %xmm0, 0xc(%r14,%rsi)
xorl %edi, %edi
xorl %esi, %esi
callq 0x8fe3
callq 0x9151
decl %ebx
je 0x8a4a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl (%rdi), %eax
movl %eax, %esi
sarl $0x1f, %esi
andl 0x15acd(%rip), %esi     # 0x1e698
addl %eax, %esi
movl 0x15ae5(%rip), %edx     # 0x1e6b8
movl 0x15ae3(%rip), %ecx     # 0x1e6bc
leal (%rcx,%rsi), %eax
subl %eax, %edx
testl %edx, %edx
jle 0x8c3c
pushq %rbx
leaq 0x14996(%rip), %rdx     # 0x1d580
movl (%rdx), %edx
subl %esi, %edx
cmpl %edx, %ecx
ja 0x8c3b
movl %eax, 0x15ac4(%rip)     # 0x1e6bc
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x8aef
movb $0x0, 0x15a48(%rip)     # 0x1e650
movl 0x15a8a(%rip), %edx     # 0x1e698
decl %edx
movl %edx, %eax
sarl $0x1f, %eax
andl %edx, %eax
cltq
movl %edx, %ecx
negl %ecx
cmovsl %edx, %ecx
incl %ecx
shlq $0x2, %rax
addq 0x15a93(%rip), %rax     # 0x1e6c0
movl $0x1, (%rax,%rbx,4)
incq %rbx
cmpl %ebx, %ecx
jne 0x8c2d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x983d(%rip), %rdi      # 0x126bf
leaq 0xe653(%rip), %rsi      # 0x174dc
callq 0x69b0
testq %rax, %rax
je 0x8f1b
movq %rax, %r14
leaq 0xf(%rsp), %rdi
movl $0x9, %esi
movq %rax, %rdx
callq 0x62f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x63c0
testq %rbx, %rbx
je 0x8f1b
movzbl (%rbx), %eax
testl %eax, %eax
je 0x8f1b
cmpl $0x2d, %eax
je 0x8f1b
movq %rbx, %rdi
callq 0x63b0
cmpq $0x7, %rax
ja 0x8f1b
movq %rsp, %rsi
movq %rbx, %rdi
movl $0x10, %edx
callq 0x69c0
cmpq $-0x1, %rax
je 0x8f1b
movq (%rsp), %rcx
movzbl (%rcx), %ecx
cmpl $0xa, %ecx
je 0x8efc
testl %ecx, %ecx
jne 0x8f1b
leaq 0xb(%rsp), %rbx
movl %eax, %edi
movq %rbx, %rsi
callq 0x723d
movq %rbx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x8037
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb 0x15762(%rip), %dl      # 0x1e6e0
movl 0x15768(%rip), %eax     # 0x1e6ec
movl 0x15766(%rip), %ecx     # 0x1e6f0
movl 0x15707(%rip), %r8d     # 0x1e698
movl %edx, %r9d
andb $-0x2, %r9b
movb %r9b, 0x15741(%rip)     # 0x1e6e0
xorl %r9d, %r9d
movl $0x0, %r10d
testl %edi, %edi
js 0x8fbd
movl 0x156e9(%rip), %r10d    # 0x1e69c
decl %r10d
cmpl %edi, %r10d
cmovgel %edi, %r10d
decl %r8d
testb $0x2, %dl
cmovel %r8d, %ecx
cmovel %r9d, %eax
movl %r10d, 0x15706(%rip)    # 0x1e6d8
cmpl %esi, %ecx
cmovgel %esi, %ecx
cmpl %esi, %eax
cmovgl %eax, %ecx
movl %ecx, 0x156fa(%rip)     # 0x1e6dc
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movq 0x15548(%rip), %rax     # 0x1e6a0
movq 0x15549(%rip), %rcx     # 0x1e6a8
movq %rcx, 0x1553a(%rip)     # 0x1e6a0
movq %rax, 0x1553b(%rip)     # 0x1e6a8
xorb $0x4, 0x15580(%rip)     # 0x1e6f4
movb $0x0, 0x154d5(%rip)     # 0x1e650
movl 0x15517(%rip), %edx     # 0x1e698
decl %edx
movl %edx, %eax
sarl $0x1f, %eax
andl %edx, %eax
cltq
movl %edx, %ecx
negl %ecx
cmovsl %edx, %ecx
incl %ecx
shlq $0x2, %rax
addq 0x15520(%rip), %rax     # 0x1e6c0
xorl %edx, %edx
movl $0x1, (%rax,%rdx,4)
incq %rdx
cmpl %edx, %ecx
jne 0x91a2
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x14e4f(%rip), %rax     # 0x1e6a0
movslq %edi, %rdi
movq (%rax,%rdi,8), %r14
callq 0x7892
movl 0x14e39(%rip), %ecx     # 0x1e69c
cmpl %ecx, %eax
cmovll %eax, %ecx
movslq %ecx, %rax
shlq $0x4, %rax
leaq (%r14,%rax), %r15
addq $-0x10, %r15
cmpq %r15, %r14
je 0x9880
jbe 0x9886
jmp 0x98aa
cmpl $0x20, (%r14)
je 0x98aa
leaq 0xc(%rsp), %rbx
movl (%r14), %edi
movq %rbx, %rsi
callq 0x723d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97e5
addq $0x10, %r14
cmpq %r15, %r14
jbe 0x988b
leaq 0x8dc8(%rip), %rdi      # 0x12679
movl $0x1, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x97e5
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %ebx
leaq 0x15680(%rip), %rdi     # 0x20738
movl $0xa8, %edx
xorl %esi, %esi
callq 0x60c0
movq 0x15675(%rip), %rdi     # 0x20740
movl $0x200, %esi            # imm = 0x200
callq 0x71e9
movq $0x0, 0x15658(%rip) # 0x20738
movq %rax, 0x15659(%rip)     # 0x20740
movq $0x200, 0x15656(%rip) # imm = 0x200
leaq 0x15657(%rip), %rdi     # 0x20750
movl $0x90, %edx
xorl %esi, %esi
callq 0x60c0
cmpl $0x9d, %ebx
jg 0xb121
cmpl $0x90, %ebx
je 0xb135
cmpl $0x9d, %ebx
jne 0xb13b
movb $0x5d, %bl
jmp 0xb13b
cmpl $0x9e, %ebx
je 0xb139
cmpl $0x9f, %ebx
jne 0xb13b
movb $0x5f, %bl
jmp 0xb13b
movb $0x50, %bl
jmp 0xb13b
movb $0x5e, %bl
leaq 0x155f6(%rip), %rdi     # 0x20738
movl $0xa8, %edx
xorl %esi, %esi
callq 0x60c0
movq 0x155eb(%rip), %rdi     # 0x20740
movl $0x200, %esi            # imm = 0x200
callq 0x71e9
movq $0x0, 0x155ce(%rip) # 0x20738
movq %rax, 0x155cf(%rip)     # 0x20740
movq $0x200, 0x155cc(%rip) # imm = 0x200
leaq 0x155cd(%rip), %rdi     # 0x20750
movl $0x90, %edx
xorl %esi, %esi
callq 0x60c0
movb %bl, 0x155a3(%rip)      # 0x20738
orb $0x4, 0x1355c(%rip)     # 0x1e6f8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movl %esi, %r14d
movl %edi, %ebp
testl %edx, %edx
cmovnel %edi, %r14d
leaq 0xf(%rsp), %rsi
leaq 0xe(%rsp), %rdx
leaq 0xd(%rsp), %rcx
movl %r14d, %edi
callq 0xc052
testl %eax, %eax
jne 0xb348
testl %ebx, %ebx
leaq 0xc57f(%rip), %rax      # 0x1785e
leaq 0xbac0(%rip), %rcx      # 0x16da6
cmoveq %rax, %rcx
movzbl 0xf(%rsp), %r9d
movzbl 0xe(%rsp), %r10d
movzbl 0xd(%rsp), %r11d
subq $0x8, %rsp
leaq 0x7614(%rip), %rdx      # 0x1291b
leaq 0x18(%rsp), %rdi
movl $0x20, %esi
movl %ebp, %r8d
xorl %eax, %eax
pushq %r11
pushq %r11
pushq %r10
pushq %r10
pushq %r9
callq 0x60d0
addq $0x30, %rsp
cmpl $0x20, %eax
jae 0xb379
movl %eax, %esi
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
callq 0x8037
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
testl %ebx, %ebx
movq 0x11c9f(%rip), %rax     # 0x1cff0
movq (%rax), %rdi
leaq 0x75bc(%rip), %rax      # 0x12917
leaq 0x75b0(%rip), %rdx      # 0x12912
cmoveq %rax, %rdx
leaq 0x7580(%rip), %rsi      # 0x128ed
movl %r14d, %ecx
xorl %eax, %eax
callq 0x6970
jmp 0xb33f
xorl %esi, %esi
testl %ebx, %ebx
sete %sil
movl %eax, %edi
callq 0x6e39
jmp 0xb33f
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0xb413
movl 0x13299(%rip), %r14d    # 0x1e69c
subl 0x132ce(%rip), %r14d    # 0x1e6d8
cmpl %edi, %r14d
cmovgel %edi, %r14d
jmp 0xb416
xorl %r14d, %r14d
movslq 0x132bb(%rip), %rbx     # 0x1e6d8
leal (%rbx,%r14), %eax
movslq 0x13274(%rip), %rdx     # 0x1e69c
movslq %eax, %rdi
subq %rdi, %rdx
movq 0x1326b(%rip), %rax     # 0x1e6a0
movslq 0x132a0(%rip), %rcx     # 0x1e6dc
movq (%rax,%rcx,8), %rax
shlq $0x4, %rdi
addq %rax, %rdi
movq %rbx, %rsi
shlq $0x4, %rsi
addq %rax, %rsi
shlq $0x4, %rdx
callq 0x6580
movl 0x1327c(%rip), %ecx     # 0x1e6dc
leal (%rbx,%r14), %edx
decl %edx
movl %ebx, %edi
movl %ecx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8fe3
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %esi, %esi
js 0xb499
movl 0x13266(%rip), %r14d    # 0x1e6f0
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0xb49c
xorl %r14d, %r14d
movslq %ebx, %r15
testl %edx, %edx
je 0xb4dd
movl 0x1320f(%rip), %eax     # 0x1e6b8
incl %eax
leaq 0x120ce(%rip), %rcx     # 0x1d580
xorl %edx, %edx
divl (%rcx)
movl %edx, 0x131fc(%rip)     # 0x1e6b8
movq 0x131ed(%rip), %rax     # 0x1e6b0
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x131cf(%rip), %rsi     # 0x1e6a0
movq (%rsi,%r15,8), %rdi
movq %rdi, (%rax,%rcx,8)
movq %rdx, (%rsi,%r15,8)
movl 0x131b9(%rip), %edx     # 0x1e69c
decl %edx
leal (%r14,%rbx), %ebp
leal (%r14,%rbx), %ecx
decl %ecx
xorl %edi, %edi
movl %ebx, %esi
callq 0x8fe3
movl 0x131f2(%rip), %esi     # 0x1e6f0
movl %ebp, %edi
callq 0x74a4
movl 0x131e5(%rip), %eax     # 0x1e6f0
subl %r14d, %eax
subl %ebx, %eax
jl 0xb542
movslq %r14d, %rcx
movq 0x13184(%rip), %rdx     # 0x1e6a0
addq %r15, %rcx
leaq (%rdx,%rcx,8), %rcx
leaq (%rdx,%r15,8), %rdx
incl %eax
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movq (%rcx,%rsi,8), %r8
movq %r8, (%rdx,%rsi,8)
movq %rdi, (%rcx,%rsi,8)
incq %rsi
cmpl %esi, %eax
jne 0xb52b
negl %r14d
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8aef
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %esi, %esi
js 0xb579
movl 0x13186(%rip), %r14d    # 0x1e6f0
subl %ebx, %r14d
incl %r14d
cmpl %esi, %r14d
cmovgel %esi, %r14d
jmp 0xb57c
xorl %r14d, %r14d
testl %edx, %edx
je 0xb5c5
movl 0x13132(%rip), %eax     # 0x1e6b8
leaq 0x11ff3(%rip), %rcx     # 0x1d580
movl (%rcx), %ecx
addl %ecx, %eax
decl %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x1311b(%rip)     # 0x1e6b8
movq 0x1310c(%rip), %rax     # 0x1e6b0
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdx
movq 0x130ee(%rip), %rsi     # 0x1e6a0
movslq 0x13137(%rip), %rdi     # 0x1e6f0
movq (%rsi,%rdi,8), %r8
movq %r8, (%rax,%rcx,8)
movq %rdx, (%rsi,%rdi,8)
movl 0x13125(%rip), %esi     # 0x1e6f0
subl %r14d, %esi
movl %ebx, %edi
callq 0x74a4
movl 0x13115(%rip), %ecx     # 0x1e6f0
movl %ecx, %esi
subl %r14d, %esi
incl %esi
movl 0x130b4(%rip), %edx     # 0x1e69c
decl %edx
xorl %edi, %edi
callq 0x8fe3
movslq 0x130f8(%rip), %rax     # 0x1e6f0
leal (%r14,%rbx), %ecx
cmpl %ecx, %eax
jl 0xb636
movslq %r14d, %rdi
movslq %ecx, %rcx
movq 0x13093(%rip), %rdx     # 0x1e6a0
incq %rax
shlq $0x3, %rdi
movq %rdx, %rsi
subq %rdi, %rsi
movq -0x8(%rdx,%rax,8), %rdi
movq -0x8(%rsi,%rax,8), %r8
movq %r8, -0x8(%rdx,%rax,8)
movq %rdi, -0x8(%rsi,%rax,8)
decq %rax
cmpq %rcx, %rax
jg 0xb61a
movl %ebx, %edi
movl %r14d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8aef
// File: /workspace/github_c_makefile_star2_O1/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:
testl %edi, %edi
js 0xba11
movl 0x12c98(%rip), %eax     # 0x1e69c
subl 0x12cce(%rip), %eax     # 0x1e6d8
cmpl %edi, %eax
cmovgel %edi, %eax
jmp 0xba13
xorl %eax, %eax
pushq %rbx
movslq 0x12cbd(%rip), %rdi     # 0x1e6d8
movslq %eax, %rbx
leaq (%rdi,%rbx), %rsi
movslq 0x12c73(%rip), %rdx     # 0x1e69c
movslq %esi, %rax
subq %rax, %rdx
movq 0x12c6a(%rip), %rax     # 0x1e6a0
movslq 0x12c9f(%rip), %rcx     # 0x1e6dc
movq (%rax,%rcx,8), %rax
shlq $0x4, %rdi
addq %rax, %rdi
shlq $0x4, %rsi
addq %rax, %rsi
shlq $0x4, %rdx
callq 0x6580
movl 0x12c3e(%rip), %edx     # 0x1e69c
movl %edx, %edi
subl %ebx, %edi
movl 0x12c74(%rip), %ecx     # 0x1e6dc
decl %edx
movl %ecx, %esi
popq %rbx
jmp 0x8fe3
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0xbdce
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x15074(%rip), %rdi     # 0x20df0
callq 0x6380
movq %r14, 0x15068(%rip)     # 0x20df0
movq 0x14e39(%rip), %rdi     # 0x20bc8
movq 0x14e42(%rip), %rdx     # 0x20bd8
movl $0x1, %esi
movq %rbx, %rcx
callq 0x66a0
movq 0x14e1e(%rip), %rdi     # 0x20bc8
movl $0x1, %esi
callq 0x69e0
cmpq 0x14e1d(%rip), %rax     # 0x20bd8
je 0xbdc2
callq 0x7379
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbd02
retq
// File: /workspace/github_c_makefile_star2_O1/mcaimi[P]st/x.c
// Function: xloadcols
void
xloadcols(void)
{
  int i;
  static int loaded;
  Color *cp;

  if (loaded) {
    for (cp = dc.col; cp < &dc.col[dc.collen]; ++cp)
      XftColorFree(xw.dpy, xw.vis, xw.cmap, cp);
  } else {
    dc.collen = MAX(LEN(colorname), 256);
    dc.col = xmalloc(dc.collen * sizeof(Color));
  }

  for (i = 0; i < dc.collen; i++)
    if (!xloadcolor(i, NULL, &dc.col[i])) {
      if (colorname[i])
        die("could not allocate color '%s'\n", colorname[i]);
      else
        die("could not allocate color %d\n", i);
    }

  /* set alpha value of bg color */
  if (USE_ARGB) {
    currentAlpha = is_focused ? alpha : alpha_unfocused;
    dc.col[defaultbg].color.alpha = (0xffff * currentAlpha) / OPAQUE;
    dc.col[defaultbg].pixel &= 0x00111111;
    dc.col[defaultbg].pixel |= currentAlpha << 24;
  }
  loaded = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x1, 0x14ced(%rip)     # 0x20acc
jne 0xbe2c
cmpq $0x0, 0x14cef(%rip)     # 0x20ad8
jle 0xbe48
movq 0x14cde(%rip), %rbx     # 0x20ad0
movq 0x14dcf(%rip), %rdi     # 0x20bc8
movq 0x14e70(%rip), %rsi     # 0x20c70
movq 0x14dc9(%rip), %rdx     # 0x20bd0
movq %rbx, %rcx
callq 0x6660
addq $0x10, %rbx
movq 0x14cbe(%rip), %rax     # 0x20ad8
shlq $0x4, %rax
addq 0x14cab(%rip), %rax     # 0x20ad0
cmpq %rax, %rbx
jb 0xbdf2
jmp 0xbe48
movq $0x106, 0x14ca1(%rip) # imm = 0x106
movl $0x1060, %edi           # imm = 0x1060
callq 0x7125
movq %rax, 0x14c88(%rip)     # 0x20ad0
cmpq $0x0, 0x14c88(%rip)     # 0x20ad8
je 0xbebb
leaq 0x11777(%rip), %r12     # 0x1d5d0
leaq 0xb0a9(%rip), %rbx      # 0x16f09
leaq 0xb083(%rip), %r14      # 0x16eea
xorl %r13d, %r13d
xorl %r15d, %r15d
movq 0x14c5c(%rip), %rdx     # 0x20ad0
addq %r13, %rdx
movl %r15d, %edi
xorl %esi, %esi
callq 0xbf36
testl %eax, %eax
jne 0xbea7
movq (%r12), %rsi
testq %rsi, %rsi
je 0xbe9a
movq %r14, %rdi
xorl %eax, %eax
callq 0x714f
jmp 0xbea7
movq %rbx, %rdi
movl %r15d, %esi
xorl %eax, %eax
callq 0x714f
incq %r15
addq $0x8, %r12
addq $0x10, %r13
cmpq %r15, 0x14c1f(%rip)     # 0x20ad8
ja 0xbe6d
movl 0x116e3(%rip), %eax     # 0x1d5a4
cmpl $0xff, %eax
je 0xbf25
cmpq $0x0, 0x14e30(%rip)     # 0x20d00
jne 0xbf25
cmpb $0x0, 0x14e2f(%rip)     # 0x20d08
je 0xbee1
movl 0x116c7(%rip), %eax     # 0x1d5a8
movl %eax, 0x14e25(%rip)     # 0x20d0c
movl %eax, %ecx
shll $0x10, %ecx
subl %eax, %ecx
movl $0x80808081, %edx       # imm = 0x80808081
imulq %rcx, %rdx
shrq $0x27, %rdx
movq 0x14bce(%rip), %rcx     # 0x20ad0
movl 0x116a4(%rip), %esi     # 0x1d5ac
shlq $0x4, %rsi
movw %dx, 0xe(%rcx,%rsi)
movq (%rcx,%rsi), %rdx
andl $0x111111, %edx         # imm = 0x111111
shll $0x18, %eax
orq %rdx, %rax
movq %rax, (%rcx,%rsi)
movb $0x1, 0x14ba0(%rip)     # 0x20acc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq