LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/liball/../lib/util/kvlds.c
// Function: kvlds_range
int
kvlds_range(struct wire_requestqueue * Q, const struct kvldskey * start,
    const struct kvldskey * end, int (* callback)(void *,
        const struct kvldskey *, const struct kvldskey *),
    void * cookie)
{
	struct rangecookie C = {
		.callback = callback,
		.cookie = cookie,
		.C = { .done = 0 }
	};

	/* Start dumping key-value pairs. */
	if (proto_kvlds_request_range2(Q, start, end,
	    callback_range_item, callback_range_done, &C)) {
		warnp("proto_kvlds_request_range2");
		goto err0;
	}

	/* Wait until we've finished. */
	if (events_spin(&C.C.done)) {
		warnp("Error running event loop");
		goto err0;
	}

	/* Did we succeed? */
	return (C.C.failed);

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

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %r9
movq %rcx, (%r9)
movq %r8, 0x8(%r9)
movq $0x0, 0x10(%r9)
leaq 0x7f(%rip), %rcx        # 0x4390
leaq 0x81(%rip), %r8         # 0x4399
callq 0x7af6
testl %eax, %eax
je 0x4337
callq 0x20a0
cmpl $0x0, (%rax)
je 0x4368
movq %rax, %rbx
leaq 0x8327(%rip), %rdi      # 0xc65c
jmp 0x4359
leaq 0x1c(%rsp), %rdi
callq 0x4879
testl %eax, %eax
je 0x4371
callq 0x20a0
cmpl $0x0, (%rax)
je 0x4377
movq %rax, %rbx
leaq 0x82ea(%rip), %rdi      # 0xc643
xorl %eax, %eax
callq 0x3c3c
movl $0x0, (%rbx)
jmp 0x4385
leaq 0x82ed(%rip), %rdi      # 0xc65c
jmp 0x437e
movl 0x18(%rsp), %eax
jmp 0x438a
leaq 0x82c5(%rip), %rdi      # 0xc643
xorl %eax, %eax
callq 0x3d5b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/liball/../lib/util/kvlds.c
// Function: kvlds_set
int
kvlds_set(struct wire_requestqueue * Q, const struct kvldskey * key,
    const struct kvldskey * value)
{
	struct donecookie C = {
		.done = 0,
		.failed = 0
	};

	/* Initiate the request. */
	if (proto_kvlds_request_set(Q, key, value, callback_done, &C)) {
		warnp("proto_kvlds_request_set");
		goto err0;
	}

	/* Wait until we've finished. */
	if (events_spin(&C.done)) {
		warnp("Error running event loop");
		goto err0;
	}

	/* Interpret results. */
	if (C.failed)
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %r8
movq $0x0, (%r8)
leaq 0x7d(%rip), %rcx        # 0x443b
callq 0x6b19
testl %eax, %eax
je 0x43dd
callq 0x20a0
cmpl $0x0, (%rax)
je 0x440e
movq %rax, %rbx
leaq 0x829c(%rip), %rdi      # 0xc677
jmp 0x43ff
leaq 0xc(%rsp), %rdi
callq 0x4879
testl %eax, %eax
je 0x4417
callq 0x20a0
cmpl $0x0, (%rax)
je 0x4422
movq %rax, %rbx
leaq 0x8244(%rip), %rdi      # 0xc643
xorl %eax, %eax
callq 0x3c3c
movl $0x0, (%rbx)
jmp 0x4430
leaq 0x8262(%rip), %rdi      # 0xc677
jmp 0x4429
cmpl $0x0, 0x8(%rsp)
jne 0x4430
xorl %eax, %eax
jmp 0x4435
leaq 0x821a(%rip), %rdi      # 0xc643
xorl %eax, %eax
callq 0x3d5b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/liball/../lib/util/kvlds.c
// Function: kvlds_get
int
kvlds_get(struct wire_requestqueue * Q, const struct kvldskey * key,
    struct kvldskey ** value)
{
	struct getcookie C = {
		.done = 0,
		.failed = 0,
		.value = NULL
	};

	/* Initiate the request. */
	if (proto_kvlds_request_get(Q, key, callback_get, &C)) {
		warnp("proto_kvlds_request_get");
		goto err0;
	}

	/* Wait until we've finished. */
	if (events_spin(&C.done)) {
		warnp("Error running event loop");
		goto err0;
	}

	/* Interpret results. */
	if (C.failed)
		goto err0;
	*value = C.value;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
leaq 0x89(%rip), %rdx        # 0x44e8
callq 0x743e
testl %eax, %eax
je 0x447e
callq 0x20a0
cmpl $0x0, (%rax)
je 0x44af
movq %rax, %rbx
leaq 0x8213(%rip), %rdi      # 0xc68f
jmp 0x44a0
leaq 0x4(%rsp), %rdi
callq 0x4879
testl %eax, %eax
je 0x44b8
callq 0x20a0
cmpl $0x0, (%rax)
je 0x44cf
movq %rax, %rbx
leaq 0x81a3(%rip), %rdi      # 0xc643
xorl %eax, %eax
callq 0x3c3c
movl $0x0, (%rbx)
jmp 0x44dd
leaq 0x81d9(%rip), %rdi      # 0xc68f
jmp 0x44d6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x0, (%rsp)
jne 0x44e2
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0x44e2
leaq 0x816d(%rip), %rdi      # 0xc643
xorl %eax, %eax
callq 0x3d5b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]kivaloo/liball/../lib/util/kvlds.c
// Function: kvlds_delete
int
kvlds_delete(struct wire_requestqueue * Q, const struct kvldskey * key)
{
	struct donecookie C = {
		.done = 0,
		.failed = 0
	};

	/* Initiate the request. */
	if (proto_kvlds_request_delete(Q, key, callback_done, &C)) {
		warnp("proto_kvlds_request_delete");
		goto err0;
	}

	/* Wait until we've finished. */
	if (events_spin(&C.done)) {
		warnp("Error running event loop");
		goto err0;
	}

	/* Interpret results. */
	if (C.failed)
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rcx
movq $0x0, (%rcx)
leaq -0xd5(%rip), %rdx       # 0x443b
callq 0x71d2
testl %eax, %eax
je 0x452f
callq 0x20a0
cmpl $0x0, (%rax)
je 0x4560
movq %rax, %rbx
leaq 0x817a(%rip), %rdi      # 0xc6a7
jmp 0x4551
leaq 0xc(%rsp), %rdi
callq 0x4879
testl %eax, %eax
je 0x4569
callq 0x20a0
cmpl $0x0, (%rax)
je 0x4574
movq %rax, %rbx
leaq 0x80f2(%rip), %rdi      # 0xc643
xorl %eax, %eax
callq 0x3c3c
movl $0x0, (%rbx)
jmp 0x4582
leaq 0x8140(%rip), %rdi      # 0xc6a7
jmp 0x457b
cmpl $0x0, 0x8(%rsp)
jne 0x4582
xorl %eax, %eax
jmp 0x4587
leaq 0x80c8(%rip), %rdi      # 0xc643
xorl %eax, %eax
callq 0x3d5b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Keith-S-Thompson[P]kst-time-utils/clock_gettime.c
// Function: main
int main(int argc, char **argv) {
    bool ok = true;
    bool show_res = false;
    bool shown = false;

    for (int i = 1; i < argc; i ++) {
        if (strlen(argv[i]) == 2 && argv[i][0] == '-') {
            switch (argv[i][1]) {
                case 'R':
                    show_res = true;
                    break;
                case 'r':
                    ok = ok && show(CLOCK_REALTIME, show_res);
                    shown = true;
                    break;
#ifdef CLOCK_TAI
                case 'T':
                    ok = ok && show(CLOCK_TAI, show_res);
                    shown = true;
                    break;
#endif
                case 'm':
                    ok = ok && show(CLOCK_MONOTONIC, show_res);
                    shown = true;
                    break;
#ifdef CLOCK_MONOTONIC_RAW
                case 'M':
                    ok = ok && show(CLOCK_MONOTONIC_RAW, show_res);
                    shown = true;
                    break;
#endif
                case 'p':
                    ok = ok && show(CLOCK_PROCESS_CPUTIME_ID, show_res);
                    shown = true;
                    break;
                case 't':
                    ok = ok && show(CLOCK_THREAD_CPUTIME_ID, show_res);
                    shown = true;
                    break;
                default:
                    usage();
                    break;
            }
        }
        else {
            usage();
        }
    }

    if (!shown) {
        ok = ok && show(CLOCK_REALTIME, show_res);
    }

    exit(ok ? EXIT_SUCCESS : EXIT_FAILURE);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x12ae
movq %rsi, %rbx
movl %edi, %r12d
movb $0x1, %bpl
movl $0x1, %r13d
xorl %r15d, %r15d
movl $0x0, 0x4(%rsp)
movq (%rbx,%r13,8), %r14
movq %r14, %rdi
callq 0x1050
cmpq $0x2, %rax
jne 0x12cb
cmpb $0x2d, (%r14)
jne 0x12cb
movzbl 0x1(%r14), %eax
cmpl $0x6c, %eax
jle 0x1217
addl $-0x6d, %eax
cmpl $0x7, %eax
ja 0x12cb
leaq 0xdfd(%rip), %rcx       # 0x2004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, %edi
jmp 0x1250
cmpl $0x4d, %eax
je 0x124b
cmpl $0x52, %eax
je 0x1243
cmpl $0x54, %eax
jne 0x12cb
movl $0xb, %edi
jmp 0x1250
movl $0x3, %edi
jmp 0x1250
movl $0x2, %edi
jmp 0x1250
xorl %edi, %edi
jmp 0x1250
movb $0x1, %al
movl %eax, 0x4(%rsp)
jmp 0x127b
movl $0x4, %edi
testb $0x1, %bpl
je 0x1276
testb $0x1, 0x4(%rsp)
leaq 0x137(%rip), %rax       # 0x1399
leaq 0xe7(%rip), %rcx        # 0x1350
cmovneq %rcx, %rax
callq *%rax
movl %eax, %ebp
movb $0x1, %r15b
jmp 0x127b
movb $0x1, %r15b
xorl %ebp, %ebp
incq %r13
cmpq %r13, %r12
jne 0x11ca
testb $0x1, %r15b
jne 0x12bb
testb $0x1, 0x4(%rsp)
leaq 0x100(%rip), %rax       # 0x1399
leaq 0xb0(%rip), %rcx        # 0x1350
cmovneq %rcx, %rax
testb $0x1, %bpl
jne 0x12b5
xorl %ebp, %ebp
jmp 0x12bb
leaq 0xe4(%rip), %rax        # 0x1399
xorl %edi, %edi
callq *%rax
movl %eax, %ebp
notb %bpl
andb $0x1, %bpl
movzbl %bpl, %edi
callq 0x1090
callq 0x12d0
// File: /workspace/github_c_makefile_star2_O3/Keith-S-Thompson[P]kst-time-utils/clock_gettime.c
// Function: usage
static void usage(void) {
    puts("Usage: clock_gettime [options]");
    puts("  -r    CLOCK_REALTIME, system-wide real-time clock (default)");
    puts("  -T    CLOCK_TAI, International Atomic Time (no leap seconds)");
#ifndef CLOCK_TAI
    puts("        CLOCK_TAI is not supported on this system");
#endif
    puts("  -m    CLOCK_MONOTONIC, monotonic time since some unspecified starting point");
    puts("  -M    CLOCK_MONOTONIC_RAW, hardware-based timer with no ntp adjustments");
#ifndef CLOCK_MONOTONIC_RAW
    puts("        CLOCK_MONOTONIC_RAW is not supported on this system");
#endif
    puts("  -p    CLOCK_PROCESS_CPUTIME_ID, high-resolution per-process timer from the CPU");
    puts("  -t    CLOCK_THREAD_CPUTIME_ID, thread-specific CPU-time clock");
    puts("(-p and -t are not particularly meaningful in this context.)");
    puts("  -R    Show resolution (calls clock_getres), may be followed by other options");
    puts("Multiple arguments may be given");
    exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rax
leaq 0xd72(%rip), %rdi       # 0x204a
callq 0x1030
leaq 0xd85(%rip), %rdi       # 0x2069
callq 0x1030
leaq 0xdb7(%rip), %rdi       # 0x20a7
callq 0x1030
leaq 0xdea(%rip), %rdi       # 0x20e6
callq 0x1030
leaq 0xe2c(%rip), %rdi       # 0x2134
callq 0x1030
leaq 0xe6a(%rip), %rdi       # 0x217e
callq 0x1030
leaq 0xeaf(%rip), %rdi       # 0x21cf
callq 0x1030
leaq 0xee3(%rip), %rdi       # 0x220f
callq 0x1030
leaq 0xf14(%rip), %rdi       # 0x224c
callq 0x1030
leaq 0xf57(%rip), %rdi       # 0x229b
callq 0x1030
xorl %edi, %edi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O3/Keith-S-Thompson[P]kst-time-utils/clock_gettime.c
// Function: show_res
static bool show_res(clockid_t clk_id) {
    struct timespec ts = { 0, 0 };
    if (clock_getres(clk_id, &ts) == 0) {
        printf("%ld.%09ld\n", (long)ts.tv_sec, (long)ts.tv_nsec);
        return true;
    }
    else {
        perror("clock_getres");
        return false;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
callq 0x1070
movl %eax, %ebx
testl %eax, %eax
jne 0x138b
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0xcab(%rip), %rdi       # 0x2024
xorl %eax, %eax
callq 0x1060
testl %ebx, %ebx
sete %al
addq $0x10, %rsp
popq %rbx
retq
leaq 0xc9d(%rip), %rdi       # 0x202f
callq 0x1080
jmp 0x1380
// File: /workspace/github_c_makefile_star2_O3/Keith-S-Thompson[P]kst-time-utils/clock_gettime.c
// Function: show_time
static bool show_time(clockid_t clk_id) {
    struct timespec ts = { 0, 0 };
    if (clock_gettime(clk_id, &ts) == 0) {
        printf("%ld.%09ld\n", (long)ts.tv_sec, (long)ts.tv_nsec);
        return true;
    }
    else {
        perror("clock_gettime");
        return false;
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
callq 0x1040
movl %eax, %ebx
testl %eax, %eax
jne 0x13d4
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0xc62(%rip), %rdi       # 0x2024
xorl %eax, %eax
callq 0x1060
testl %ebx, %ebx
sete %al
addq $0x10, %rsp
popq %rbx
retq
leaq 0xc61(%rip), %rdi       # 0x203c
callq 0x1080
jmp 0x13c9
// File: /workspace/github_c_makefile_star2_O3/randyrossi[P]fisher-modem/mkfilter/src/mkaverage.C
// Function: main.cold.1
static void giveup(const char* msg, int p1) {
  fprintf(stderr, "mkaverage: ");
  fprintf(stderr, msg, p1);
  putc('\n', stderr);
  exit(1);
}

// Assembly:
pushq %rbx
movq 0x2ea8(%rip), %rbx      # 0x3fe0
movq (%rbx), %rcx
leaq 0xf43(%rip), %rdi       # 0x2085
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
callq 0x1110
movq (%rbx), %rdi
leaq 0xeb1(%rip), %rsi       # 0x2008
movl $0x201, %edx            # imm = 0x201
xorl %eax, %eax
callq 0x10b0
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x1100
pushq $0x1
popq %rdi
callq 0x1080
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/randyrossi[P]fisher-modem/mkfilter/src/mkaverage.C
// Function: main
static void readcmdline(char* argv[]) {
  int ap = 0, n = 0;
  unless(argv[ap] == NULL) ap++; /* skip program name */
  unless(argv[ap] != NULL && seq(argv[ap++], "-Av")) usage();
  lflag = false;
  until(argv[ap] == NULL) {
    char* s = argv[ap++];
    if (seq(s, "-l"))
      lflag = true;
    else if (n == 0) {
      numcoeffs = atoi(s);
      n++;
    } else
      usage();
  }
  unless(n == 1) usage();
  /* (num.zeros) = (num.coeffs) - 1 */
  if (numcoeffs < 1 || numcoeffs > MAXPZ + 1)
    giveup("filter length must be in range 1 .. %d", MAXPZ + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r14
xorl %eax, %eax
testq %r14, %r14
setne %al
movq (%rsi,%rax,8), %rdi
testq %rdi, %rdi
je 0x1442
movq %rsi, %rbx
leaq 0xd6b(%rip), %rsi       # 0x2004
callq 0x10a0
testl %eax, %eax
jne 0x1442
cmpq $0x1, %r14
movl $0x1, %r15d
sbbq $-0x1, %r15
movl %r15d, %eax
movq (%rbx,%rax,8), %rdi
testq %rdi, %rdi
je 0x1442
movb $0x1, %cl
xorl %ebp, %ebp
xorl %edx, %edx
incq %r15
cmpb $0x2d, (%rdi)
jne 0x12ef
cmpb $0x6c, 0x1(%rdi)
jne 0x12ef
cmpb $0x0, 0x2(%rdi)
jne 0x12ef
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x1332
incq %r15
movb $0x1, %bpl
jmp 0x12cd
testb $0x1, %cl
je 0x1442
callq 0x10d0
movl %eax, 0x2da1(%rip)      # 0x40a4
movq (%rbx,%r15,8), %rdi
movb $0x1, %dl
xorl %ecx, %ecx
testq %rdi, %rdi
jne 0x12ca
addl $0xfffffdfe, %eax       # imm = 0xFFFFFDFE
cmpl $0xfffffdff, %eax       # imm = 0xFFFFFDFF
jb 0x1447
testb $0x1, %bpl
jne 0x1350
leaq 0xd7f(%rip), %rbx       # 0x20ac
jmp 0x1429
testb $0x1, %dl
je 0x1442
movl $0xfffffdfe, %eax       # imm = 0xFFFFFDFE
movl 0x2d5e(%rip), %ecx      # 0x40a4
addl %eax, %ecx
cmpl %eax, %ecx
jbe 0x1447
testq %r14, %r14
je 0x138f
xorl %r12d, %r12d
movq 0x2c69(%rip), %r15      # 0x3fc8
testq %r12, %r12
je 0x1372
movl $0x20, %edi
callq 0x1090
movq (%rbx,%r12,8), %r14
leaq 0x1(%r12), %r13
movq (%r15), %rsi
movq %r14, %rdi
callq 0x1070
movq 0x8(%rbx,%r12,8), %r14
movq %r13, %r12
testq %r14, %r14
jne 0x135f
movl $0xa, %edi
callq 0x1090
movl 0x2d05(%rip), %esi      # 0x40a4
leaq 0xceb(%rip), %rdi       # 0x2091
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1030
movl 0x2cef(%rip), %esi      # 0x40a4
decl %esi
leaq 0xcdc(%rip), %rdi       # 0x209a
xorl %eax, %eax
callq 0x1030
movl 0x2cd9(%rip), %esi      # 0x40a4
testl %esi, %esi
jle 0x13ea
leaq 0xcdb(%rip), %rbx       # 0x20b1
movq %rbx, %rdi
callq 0x10c0
incl %ebp
movl 0x2cbe(%rip), %esi      # 0x40a4
cmpl %esi, %ebp
jl 0x13d6
decl %esi
leaq 0xcb0(%rip), %rdi       # 0x20a3
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1030
leaq 0xcad(%rip), %rbx       # 0x20b0
cmpl $0x2, 0x2c9a(%rip)      # 0x40a4
jl 0x1429
leaq 0xca0(%rip), %r14       # 0x20b3
movq %r14, %rdi
callq 0x10c0
incl %ebp
movl 0x2c81(%rip), %eax      # 0x40a4
decl %eax
cmpl %eax, %ebp
jl 0x1413
movq %rbx, %rdi
callq 0x10c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x144c
callq 0x1130
// File: /workspace/github_c_makefile_star2_O3/randyrossi[P]fisher-modem/mkfilter/src/complex.C
// Function: csqrt(complex)
global complex csqrt(complex x) {
  double r = hypot(x);
  complex z = complex(Xsqrt(0.5 * (r + x.re)), Xsqrt(0.5 * (r - x.re)));
  if (x.im < 0.0)
    z.im = -z.im;
  return z;
}

// Assembly:
subq $0x38, %rsp
movapd %xmm0, %xmm2
movsd %xmm0, (%rsp)
movapd %xmm1, 0x20(%rsp)
movapd %xmm1, %xmm0
movapd %xmm2, %xmm1
callq 0x1050
movsd (%rsp), %xmm5
movapd %xmm0, %xmm2
addsd %xmm5, %xmm0
mulsd 0xad7(%rip), %xmm0      # 0x20b8
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
xorpd %xmm3, %xmm3
jb 0x1620
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x1602
xorps %xmm3, %xmm3
sqrtsd %xmm0, %xmm3
jmp 0x1620
movsd %xmm2, 0x18(%rsp)
callq 0x1060
movsd (%rsp), %xmm5
movsd 0x18(%rsp), %xmm2
xorpd %xmm4, %xmm4
movapd %xmm0, %xmm3
subsd %xmm5, %xmm2
mulsd 0xa8c(%rip), %xmm2      # 0x20b8
ucomisd %xmm4, %xmm2
jb 0x165c
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x1645
xorps %xmm4, %xmm4
sqrtsd %xmm2, %xmm4
jmp 0x165c
movapd %xmm2, %xmm0
movapd %xmm3, (%rsp)
callq 0x1060
movapd (%rsp), %xmm3
movapd %xmm0, %xmm4
movapd 0xa5c(%rip), %xmm0      # 0x20c0
xorpd %xmm4, %xmm0
xorpd %xmm2, %xmm2
movapd 0x20(%rsp), %xmm1
cmpltsd %xmm2, %xmm1
andpd %xmm1, %xmm0
andnpd %xmm4, %xmm1
orpd %xmm0, %xmm1
movapd %xmm3, %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/stack.c
// Function: push8
void
push8(stack8 st, uint8_t val)
{
	struct node8	*node;

	node = malloc(sizeof(struct node8));

	/* memory problems can only lead to more memory problems. */
	if (NULL == node)
		abort();

	node->val = val;
	node->next = st->st;
	st->st = node;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x10b0
testq %rax, %rax
je 0x12c0
movb %bpl, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/stack.c
// Function: destroy8
void
destroy8(stack8 st)
{
	struct node8 *node = NULL;

	while (NULL != (node = st->st)) {
		st->st = node->next;
		free(node);
	}
	free(st);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x130f
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
callq 0x1030
movq (%rbx), %rdi
jmp 0x12f9
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/stack.c
// Function: push16
void
push16(stack16 st, uint16_t val)
{
	struct node16	*node;

	node = malloc(sizeof(struct node16));

	/* memory problems can only lead to more memory problems. */
	if (NULL == node)
		abort();

	node->val = val;
	node->next = st->st;
	st->st = node;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x10b0
testq %rax, %rax
je 0x135c
movw %bp, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/stack.c
// Function: destroy16
void
destroy16(stack16 st)
{
	struct node16 *node = NULL;

	while (NULL != (node = st->st)) {
		st->st = node->next;
		free(node);
	}
	free(st);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x13ac
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
callq 0x1030
movq (%rbx), %rdi
jmp 0x1396
movq %rbx, %rdi
popq %rbx
jmp 0x1030
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/vm.c
// Function: vm_new
machine
vm_new(void)
{
	machine vm = NULL;

	vm = malloc(sizeof(struct s_vm));
	if (NULL == vm)
		return NULL;

	vm->vals = new_stack16();
	vm->opers = new_stack8();
	vm->pc = 0;

	if ((NULL == vm->vals) || (NULL == vm->opers)) {
		vm_destroy(vm);
		return NULL;
	}
	return vm;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x18, %edi
callq 0x10b0
testq %rax, %rax
je 0x1402
movq %rax, %rbx
callq 0x1318
movq %rax, %r14
movq %rax, (%rbx)
callq 0x127c
movq %rax, 0x8(%rbx)
movw $0x0, 0x10(%rbx)
testq %r14, %r14
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
cmpb $0x1, %al
jne 0x1404
movq %rbx, %rdi
callq 0x140f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/vm.c
// Function: vm_destroy
void
vm_destroy(machine vm)
{
	if (vm) {
		if (vm->vals)
			destroy16(vm->vals);
		if (vm->opers)
			destroy8(vm->opers);
		free(vm);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x143c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1425
callq 0x138f
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1433
callq 0x12f2
movq %rbx, %rdi
popq %rbx
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/vm.c
// Function: vm_step
int
vm_step(machine vm, uint8_t *prog, uint16_t prog_len)
{
	uint16_t	val;
	uint8_t		oper;

	if (NULL == vm) {
		fprintf(stderr, "[!] VM not initialised.\n");
		return VM_ERR;
	}

	if (vm->pc == prog_len)
		return VM_STOP;

	oper = prog[vm->pc];
	vm->pc++;
	switch (oper) {
	case INSTR_STOP:
		return VM_STOP;
	case INSTR_ADD:  /* fall through: store the operator in */
	case INSTR_SUB:  /* the op stack                        */
	case INSTR_DIV:
	case INSTR_MUL:
		push8(vm->opers, oper);
		break;
	case INSTR_IMM:
		/* detect wrap around */
		if ((prog_len - vm->pc) >= prog_len) {
			fprintf(stderr, "[!] PC overflow.\n");
			return VM_ERR;
		}
		/* ensure we have enough progspace left */
		if ((prog_len - vm->pc) < 2) {
			fprintf(stderr, "[!] Out of program space.\n");
			fprintf(stderr, "    %d bytes remain.\n", 
			    prog_len - vm->pc);
			return VM_ERR;
		}
		memcpy(&val, prog + vm->pc, sizeof(val));
		push16(vm->vals, val);
		vm->pc += 2; /* 2 bytes == 16 bits */
		break;
	case INSTR_DO:
		return eval(vm);
	default:
		fprintf(stderr, "[!] Unknown operator: %d.\n", oper);
		return VM_ERR;

	}
	return VM_OK;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1509
movq %rdi, %rbx
movzwl 0x10(%rdi), %ecx
movl $0x2, %ebp
cmpw %dx, %cx
je 0x1493
leaq 0x10(%rbx), %rdi
movzbl (%rsi,%rcx), %eax
incl %ecx
movw %cx, (%rdi)
cmpq $0x6, %rax
ja 0x153f
leaq 0xb8b(%rip), %r8        # 0x2004
movslq (%r8,%rax,4), %r9
addq %r8, %r9
jmpq *%r9
movq 0x8(%rbx), %rdi
movl %eax, %esi
callq 0x1295
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
testw %cx, %cx
je 0x1560
movzwl %dx, %eax
movzwl %cx, %ecx
movl %eax, %edx
subl %ecx, %edx
cmpl $0x1, %edx
jle 0x1567
movzwl (%rsi,%rcx), %esi
movq (%rbx), %rdi
callq 0x1331
addw $0x2, 0x10(%rbx)
jmp 0x148e
movq (%rbx), %rdi
callq 0x1361
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x1361
movl %eax, %r14d
movq 0x8(%rbx), %rdi
callq 0x12c5
movzbl %al, %eax
decl %eax
cmpl $0x3, %eax
ja 0x1570
leaq 0xb28(%rip), %rcx       # 0x2020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %rdi
addl %ebp, %r14d
jmp 0x1531
callq 0x1150
xorl %ebp, %ebp
jmp 0x1493
movq (%rbx), %rdi
imull %ebp, %r14d
jmp 0x1531
movq (%rbx), %rdi
movl %r14d, %eax
xorl %edx, %edx
divw %bp
movzwl %ax, %esi
jmp 0x1535
movq (%rbx), %rdi
subl %ebp, %r14d
movzwl %r14w, %esi
callq 0x1331
jmp 0x148e
movq 0x2ab2(%rip), %rcx      # 0x3ff8
movq (%rcx), %rdi
leaq 0xb3c(%rip), %rsi       # 0x208c
xorl %ebp, %ebp
movl %eax, %edx
xorl %eax, %eax
callq 0x1090
jmp 0x1493
callq 0x1134
jmp 0x150e
movl %eax, %esi
callq 0x10f0
jmp 0x150e
callq 0x1040
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/vm.c
// Function: vm_peek
uint16_t
vm_peek(machine vm)
{
	uint16_t val;

	if (NULL == vm)
		return 0;
	if (NULL == vm->vals)
		return 0;
	if (empty16(vm->vals))
		return 0;

	val = pop16(vm->vals);
	push16(vm->vals, val);
	return val;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x15b6
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x15b6
callq 0x1385
testl %eax, %eax
je 0x15c2
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdi
callq 0x1361
movl %eax, %ebx
movq (%r14), %rdi
movzwl %ax, %esi
callq 0x1331
jmp 0x15b8
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/kisom[P]kam/kamvm.c
// Function: main
int
main(int argc, const char *argv[])
{
	if (0 == argc)
		return interpreter();
	else
		return run(argv[1]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
testl %edi, %edi
je 0x16d7
movq 0x8(%rsi), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x10a0
movl $0x1, %ebp
cmpl $-0x1, %eax
je 0x1700
movq 0x30(%rsp), %r15
leaq 0xab4(%rip), %rdi       # 0x20d0
movq %r15, %rsi
xorl %eax, %eax
callq 0x1080
movq %r15, %rdi
callq 0x10b0
testq %rax, %rax
je 0x1700
movq %rax, %r14
leaq 0xaaa(%rip), %rsi       # 0x20eb
movq %rbx, %rdi
callq 0x10c0
testq %rax, %rax
je 0x16cd
movq %rax, %rbx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x1060
cmpq %rax, %r15
jne 0x16be
callq 0x13b8
testq %rax, %rax
je 0x16be
movq %rax, %r12
leaq 0xa77(%rip), %rdi       # 0x20f4
callq 0x1050
movzwl %r15w, %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x1575
testl %eax, %eax
je 0x16e3
movq %r12, %rdi
callq 0x1599
movzwl %ax, %esi
leaq 0xa47(%rip), %rdi       # 0x20ee
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x1080
leaq 0xa4a(%rip), %rdi       # 0x2101
callq 0x1050
jmp 0x16e8
movq %r14, %rdi
callq 0x1030
movl $0x1, %ebp
jmp 0x16f8
movq %r14, %rdi
callq 0x1030
jmp 0x1700
callq 0x116c
movl $0x1, %ebp
jmp 0x1700
movl $0x1, %ebp
movq %r14, %rdi
callq 0x1030
movq %r12, %rdi
callq 0x140f
movq %rbx, %rdi
callq 0x1070
movl %ebp, %eax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/bgzf.c
// Function: bgzf_mt
int bgzf_mt(BGZF *fp, int n_threads, int n_sub_blks)
{
	int i;
	mtaux_t *mt;
	pthread_attr_t attr;
	if (!fp->is_write || fp->mt || n_threads <= 1) return -1;
	mt = (mtaux_t*)calloc(1, sizeof(mtaux_t));
	mt->n_threads = n_threads;
	mt->n_blks = n_threads * n_sub_blks;
	mt->len = (int*)calloc(mt->n_blks, sizeof(int));
	mt->blk = (void**)calloc(mt->n_blks, sizeof(void*));
	for (i = 0; i < mt->n_blks; ++i)
		mt->blk[i] = malloc(BGZF_MAX_BLOCK_SIZE);
	mt->tid = (pthread_t*)calloc(mt->n_threads, sizeof(pthread_t)); // tid[0] is not used, as the worker 0 is launched by the master
	mt->w = (worker_t*)calloc(mt->n_threads, sizeof(worker_t));
	for (i = 0; i < mt->n_threads; ++i) {
		mt->w[i].i = i;
		mt->w[i].mt = mt;
		mt->w[i].fp = fp;
		mt->w[i].buf = malloc(BGZF_MAX_BLOCK_SIZE);
	}
	pthread_attr_init(&attr);
	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
	pthread_mutex_init(&mt->lock, 0);
	pthread_cond_init(&mt->cv, 0);
	for (i = 1; i < mt->n_threads; ++i) // worker 0 is effectively launched by the master thread
		pthread_create(&mt->tid[i], &attr, mt_worker, &mt->w[i]);
	fp->mt = mt;
	return 0;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb $0x3, 0x2(%rdi)
je 0x40ce
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
cmpl $0x2, %esi
jl 0x40c0
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x40c0
movl %edx, %r12d
movl $0x1, %edi
movl $0x90, %esi
callq 0x21f0
movq %rax, %r14
movl %ebp, (%rax)
imull %ebp, %r12d
movl %r12d, 0x4(%rax)
movslq %r12d, %r13
movl $0x4, %esi
movq %r13, %rdi
callq 0x21f0
movq %rax, 0x20(%r14)
movl $0x8, %esi
movq %r13, %rdi
callq 0x21f0
movq %rax, 0x18(%r14)
testl %r13d, %r13d
jle 0x3fea
movq %rax, %r15
movl %r12d, %r12d
xorl %r13d, %r13d
movl $0x10000, %edi          # imm = 0x10000
callq 0x22a0
movq %rax, (%r15,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x3fd4
movl %ebp, %r15d
movl $0x8, %esi
movq %r15, %rdi
callq 0x21f0
movq %rax, 0x30(%r14)
movl $0x28, %esi
movq %r15, %rdi
callq 0x21f0
movq %rax, %r12
movq %rax, 0x28(%r14)
addq $0x18, %r12
xorl %r13d, %r13d
movl %r13d, (%r12)
movq %r14, -0x10(%r12)
movq %rbx, -0x18(%r12)
movl $0x10000, %edi          # imm = 0x10000
callq 0x22a0
movq %rax, -0x8(%r12)
incq %r13
addq $0x28, %r12
cmpq %r13, %r15
jne 0x4019
movq %rsp, %r12
movq %r12, %rdi
callq 0x21e0
movq %r12, %rdi
xorl %esi, %esi
callq 0x2280
leaq 0x38(%r14), %rdi
xorl %esi, %esi
callq 0x23e0
movq %r14, %rdi
addq $0x60, %rdi
xorl %esi, %esi
callq 0x2270
cmpl $0x2, (%r14)
jl 0x40ba
movl $0x1, %ebp
movl $0x28, %r15d
movl $0x8, %r12d
movq %rsp, %r13
movq 0x30(%r14), %rdi
addq %r12, %rdi
movq 0x28(%r14), %rcx
addq %r15, %rcx
movq %r13, %rsi
leaq 0x2d(%rip), %rdx        # 0x40cf
callq 0x2300
incq %rbp
movslq (%r14), %rax
addq $0x28, %r15
addq $0x8, %r12
cmpq %rax, %rbp
jl 0x408a
movq %r14, 0x38(%rbx)
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/bgzf.c
// Function: bgzf_flush
int bgzf_flush(BGZF *fp)
{
	if (!fp->is_write) return 0;
#ifdef BGZF_MT
	if (fp->mt) return mt_flush(fp);
#endif
	while (fp->block_offset > 0) {
		int block_length;
		block_length = deflate_block(fp, fp->block_offset);
		if (block_length < 0) return -1;
		if (fwrite(fp->compressed_block, 1, block_length, (FILE*)fp->fp) != (size_t)block_length) {
			fp->errcode |= BGZF_ERR_IO; // possibly truncated file
			return -1;
		}
		fp->block_address += block_length;
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %ebx, %ebx
testb $0x3, 0x2(%rdi)
je 0x4144
movq %rdi, %r14
cmpq $0x0, 0x38(%rdi)
je 0x4131
movq %r14, %rdi
callq 0x414c
jmp 0x4144
movq %r14, %rdi
callq 0x4330
testl %eax, %eax
js 0x413f
movl %eax, %r15d
movq 0x20(%r14), %rdi
movq 0x30(%r14), %rcx
movl $0x1, %esi
movq %r15, %rdx
callq 0x23b0
cmpq %r15, %rax
jne 0x413b
addq %r15, 0x10(%r14)
movl 0xc(%r14), %esi
testl %esi, %esi
jg 0x4104
jmp 0x4144
orb $0x4, (%r14)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/bgzf.c
// Function: bgzf_write
ssize_t bgzf_write(BGZF *fp, const void *data, ssize_t length)
{
	const uint8_t *input = (const uint8_t*)data;
	int block_length = BGZF_BLOCK_SIZE, bytes_written = 0;
	assert(fp->is_write);
#ifdef BGZF_MT
	if (fp->mt) return mt_write(fp, data, length);
#endif
	while (bytes_written < length) {
		uint8_t* buffer = (uint8_t*)fp->uncompressed_block;
		int copy_length = block_length - fp->block_offset < length - bytes_written? block_length - fp->block_offset : length - bytes_written;
		memcpy(buffer + fp->block_offset, input, copy_length);
		fp->block_offset += copy_length;
		input += copy_length;
		bytes_written += copy_length;
		if (fp->block_offset == block_length && bgzf_flush(fp)) break;
	}
	return bytes_written;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testb $0x3, 0x2(%rdi)
je 0x44c1
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq $0x0, 0x38(%rdi)
je 0x444d
testq %rbx, %rbx
je 0x44b2
movq %rbx, %r13
movslq 0xc(%r15), %rdi
movl $0xff00, %eax           # imm = 0xFF00
subq %rdi, %rax
cmpq %rax, %r13
movl %r13d, %ecx
cmovgl %eax, %ecx
addq 0x18(%r15), %rdi
movslq %ecx, %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x2240
movl 0xc(%r15), %eax
addl %r12d, %eax
movl %eax, 0xc(%r15)
cmpl $0xff00, %eax           # imm = 0xFF00
jne 0x4443
movq %r15, %rdi
callq 0x4399
addq %r12, %r14
subq %r12, %r13
jne 0x4402
jmp 0x44b4
xorl %r13d, %r13d
testq %rbx, %rbx
jle 0x44b2
xorl %eax, %eax
movslq 0xc(%r15), %rdi
movl $0xff00, %ecx           # imm = 0xFF00
subq %rdi, %rcx
movq %rbx, %rdx
subq %rax, %rdx
cmpq %rcx, %rdx
cmovgl %ecx, %edx
addq 0x18(%r15), %rdi
movslq %edx, %r12
movq %r14, %rsi
movq %r12, %rdx
callq 0x2240
addl %r12d, %r13d
movl 0xc(%r15), %eax
addl %r12d, %eax
movl %eax, 0xc(%r15)
addq %r12, %r14
cmpl $0xff00, %eax           # imm = 0xFF00
jne 0x44a5
movq %r15, %rdi
callq 0x40e3
testl %eax, %eax
jne 0x44ad
movslq %r13d, %rax
cmpq %rbx, %rax
jl 0x4457
movslq %r13d, %rbx
jmp 0x44b4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x9de1(%rip), %rdi      # 0xe2a9
leaq 0x9d46(%rip), %rsi      # 0xe215
leaq 0x9de0(%rip), %rcx      # 0xe2b6
movl $0x23d, %edx            # imm = 0x23D
callq 0x2180
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/bgzf.c
// Function: bgzf_close
int bgzf_close(BGZF* fp)
{
	int ret, block_length;
	if (fp == 0) return -1;
	if (fp->is_write) {
		if (bgzf_flush(fp) != 0) return -1;
		fp->compress_level = -1;
		block_length = deflate_block(fp, 0); // write an empty block
		fwrite(fp->compressed_block, 1, block_length, (FILE*)fp->fp);
		if (fflush((FILE*)fp->fp) != 0) {
			fp->errcode |= BGZF_ERR_IO;
			return -1;
		}
#ifdef BGZF_MT
		if (fp->mt) mt_destroy((mtaux_t*)fp->mt);
#endif
	}
	ret = fp->is_write? fclose((FILE*)fp->fp) : _bgzf_close(fp->fp);
	if (ret != 0) return -1;
	free(fp->uncompressed_block);
	free(fp->compressed_block);
	free_cache(fp);
	free(fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x466b
movq %rdi, %rbx
testb $0x3, 0x2(%rdi)
je 0x4642
movq %rbx, %rdi
callq 0x40e3
testl %eax, %eax
jne 0x466b
orl $0xfff00000, (%rbx)     # imm = 0xFFF00000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4330
movslq %eax, %rdx
movq 0x20(%rbx), %rdi
movq 0x30(%rbx), %rcx
movl $0x1, %esi
callq 0x23b0
movq 0x30(%rbx), %rdi
callq 0x22b0
testl %eax, %eax
je 0x4550
orb $0x4, (%rbx)
jmp 0x466b
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x4642
leaq 0x38(%r14), %r15
movq %r15, %rdi
callq 0x2400
movl $0x1, 0xc(%r14)
movl $0x0, 0x10(%r14)
leaq 0x60(%r14), %rdi
movq %rdi, (%rsp)
callq 0x20d0
movq %r15, %rdi
callq 0x2290
movl (%r14), %eax
cmpl $0x2, %eax
jl 0x45b6
movl $0x1, %r12d
movq 0x30(%r14), %rax
movq (%rax,%r12,8), %rdi
xorl %esi, %esi
callq 0x23c0
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x459c
cmpl $0x0, 0x4(%r14)
jle 0x45dc
xorl %r12d, %r12d
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
callq 0x2050
incq %r12
movslq 0x4(%r14), %rax
cmpq %rax, %r12
jl 0x45c0
movl (%r14), %eax
testl %eax, %eax
jle 0x4605
movl $0x10, %r13d
xorl %r12d, %r12d
movq 0x28(%r14), %rax
movq (%rax,%r13), %rdi
callq 0x2050
incq %r12
movslq (%r14), %rax
addq $0x28, %r13
cmpq %rax, %r12
jl 0x45e9
movq 0x18(%r14), %rdi
callq 0x2050
movq 0x20(%r14), %rdi
callq 0x2050
movq 0x28(%r14), %rdi
callq 0x2050
movq 0x30(%r14), %rdi
callq 0x2050
movq (%rsp), %rdi
callq 0x2330
movq %r15, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2050
movq 0x30(%rbx), %rdi
callq 0x2140
testl %eax, %eax
jne 0x466b
movq 0x18(%rbx), %rdi
callq 0x2050
movq 0x20(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2050
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/bgzf.c
// Function: bgzf_check_EOF
int bgzf_check_EOF(BGZF *fp)
{
	uint8_t buf[28];
	off_t offset;
	offset = _bgzf_tell((_bgzf_file_t)fp->fp);
	if (_bgzf_seek(fp->fp, -28, SEEK_END) < 0) return 0;
	_bgzf_read(fp->fp, buf, 28);
	_bgzf_seek(fp->fp, offset, SEEK_SET);
	return (memcmp("\037\213\010\4\0\0\0\0\0\377\6\0\102\103\2\0\033\0\3\0\0\0\0\0\0\0\0\0", buf, 28) == 0)? 1 : 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x20b0
movq %rax, %r14
movq 0x30(%rbx), %rdi
movq $-0x1c, %rsi
movl $0x2, %edx
callq 0x2340
testl %eax, %eax
js 0x470d
movq 0x30(%rbx), %rcx
movq %rsp, %r15
movl $0x1, %esi
movl $0x1c, %edx
movq %r15, %rdi
callq 0x20e0
movq 0x30(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2340
movdqu 0xc(%r15), %xmm0
pcmpeqb 0x9ad5(%rip), %xmm0     # 0xe1c0
movdqa (%r15), %xmm1
pcmpeqb 0x9ad8(%rip), %xmm1     # 0xe1d0
pand %xmm0, %xmm1
pmovmskb %xmm1, %ecx
xorl %eax, %eax
cmpl $0xffff, %ecx           # imm = 0xFFFF
sete %al
jmp 0x470f
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/hts.c
// Function: hts_close
void hts_close(htsFile *fp)
{
	free(fp->fn);
	if (!fp->is_bin) {
		free(fp->line.s);
		if (!fp->is_write) {
			gzFile gzfp = ((kstream_t*)fp->fp)->f;
			ks_destroy((kstream_t*)fp->fp);
			gzclose(gzfp);
			free(fp->fn_aux);
		} else fclose((FILE*)fp->fp);
	} else bgzf_close((BGZF*)fp->fp);
	free(fp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x2050
testb $0x1, (%rbx)
jne 0x57e1
movq 0x20(%rbx), %rdi
callq 0x2050
testb $0x2, (%rbx)
movq 0x38(%rbx), %rdi
jne 0x57ec
movq 0x10(%rdi), %r14
callq 0x4ca5
movq %r14, %rdi
callq 0x2040
movq 0x30(%rbx), %rdi
callq 0x2050
jmp 0x57f1
movq 0x38(%rbx), %rdi
callq 0x44e0
jmp 0x57f1
callq 0x2140
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/hts.c
// Function: hts_getline
int hts_getline(htsFile *fp, int delimiter, kstring_t *str)
{
	int ret, dret;
	ret = ks_getuntil((kstream_t*)fp->fp, delimiter, str, &dret);
	++fp->lineno;
	return ret;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
leaq 0xc(%rsp), %rcx
xorl %r8d, %r8d
callq 0x4cc1
incq 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/hts.c
// Function: hts_idx_init
hts_idx_t *hts_idx_init(int n, int fmt, uint64_t offset0, int min_shift, int n_lvls)
{
	hts_idx_t *idx;
	idx = (hts_idx_t*)calloc(1, sizeof(hts_idx_t));
	idx->fmt = fmt;
	idx->min_shift = min_shift;
	idx->n_lvls = n_lvls;
	idx->n_bins = ((1<<(3 * n_lvls + 3)) - 1) / 7;
	idx->z.save_bin = idx->z.save_tid = idx->z.last_tid = idx->z.last_bin = 0xffffffffu;
	idx->z.save_off = idx->z.last_off = idx->z.off_beg = idx->z.off_end = offset0;
	idx->z.last_coor = 0xffffffffu;
	if (n) {
		idx->n = idx->m = n;
		idx->bidx = (bidx_t**)calloc(n, sizeof(void*));
		idx->lidx = (lidx_t*) calloc(n, sizeof(lidx_t));
	}
	return idx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %r12d
movq %rdx, %r14
movl %esi, %r13d
movl %edi, %ebp
movl $0x1, %edi
movl $0x88, %esi
callq 0x21f0
movq %rax, %rbx
movl %r13d, (%rax)
movl %r12d, 0x4(%rax)
movl %r15d, 0x8(%rax)
leal (%r15,%r15,2), %ecx
addb $0x3, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
movl $0x92492493, %ecx       # imm = 0x92492493
imulq %rax, %rcx
shrq $0x22, %rcx
movl %ecx, 0xc(%rbx)
movl $0xffffffff, 0x50(%rbx) # imm = 0xFFFFFFFF
movq %r14, 0x70(%rbx)
movq %r14, 0x68(%rbx)
movq %r14, 0x58(%rbx)
movq %r14, 0x60(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x40(%rbx)
testl %ebp, %ebp
je 0x5fc5
movl %ebp, 0x18(%rbx)
movl %ebp, 0x14(%rbx)
movslq %ebp, %r14
movl $0x8, %esi
movq %r14, %rdi
callq 0x21f0
movq %rax, 0x28(%rbx)
movl $0x10, %esi
movq %r14, %rdi
callq 0x21f0
movq %rax, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/hts.c
// Function: hts_idx_destroy
void hts_idx_destroy(hts_idx_t *idx)
{
	khint_t k;
	int i;
	if (idx == 0) return;
	for (i = 0; i < idx->m; ++i) {
		bidx_t *bidx = idx->bidx[i];
		free(idx->lidx[i].offset);
		if (bidx == 0) continue;
		for (k = kh_begin(bidx); k != kh_end(bidx); ++k)
			if (kh_exist(bidx, k))
				free(kh_value(bidx, k).list);
		kh_destroy(bin, bidx);
	}
	free(idx->bidx); free(idx->lidx); free(idx->meta);
	free(idx);
}

// Assembly:
testq %rdi, %rdi
je 0x6f94
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jle 0x6f69
xorl %r15d, %r15d
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq (%rax,%r15,8), %r14
movq %r15, %rax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rdi
callq 0x2050
testq %r14, %r14
je 0x6f59
movl (%r14), %eax
testl %eax, %eax
je 0x6f36
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x10(%r14), %rcx
movl %r12d, %edx
shrl $0x4, %edx
movl (%rcx,%rdx,4), %edx
movl %ebp, %ecx
andb $0x1e, %cl
shrl %cl, %edx
testb $0x3, %dl
jne 0x6f2b
movq 0x20(%r14), %rax
movl %r12d, %ecx
leaq (%rcx,%rcx,2), %rcx
movq 0x10(%rax,%rcx,8), %rdi
callq 0x2050
movl (%r14), %eax
incl %r12d
addl $0x2, %ebp
cmpl %eax, %r12d
jne 0x6efa
movq 0x18(%r14), %rdi
callq 0x2050
movq 0x10(%r14), %rdi
callq 0x2050
movq 0x20(%r14), %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
incq %r15
movslq 0x18(%rbx), %rax
cmpq %rax, %r15
jl 0x6ecc
movq 0x28(%rbx), %rdi
callq 0x2050
movq 0x30(%rbx), %rdi
callq 0x2050
movq 0x38(%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2050
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/hts.c
// Function: hts_idx_save
void hts_idx_save(const hts_idx_t *idx, const char *fn, int fmt)
{
	char *fnidx;
	fnidx = (char*)calloc(1, strlen(fn) + 5);
	strcpy(fnidx, fn);
	if (fmt == HTS_FMT_CSI) {
		BGZF *fp;
		uint32_t x[3];
		int is_be, i;
		is_be = ed_is_big();
		fp = bgzf_open(strcat(fnidx, ".csi"), "w");
		bgzf_write(fp, "CSI\1", 4);
		x[0] = idx->min_shift; x[1] = idx->n_lvls; x[2] = idx->l_meta;
		if (is_be) {
			for (i = 0; i < 3; ++i)
				bgzf_write(fp, ed_swap_4p(&x[i]), 4);
		} else bgzf_write(fp, &x, 12);
		if (idx->l_meta) bgzf_write(fp, idx->meta, idx->l_meta);
		hts_idx_save_core(idx, fp, HTS_FMT_CSI);
		bgzf_close(fp);
	} else if (fmt == HTS_FMT_TBI) {
		BGZF *fp;
		fp = bgzf_open(strcat(fnidx, ".tbi"), "w");
		bgzf_write(fp, "TBI\1", 4);
		hts_idx_save_core(idx, fp, HTS_FMT_TBI);
		bgzf_close(fp);
	} else if (fmt == HTS_FMT_BAI) {
		FILE *fp;
		fp = fopen(strcat(fnidx, ".bai"), "w");
		fwrite("BAI\1", 1, 4, fp);
		hts_idx_save_core(idx, fp, HTS_FMT_BAI);
		fclose(fp);
	} else abort();
	free(fnidx);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x2150
leaq 0x5(%rax), %rsi
movl $0x1, %edi
callq 0x21f0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x20a0
cmpl $0x2, %ebp
je 0x70ba
cmpl $0x1, %ebp
je 0x7061
testl %ebp, %ebp
jne 0x711f
movq %rbx, %rdi
callq 0x2150
movl $0x6973632e, (%rbx,%rax) # imm = 0x6973632E
movb $0x0, 0x4(%rbx,%rax)
leaq 0x7127(%rip), %rsi      # 0xe127
movq %rbx, %rdi
callq 0x3ad0
movq %rax, %r15
leaq 0x73f6(%rip), %rsi      # 0xe408
movl $0x4, %edx
movq %rax, %rdi
callq 0x43d3
movq 0x4(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl 0x10(%r14), %eax
movl %eax, 0x8(%rsi)
movl $0xc, %edx
movq %r15, %rdi
callq 0x43d3
movl 0x10(%r14), %edx
testq %rdx, %rdx
je 0x7054
movq 0x38(%r14), %rsi
movq %r15, %rdi
callq 0x43d3
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
jmp 0x70ff
movq %rbx, %rdi
callq 0x2150
movl $0x6961622e, (%rbx,%rax) # imm = 0x6961622E
movb $0x0, 0x4(%rbx,%rax)
leaq 0x70ab(%rip), %rsi      # 0xe127
movq %rbx, %rdi
callq 0x2350
movq %rax, %r15
leaq 0x738e(%rip), %rdi      # 0xe41c
movl $0x1, %esi
movl $0x4, %edx
movq %rax, %rcx
callq 0x23b0
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x7124
movq %r15, %rdi
callq 0x2140
jmp 0x710c
movq %rbx, %rdi
callq 0x2150
movl $0x6962742e, (%rbx,%rax) # imm = 0x6962742E
movb $0x0, 0x4(%rbx,%rax)
leaq 0x7052(%rip), %rsi      # 0xe127
movq %rbx, %rdi
callq 0x3ad0
movq %rax, %r15
leaq 0x732b(%rip), %rsi      # 0xe412
movl $0x4, %edx
movq %rax, %rdi
callq 0x43d3
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0x7124
movq %r15, %rdi
callq 0x44e0
movq %rbx, %rdi
callq 0x2050
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2060
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/hts.c
// Function: hts_idx_set_meta
void hts_idx_set_meta(hts_idx_t *idx, int l_meta, uint8_t *meta, int is_copy)
{
	if (idx->meta) free(idx->meta);
	idx->l_meta = l_meta;
	if (is_copy) {
		idx->meta = (uint8_t*)malloc(l_meta);
		memcpy(idx->meta, meta, l_meta);
	} else idx->meta = meta;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x78ed
callq 0x2050
movl %ebp, 0x10(%r14)
testl %r15d, %r15d
je 0x791d
movslq %ebp, %r15
movq %r15, %rdi
callq 0x22a0
movq %rax, 0x38(%r14)
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2240
movq %rbx, 0x38(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/hts.c
// Function: hts_itr_querys
hts_itr_t *hts_itr_querys(const hts_idx_t *idx, const char *reg, hts_name2id_f getid, void *hdr)
{
	int tid, beg, end;
	char *q, *tmp;
	if (strcmp(reg, "*")) {
		q = (char*)hts_parse_reg(reg, &beg, &end);
		tmp = (char*)alloca(q - reg + 1);
		strncpy(tmp, reg, q - reg);
		tmp[q - reg] = 0;
		if ((tid = getid(hdr, tmp)) < 0)
			tid = getid(hdr, reg);
		if (tid < 0) return 0;
		return hts_itr_query(idx, tid, beg, end);
	} else return hts_itr_query(idx, HTS_IDX_NOCOOR, 0, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
cmpb $0x2a, (%rsi)
jne 0x8349
cmpb $0x0, 0x1(%r12)
je 0x83c2
movq %rdi, -0x38(%rbp)
leaq -0x30(%rbp), %rsi
leaq -0x2c(%rbp), %rdx
movq %r12, %rdi
callq 0x8117
movq %rax, %r13
subq %r12, %r13
leaq 0x10(%r13), %rax
andq $-0x10, %rax
movq %rsp, %rbx
subq %rax, %rbx
movq %rbx, %rsp
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x2080
movb $0x0, (%r13,%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq *%r14
testl %eax, %eax
jns 0x83a2
movq %r15, %rdi
movq %r12, %rsi
callq *%r14
testl %eax, %eax
js 0x83de
movl -0x30(%rbp), %edx
movl -0x2c(%rbp), %ecx
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x7936
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
xorl %edx, %edx
xorl %ecx, %ecx
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7936
xorl %eax, %eax
jmp 0x83b3
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/hts.c
// Function: hts_idx_getfn
char *hts_idx_getfn(const char *fn, const char *ext)
{
	int i, l_fn, l_ext;
	char *fnidx, *ret;
	l_fn = strlen(fn); l_ext = strlen(ext);
	fnidx = (char*)calloc(l_fn + l_ext + 1, 1);
	strcpy(fnidx, fn); strcpy(fnidx + l_fn, ext);
	if ((ret = test_and_fetch(fnidx)) == 0) {
		for (i = l_fn - 1; i >= 0; --i)
			if (fnidx[i] == '.') break;
		strcpy(fnidx + i, ext);
		ret = test_and_fetch(fnidx);
	}
	if (ret == 0) {
		free(fnidx);
		return 0;
	}
	l_fn = strlen(ret);
	memmove(fnidx, ret, l_fn + 1);
	return fnidx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
callq 0x2150
movq %rax, %r15
movq %r14, %rdi
callq 0x2150
addl %r15d, %eax
incl %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x21f0
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
callq 0x20a0
movslq %r15d, %rdi
addq %rbx, %rdi
movq %r14, %rsi
callq 0x20a0
movq %rbx, %rdi
callq 0x8643
testq %rax, %rax
jne 0x85f4
movl %r15d, %eax
movl %r15d, %ecx
sarl $0x1f, %ecx
andl %r15d, %ecx
decl %ecx
decq %rax
testl %r15d, %r15d
jle 0x85d3
movl %eax, %edx
decl %r15d
decq %rax
cmpb $0x2e, (%rbx,%rdx)
jne 0x85be
jmp 0x85d6
movl %ecx, %r15d
movslq %r15d, %rax
movq %rbx, %rdi
addq %rax, %rdi
movq %r14, %rsi
callq 0x20a0
movq %rbx, %rdi
callq 0x8643
testq %rax, %rax
je 0x862d
movq %rax, %r12
movabsq $0x100000000, %r14      # imm = 0x100000000
movq %rax, %rdi
callq 0x2150
shlq $0x20, %rax
addq %rax, %r14
sarq $0x20, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2310
movq %rbx, %rdi
callq 0x2050
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/DReichLab[P]adna/hts.c
// Function: hts_idx_load
hts_idx_t *hts_idx_load(const char *fn, int fmt)
{
	char *fnidx;
	hts_idx_t *idx;
	fnidx = hts_idx_getfn(fn, ".csi");
	if (fnidx) fmt = HTS_FMT_CSI;
	else fnidx = hts_idx_getfn(fn, fmt == HTS_FMT_BAI? ".bai" : ".tbi");
	if (fnidx == 0) return 0;
	idx = hts_idx_load_direct(fnidx, fmt);
	free(fnidx);
	return idx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
leaq 0x5d29(%rip), %rsi      # 0xe403
callq 0x8554
testq %rax, %rax
je 0x86eb
movq %rax, %r14
xorl %ebx, %ebx
jmp 0x8710
cmpl $0x1, %ebx
leaq 0x5d22(%rip), %rax      # 0xe417
leaq 0x5d11(%rip), %rsi      # 0xe40d
cmoveq %rax, %rsi
movq %r15, %rdi
callq 0x8554
movq %rax, %r14
testq %rax, %rax
je 0x872e
movq %r14, %rdi
movl %ebx, %esi
callq 0x73f7
movq %rax, %rbx
movq %r14, %rdi
callq 0x2050
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
jmp 0x8728