LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/vi[P]simple_cbor_stream_parse/scsp_cpp.cpp
// Function: scsp::parse_from_istream(std::istream&, scsp::Callbacks&)
bool SCSP_EXPORT parse_from_istream(
            std::istream& is,
            class Callbacks& callbacks)
{
    struct scsp_state     ss;
    ss.cur_depth = 0;
    uint8_t buf[8192];
    
    size_t read_cursor = 0;
    for(;;) {
        if (is.eof()) {
            if (read_cursor == 0) {
                return true;
            } else {
                return false;
            }
        }
        if (is.fail()) {
            return false;
        }
        is.read((char*)(buf+read_cursor), (sizeof buf) - read_cursor);
        size_t len = is.gcount();
       
        if (len == 0) {
            continue;
        }
        
        len += read_cursor;
        read_cursor=0;
        
        size_t write_cursor = 0;
        while(write_cursor < len) {
            int ret2 = scsp_parse_lowlevel(&ss, &tocpp_callbacks, (void*)&callbacks, buf+write_cursor, len-write_cursor);
            if (ret2 == -1) {
                return false;
            }
            if (ret2 == 0) {
                memmove(buf, buf+write_cursor, len-write_cursor);
                read_cursor = len-write_cursor;
                break;
            }
            write_cursor += ret2;
        }
        //fflush(stdout);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2140, %rsp           # imm = 0x2140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x120(%rbp)
movq $0x0, -0x2128(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2130
testb $0x1, %al
jne 0x24df
jmp 0x24fb
cmpq $0x0, -0x2128(%rbp)
jne 0x24f2
movb $0x1, -0x1(%rbp)
jmp 0x264a
movb $0x0, -0x1(%rbp)
jmp 0x264a
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x2030
testb $0x1, %al
jne 0x2511
jmp 0x251a
movb $0x0, -0x1(%rbp)
jmp 0x264a
movq -0x10(%rbp), %rdi
leaq -0x2120(%rbp), %rsi
addq -0x2128(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
subq -0x2128(%rbp), %rdx
callq 0x20c0
movq -0x10(%rbp), %rdi
callq 0x2140
movq %rax, -0x2130(%rbp)
cmpq $0x0, -0x2130(%rbp)
jne 0x255c
jmp 0x24c9
movq -0x2128(%rbp), %rax
addq -0x2130(%rbp), %rax
movq %rax, -0x2130(%rbp)
movq $0x0, -0x2128(%rbp)
movq $0x0, -0x2138(%rbp)
movq -0x2138(%rbp), %rax
cmpq -0x2130(%rbp), %rax
jae 0x2645
movq -0x18(%rbp), %rdx
leaq -0x2120(%rbp), %rcx
addq -0x2138(%rbp), %rcx
movq -0x2130(%rbp), %r8
subq -0x2138(%rbp), %r8
leaq -0x120(%rbp), %rdi
leaq 0x4aef(%rip), %rsi      # 0x70b8
callq 0x2fd0
movl %eax, -0x213c(%rbp)
cmpl $-0x1, -0x213c(%rbp)
jne 0x25e3
movb $0x0, -0x1(%rbp)
jmp 0x264a
cmpl $0x0, -0x213c(%rbp)
jne 0x262b
leaq -0x2120(%rbp), %rdi
leaq -0x2120(%rbp), %rsi
addq -0x2138(%rbp), %rsi
movq -0x2130(%rbp), %rdx
subq -0x2138(%rbp), %rdx
callq 0x2120
movq -0x2130(%rbp), %rax
subq -0x2138(%rbp), %rax
movq %rax, -0x2128(%rbp)
jmp 0x2645
movslq -0x213c(%rbp), %rax
addq -0x2138(%rbp), %rax
movq %rax, -0x2138(%rbp)
jmp 0x2587
jmp 0x24c9
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x2140, %rsp           # imm = 0x2140
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/vi[P]simple_cbor_stream_parse/scsp_cpp.cpp
// Function: scsp::Generator::integer(long)
void Generator::integer(SCSP_INT value) {
    if (value >= 0) {
        writething(0x00, value);
    } else {
        writething(0x20, (-value) - 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x28b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x2660
jmp 0x28ca
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
subq -0x10(%rbp), %rdx
subq $0x1, %rdx
movl $0x20, %esi
callq 0x2660
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vi[P]simple_cbor_stream_parse/scsp_cpp.cpp
// Function: scsp::Generator::simple(char)
void Generator::simple (char value){ 
    switch (value) {
        case 'F' : o.write("\xF4", 1); break;
        case 'T' : o.write("\xF5", 1); break;
        case 'N' : o.write("\xF6", 1); break;
        case 'U' : o.write("\xF7", 1); break;
        default:   o.write("\xF7", 1); break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movsbl -0x9(%rbp), %eax
addl $-0x46, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xf, %eax
ja 0x2bd0
movq -0x18(%rbp), %rax
leaq 0x24c1(%rip), %rcx      # 0x501c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x2505(%rip), %rsi      # 0x5078
movl $0x1, %edx
callq 0x20d0
jmp 0x2be9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x24ec(%rip), %rsi      # 0x507a
movl $0x1, %edx
callq 0x20d0
jmp 0x2be9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x24d3(%rip), %rsi      # 0x507c
movl $0x1, %edx
callq 0x20d0
jmp 0x2be9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x24ba(%rip), %rsi      # 0x507e
movl $0x1, %edx
callq 0x20d0
jmp 0x2be9
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x249f(%rip), %rsi      # 0x507e
movl $0x1, %edx
callq 0x20d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/vi[P]simple_cbor_stream_parse/scsp_cpp.cpp
// Function: scsp::Generator::noninteger(double)
void Generator::noninteger (double value){
    uint64_t v = *reinterpret_cast<const uint64_t*>(&value);
    o.write("\xFB", 1);
    int i;
    for (i=0; i<8; ++i) {
        uint8_t q = (v&0xFF00000000000000ULL) >> 56;
        v<<=8;
        o.write((char*)&q, 1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rdi
leaq 0x2404(%rip), %rsi      # 0x5080
movl $0x1, %edx
callq 0x20d0
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x2cd5
movq -0x28(%rbp), %rax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq -0x18(%rbp), %rcx
shrq $0x38, %rcx
movb %cl, -0x1d(%rbp)
movq -0x18(%rbp), %rcx
shlq $0x8, %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rdi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x20d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c8d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hifi[P]whatever/whatever.c
// Function: die
static void die(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "[whatever] ");
    vfprintf(stderr, fmt, ap);
    exit(1);
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x401d9c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0xd0(%rsp)
leaq 0xb0(%rsp), %rax
movq %rsp, %rcx
movq %rcx, 0x10(%rax)
leaq 0xe0(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq $0x4c96e8, %rax         # imm = 0x4C96E8
movq (%rax), %rdi
leaq 0x974fa(%rip), %rsi     # 0x4992f0
movb $0x0, %al
callq 0x40bd30
movq $0x4c96e8, %rax         # imm = 0x4C96E8
movq (%rax), %rdi
movq 0xd0(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x40bd20
movl $0x1, %edi
callq 0x40b1f0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/sigstop.c
// Function: main
int main() {
  libforks_ServerConn conn;

  check(libforks_start(&conn) == libforks_OK);

  pid_t child_pid;
  int socket_fd;

  libforks_Result r = libforks_fork(
    conn,
    &child_pid, // pid_ptr
    &socket_fd, // socket_fd_ptr
    NULL, // exit_fd_ptr
    child_main
  );
  check(r == libforks_OK);

  check(kill(child_pid, SIGSTOP) == 0);
  check(kill(child_pid, SIGCONT) == 0);

  check(write(socket_fd, "a", 1) == 1);
  char c;
  check(read(socket_fd, &c, 1) == 1);
  check(c == 'b');

  check(libforks_stop(conn) == libforks_OK);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1b90
cmpl $0x0, %eax
jne 0x132f
jmp 0x1347
leaq 0x2cce(%rip), %rdi      # 0x4004
leaq 0x2cec(%rip), %rsi      # 0x4029
movl $0x12, %edx
callq 0x14a0
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq 0x182(%rip), %r8        # 0x14e0
callq 0x2360
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x136e
jmp 0x1386
leaq 0x2cc4(%rip), %rdi      # 0x4039
leaq 0x2cad(%rip), %rsi      # 0x4029
movl $0x1e, %edx
callq 0x14a0
movl -0x14(%rbp), %edi
movl $0x13, %esi
callq 0x1160
cmpl $0x0, %eax
jne 0x139a
jmp 0x13b2
leaq 0x2ca9(%rip), %rdi      # 0x404a
leaq 0x2c81(%rip), %rsi      # 0x4029
movl $0x20, %edx
callq 0x14a0
movl -0x14(%rbp), %edi
movl $0x12, %esi
callq 0x1160
cmpl $0x0, %eax
jne 0x13c6
jmp 0x13de
leaq 0x2c9b(%rip), %rdi      # 0x4068
leaq 0x2c55(%rip), %rsi      # 0x4029
movl $0x21, %edx
callq 0x14a0
movl -0x18(%rbp), %edi
leaq 0x2c9e(%rip), %rsi      # 0x4086
movl $0x1, %edx
callq 0x1080
cmpq $0x1, %rax
jne 0x13fa
jmp 0x1412
leaq 0x2c87(%rip), %rdi      # 0x4088
leaq 0x2c21(%rip), %rsi      # 0x4029
movl $0x23, %edx
callq 0x14a0
movl -0x18(%rbp), %edi
leaq -0x1d(%rbp), %rsi
movl $0x1, %edx
callq 0x1100
cmpq $0x1, %rax
jne 0x142b
jmp 0x1443
leaq 0x2c74(%rip), %rdi      # 0x40a6
leaq 0x2bf0(%rip), %rsi      # 0x4029
movl $0x25, %edx
callq 0x14a0
movsbl -0x1d(%rbp), %eax
cmpl $0x62, %eax
jne 0x144e
jmp 0x1466
leaq 0x2c6d(%rip), %rdi      # 0x40c2
leaq 0x2bcd(%rip), %rsi      # 0x4029
movl $0x26, %edx
callq 0x14a0
movq -0x10(%rbp), %rdi
callq 0x25f0
cmpl $0x0, %eax
jne 0x1476
jmp 0x148e
leaq 0x2c4e(%rip), %rdi      # 0x40cb
leaq 0x2ba5(%rip), %rsi      # 0x4029
movl $0x28, %edx
callq 0x14a0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/sigstop.c
// Function: child_main
static void child_main(libforks_ServerConn conn, int socket_fd) {
  (void)conn;

  char c;
  check(read(socket_fd, &c, 1) == 1);
  check(c == 'a');
  check(write(socket_fd, "b", 1) == 1);

  sleep(999);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq -0xd(%rbp), %rsi
movl $0x1, %edx
callq 0x1100
cmpq $0x1, %rax
jne 0x1508
jmp 0x1520
leaq 0x2b97(%rip), %rdi      # 0x40a6
leaq 0x2b13(%rip), %rsi      # 0x4029
movl $0x8, %edx
callq 0x14a0
movsbl -0xd(%rbp), %eax
cmpl $0x61, %eax
jne 0x152b
jmp 0x1543
leaq 0x2bd8(%rip), %rdi      # 0x410a
leaq 0x2af0(%rip), %rsi      # 0x4029
movl $0x9, %edx
callq 0x14a0
movl -0xc(%rbp), %edi
leaq 0x2bc6(%rip), %rsi      # 0x4113
movl $0x1, %edx
callq 0x1080
cmpq $0x1, %rax
jne 0x155f
jmp 0x1577
leaq 0x2baf(%rip), %rdi      # 0x4115
leaq 0x2abc(%rip), %rsi      # 0x4029
movl $0xa, %edx
callq 0x14a0
movl $0x3e7, %edi            # imm = 0x3E7
callq 0x11f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_nibbles.c
// Function: fmttime
char *fmttime(long long elapsed) {
    static char buf[64];

#ifdef HAVE_CLOCK_GETTIME_CPUTIME
    long long sec = elapsed / 1000000000;
    long long nsec = elapsed % 1000000000;
    sprintf(buf, "%lld.%09lld processor seconds", sec, nsec);
#else
    long long sec = elapsed / 1000000;
    long long usec = elapsed % 1000000;
    sprintf(buf, "%lld.%06lld wall-time seconds", sec, usec);
#endif

    return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
cqto
idivq %rcx
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x1031a1(%rip), %rdi    # 0x108cd0
leaq 0xe051e(%rip), %rsi     # 0xe6054
movb $0x0, %al
callq 0x40b0
leaq 0x10318c(%rip), %rax    # 0x108cd0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_nibbles.c
// Function: validate_nibble2base
int validate_nibble2base(void) {
    char defbuf[500];
    int i, start, len;
    unsigned long long total = 0, failed = 0;

    for (i = 0; i < sizeof nibble; i++)
        nibble[i] = i % 256;

    for (start = 0; start < 80; start++)
        for (len = 0; len < 400; len++) {
            memset(defbuf, '\0', sizeof defbuf);
            nibble2base_single(&nibble[start], defbuf, len);

            memset(buf, '\0', sizeof defbuf);
            nibble2base(&nibble[start], buf, len);

            total++;
            if (strcmp(defbuf, buf) != 0) {
                printf("%s expected\n%s FAIL\n\n", defbuf, buf);
                failed++;
            }
        }

    if (failed > 0) {
        fprintf(stderr, "Failures: %llu (out of %llu tests)\n", failed, total);
        return 1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq $0x0, -0x218(%rbp)
movq $0x0, -0x220(%rbp)
movl $0x0, -0x204(%rbp)
movslq -0x204(%rbp), %rax
cmpq $0x1388, %rax           # imm = 0x1388
jae 0x5c2a
movl -0x204(%rbp), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movslq -0x204(%rbp), %rcx
leaq 0x1030fa(%rip), %rax    # 0x108d10
movb %dl, (%rax,%rcx)
movl -0x204(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x204(%rbp)
jmp 0x5beb
movl $0x0, -0x208(%rbp)
cmpl $0x50, -0x208(%rbp)
jge 0x5d4b
movl $0x0, -0x20c(%rbp)
cmpl $0x190, -0x20c(%rbp)    # imm = 0x190
jge 0x5d35
leaq -0x200(%rbp), %rdi
xorl %esi, %esi
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x4270
movslq -0x208(%rbp), %rax
leaq 0x103094(%rip), %rdi    # 0x108d10
addq %rax, %rdi
leaq -0x200(%rbp), %rsi
movl -0x20c(%rbp), %edx
callq 0x5b50
leaq 0x104408(%rip), %rdi    # 0x10a0a0
xorl %esi, %esi
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x4270
movslq -0x208(%rbp), %rax
leaq 0x10305e(%rip), %rdi    # 0x108d10
addq %rax, %rdi
movl -0x20c(%rbp), %edx
leaq 0x1043de(%rip), %rsi    # 0x10a0a0
callq 0x5da0
movq -0x218(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x218(%rbp)
leaq -0x200(%rbp), %rdi
leaq 0x1043b9(%rip), %rsi    # 0x10a0a0
callq 0x46b0
cmpl $0x0, %eax
je 0x5d1f
leaq -0x200(%rbp), %rsi
leaq 0xe0373(%rip), %rdi     # 0xe6072
leaq 0x10439a(%rip), %rdx    # 0x10a0a0
movb $0x0, %al
callq 0x4060
movq -0x220(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x220(%rbp)
jmp 0x5d21
movl -0x20c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20c(%rbp)
jmp 0x5c4b
jmp 0x5d37
movl -0x208(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x208(%rbp)
jmp 0x5c34
cmpq $0x0, -0x220(%rbp)
jbe 0x5d84
movq 0xfe284(%rip), %rax     # 0x103fe0
movq (%rax), %rdi
movq -0x220(%rbp), %rdx
movq -0x218(%rbp), %rcx
leaq 0xe0314(%rip), %rsi     # 0xe6088
movb $0x0, %al
callq 0x46f0
movl $0x1, -0x4(%rbp)
jmp 0x5d8b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_nibbles.c
// Function: time_nibble2base
int time_nibble2base(int length, unsigned long count) {
    unsigned long i, total = 0;

    for (i = 0; i < length; i++)
        nibble[i] = i % 256;

    printf("Timing %lu nibble2base iterations with read length %d...\n", count, length);
    long long start = gettime();

    for (i = 0; i < count; i++) {
        nibble2base(nibble, buf, length);
        total += buf[i % length];
    }

    long long stop = gettime();
    printf("%s (summing to %lu)\n", fmttime(stop - start), total);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
cmpq %rcx, %rax
jae 0x5e24
movq -0x18(%rbp), %rax
andq $0xff, %rax
movb %al, %dl
movq -0x18(%rbp), %rcx
leaq 0x102efd(%rip), %rax    # 0x108d10
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5def
movq -0x10(%rbp), %rsi
movl -0x4(%rbp), %edx
leaq 0xe027a(%rip), %rdi     # 0xe60ac
movb $0x0, %al
callq 0x4060
callq 0x5ac0
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x5e99
movl -0x4(%rbp), %edx
leaq 0x102eb2(%rip), %rdi    # 0x108d10
leaq 0x10423b(%rip), %rsi    # 0x10a0a0
callq 0x5da0
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
xorl %edx, %edx
divq %rcx
leaq 0x104222(%rip), %rax    # 0x10a0a0
movsbq (%rax,%rdx), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5e4a
callq 0x5ac0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
subq -0x28(%rbp), %rdi
callq 0x5af0
movq %rax, %rsi
movq -0x20(%rbp), %rdx
leaq 0xe0229(%rip), %rdi     # 0xe60e6
movb $0x0, %al
callq 0x4060
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_nibbles.c
// Function: main
int main(int argc, char **argv) {
    int readlen = 5000;
    unsigned long count = 1000000;
    int status = 0;
    int c;

    if (argc == 1)
        printf(
"Usage: test_nibbles [-c NUM] [-r NUM] [-n|-v]...\n"
"Options:\n"
"  -c NUM  Specify number of iterations [%lu]\n"
"  -n      Run nibble2base speed tests\n"
"  -r NUM  Specify read length [%d]\n"
"  -v      Run all validation tests\n"
"", count, readlen);

    while ((c = getopt(argc, argv, "c:nr:v")) >= 0)
        switch (c) {
        case 'c':
            count = strtoul(optarg, NULL, 0);
            break;

        case 'n':
            status += time_nibble2base(readlen, count);
            break;

        case 'r':
            readlen = atoi(optarg);
            break;

        case 'v':
            status += validate_nibble2base();
            break;
        }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1388, -0x14(%rbp)    # imm = 0x1388
movq $0xf4240, -0x20(%rbp)   # imm = 0xF4240
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x5f17
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0xe01eb(%rip), %rdi     # 0xe60fb
movb $0x0, %al
callq 0x4060
jmp 0x5f19
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xe02a8(%rip), %rdx     # 0xe61cf
callq 0x40e0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jl 0x5fac
movl -0x28(%rbp), %eax
addl $-0x63, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x13, %eax
ja 0x5fa7
movq -0x30(%rbp), %rax
leaq 0xe00b4(%rip), %rcx     # 0xe6004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xfe068(%rip), %rax     # 0x103fc8
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x4130
movq %rax, -0x20(%rbp)
jmp 0x5fa7
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x5dd0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x5fa7
movq 0xfe039(%rip), %rax     # 0x103fc8
movq (%rax), %rdi
callq 0x47e0
movl %eax, -0x14(%rbp)
jmp 0x5fa7
callq 0x5bc0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x5f19
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_xmlenc.c
// Function: main
int
main(void)
{
	if (pledge("stdio", NULL) == -1)
		err(1, "pledge");

	parser.xmlattr = xmlattr;
	parser.xmltagstart = xmltagstart;

	/* NOTE: getnext is defined in xml.h for inline optimization */
	xml_parse(&parser);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x2a(%rip), %rax        # 0x1220
movq %rax, 0x3e8b(%rip)      # 0x5088
leaq 0xdc(%rip), %rax        # 0x12e0
movq %rax, 0x3ef5(%rip)      # 0x5100
leaq 0x3e76(%rip), %rdi      # 0x5088
callq 0x1520
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_xmlenc.c
// Function: xmlattr
static void
xmlattr(XMLParser *p, const char *t, size_t tl, const char *n,
	size_t nl, const char *v, size_t vl)
{
	if (strcasecmp(t, "?xml") || strcasecmp(n, "encoding"))
		return;

	/* output lowercase, no control characters */
	for (; *v; v++) {
		if (!iscntrl((unsigned char)*v))
			putchar(tolower((unsigned char)*v));
	}
	putchar('\n');
	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1db5(%rip), %rsi      # 0x3004
callq 0x1040
cmpl $0x0, %eax
jne 0x126e
movq -0x20(%rbp), %rdi
leaq 0x1da5(%rip), %rsi      # 0x3009
callq 0x1040
cmpl $0x0, %eax
je 0x1274
addq $0x30, %rsp
popq %rbp
retq
jmp 0x1276
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0x12c0
callq 0x10d0
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x12b0
movq -0x30(%rbp), %rax
movzbl (%rax), %edi
callq 0x10a0
movl %eax, %edi
callq 0x1030
jmp 0x12b2
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1276
movl $0xa, %edi
callq 0x1030
xorl %edi, %edi
callq 0x10c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/diff.c
// Function: fm_diff
uint64_t *fm_diff(const rld_t *eqry, const rld_t *eref, int min_k, int max_k, int min_occ, int n_threads)
{
	shared_t d;
	assert(min_k > SUF_LEN && min_k < max_k);
	d.sub = calloc((eqry->mcnt[1] + 63) / 64, 8);
	d.min_k = min_k, d.max_k = max_k, d.min_occ = min_occ, d.eref = eref, d.eqry = eqry;
	kt_for(n_threads, worker, &d, 1<<SUF_LEN*2);
	return d.sub;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
cmpl $0x5, -0x14(%rbp)
jle 0x4d9e
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x4d9e
jmp 0x4dbd
leaq 0x273b3(%rip), %rdi     # 0x2c158
leaq 0x273cd(%rip), %rsi     # 0x2c179
movl $0x83, %edx
leaq 0x273c8(%rip), %rcx     # 0x2c180
callq 0x2140
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
addq $0x3f, %rdi
shrq $0x6, %rdi
movl $0x8, %esi
callq 0x21a0
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x20(%rbp), %edi
leaq 0x25(%rip), %rsi        # 0x4e30
leaq -0x48(%rbp), %rdx
movl $0x400, %ecx            # imm = 0x400
callq 0x2490
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/diff.c
// Function: descend
static rldintv_t descend(const rld_t *e, int suf_len, int suf)
{
	int i;
	rldintv_t ok[6], ik;
	ik.x[0] = ik.x[1] = 0; ik.x[2] = e->mcnt[0];
	for (i = 0; i < suf_len; ++i) {
		rld_extend(e, &ik, ok, 1);
		ik = ok[(suf>>i*2&3) + 1];
	}
	return ik;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq $0x0, 0x8(%rdi)
movq $0x0, (%rdi)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rdi)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x5ab2
movq -0xf0(%rbp), %rsi
movq -0x8(%rbp), %rdi
leaq -0xe0(%rbp), %rdx
movl $0x1, %ecx
callq 0x49a0
movq -0xf0(%rbp), %rax
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
shll %ecx
sarl %cl, %edx
movl %edx, %ecx
andl $0x3, %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
leaq -0xe0(%rbp), %rcx
shlq $0x5, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5a3b
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/sub.c
// Function: fm_sub
rld_t *fm_sub(rld_t *e, const uint64_t *sub, int n_threads, int is_comp, int is_both)
{
	shared_t d;
	rld_t *r;
	d.bits = calloc((e->mcnt[0] + 63) / 64, 8);
	d.sub = sub, d.e = e, d.n_threads = n_threads, d.is_both = is_both, d.n_ss = 0;
	kt_for(n_threads, worker, &d, n_threads);
	r = gen_idx(e, d.bits, is_comp);
	free(d.bits);
	if (is_both) fprintf(stderr, "[M::%s] # single-stranded: %ld\n", __func__, (long)d.n_ss);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
addq $0x3f, %rdi
shrq $0x6, %rdi
movl $0x8, %esi
callq 0x21a0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq $0x0, -0x30(%rbp)
movl -0x14(%rbp), %edi
movslq -0x14(%rbp), %rcx
leaq 0x63(%rip), %rsi        # 0x5f20
leaq -0x48(%rbp), %rdx
callq 0x2490
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x5f80
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2040
cmpl $0x0, -0x1c(%rbp)
je 0x5f0c
movq 0x2d108(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rcx
leaq 0x2638e(%rip), %rsi     # 0x2c28c
leaq 0x263a7(%rip), %rdx     # 0x2c2ac
movb $0x0, %al
callq 0x21d0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/sub.c
// Function: gen_idx
static rld_t *gen_idx(rld_t *e0, uint64_t *bits, int is_comp)
{
	int c = 0, c0 = -1;
	int64_t l, i, k = 0, len = 0;
	rld_t *e;
	rlditr_t ritr, witr;

	e = rld_init(e0->asize, e0->sbits);
	rld_itr_init(e, &witr, 0);
	rld_itr_init(e0, &ritr, 0);
	while ((l = rld_dec(e0, &ritr, &c, 1)) >= 0) {
		for (i = 0; i < l; ++i, ++k) {
			if ((bits[k>>6]>>(k&0x3f)&1) == !is_comp) {
				if (c != c0) {
					if (len) rld_enc(e, &witr, len, c0);
					c0 = c, len = 1;
				} else ++len;
			}
		}
	}
	if (len) rld_enc(e, &witr, len, c0);
	assert(k == e0->mcnt[0]);
	rld_destroy(e0);
	rld_enc_finish(e, &witr);
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %edi
movq -0x8(%rbp), %rax
movsbl 0x3(%rax), %esi
callq 0x2760
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x29f0
movq -0x8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x29f0
movq -0x8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
leaq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x6540
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jl 0x60cd
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x60c8
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
sarq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
andq $0x3f, %rcx
shrq %cl, %rax
andq $0x1, %rax
cmpl $0x0, -0x14(%rbp)
setne %cl
xorb $-0x1, %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0x60a9
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x609b
cmpq $0x0, -0x40(%rbp)
je 0x608b
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movl -0x1c(%rbp), %eax
leaq -0xb8(%rbp), %rsi
movzbl %al, %ecx
callq 0x2b20
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq $0x1, -0x40(%rbp)
jmp 0x60a7
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x60a9
jmp 0x60ab
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x601d
jmp 0x5ff1
cmpq $0x0, -0x40(%rbp)
je 0x60ee
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
movl -0x1c(%rbp), %eax
leaq -0xb8(%rbp), %rsi
movzbl %al, %ecx
callq 0x2b20
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq (%rcx), %rax
jne 0x6101
jmp 0x6120
leaq 0x26224(%rip), %rdi     # 0x2c32c
leaq 0x2622e(%rip), %rsi     # 0x2c33d
movl $0x3d, %edx
leaq 0x26228(%rip), %rcx     # 0x2c343
callq 0x2140
movq -0x8(%rbp), %rdi
callq 0x28f0
movq -0x48(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x3190
movq -0x48(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/sub.c
// Function: set_bits
static int64_t set_bits(const rld_t *e, const uint64_t *sub, uint64_t *bits, int start, int step, int is_both)
{
	uint64_t i, k, n_ss = 0;
	for (i = start; i < e->mcnt[1]; i += step) {
		if ((sub[i>>6]>>(i&0x3f)&1) == 0) continue;
		k = set_bits_aux(e, bits, i);
		if (is_both && (sub[k>>6]>>(k&0x3f)&1) == 0) {
			set_bits_aux(e, bits, k);
			++n_ss;
		}
	}
	return n_ss;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq $0x0, -0x40(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x640c
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
andq $0x3f, %rcx
shrq %cl, %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x639c
jmp 0x63fb
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x6420
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x63f9
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
andq $0x3f, %rcx
shrq %cl, %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x63f9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x6420
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x63fb
movslq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x635f
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/sub.c
// Function: set_bits_aux
static inline int64_t set_bits_aux(const rld_t *e, uint64_t *bits, uint64_t k)
{
	int c;
	uint64_t *ok;
	ok = alloca(8 * e->asize);
	do {
		set_bit(bits, k);
		c = rld_rank1a(e, k + 1, ok);
		k = e->cnt[c] + ok[c] - 1;
		if (c == 0) break;
	} while (c);
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
movl %ecx, %eax
leal 0xf(,%rax,8), %eax
andl $-0x10, %eax
movl %eax, %ecx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x64c0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x28(%rbp), %rdx
callq 0x3f60
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
addq (%rcx,%rdx,8), %rax
subq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x64a7
jmp 0x64af
jmp 0x64a9
cmpl $0x0, -0x1c(%rbp)
jne 0x6456
movq -0x18(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/unpack.c
// Function: fm_retrieve
int64_t fm_retrieve(const rld_t *e, uint64_t x, kstring_t *s)
{
	uint64_t k = x, *ok;
	ok = alloca(8 * e->asize);
	s->l = 0;
	while (1) {
		int c = rld_rank1a(e, k + 1, ok);
		k = e->cnt[c] + ok[c] - 1;
		if (c == 0) return k;
		kputc(c, s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
movl %ecx, %eax
leal 0xf(,%rax,8), %eax
andl $-0x10, %eax
movl %eax, %ecx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movq -0x28(%rbp), %rdx
callq 0x3f60
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
addq (%rcx,%rdx,8), %rax
subq $0x1, %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x69c3
movq -0x20(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
movl -0x2c(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x69e0
jmp 0x6978
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/unpack.c
// Function: print1
static void print1(const rld_t *e, int i, kstring_t *s)
{
	int64_t k;
	int j, tmp;
	k = fm_retrieve(e, i, s);
	for (j = 0; j < s->l; ++j)
		s->s[j] = "$ACGTN"[(int)s->s[j]];
	for (j = 0; j < s->l>>1; ++j) // reverse
		tmp = s->s[j], s->s[j] = s->s[s->l-1-j], s->s[s->l-1-j] = tmp;
	fwrite(s->s, 1, s->l, stdout);
	printf("\t%ld\n", (long)k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6930
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x7011
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x253a6(%rip), %rax     # 0x2c39a
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6fcf
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
shrl %ecx
cmpl %ecx, %eax
jae 0x708b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
subl -0x24(%rbp), %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x28(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
subl -0x24(%rbp), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7018
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %edx
movq 0x2bf1e(%rip), %rax     # 0x32fc0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x2320
movq -0x20(%rbp), %rsi
leaq 0x25de5(%rip), %rdi     # 0x2ce9f
movb $0x0, %al
callq 0x2120
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: fmc_opt_init
void fmc_opt_init(fmc_opt_t *opt)
{
	memset(opt, 0, sizeof(fmc_opt_t));
	opt->c.k = 17;
	opt->c.suf_len = 1;
	opt->c.min_occ = 3;
	opt->c.q1_depth = 17; // if there q1_depth bases but only one 2nd-best, correct regardless of the quality
	opt->c.max_ec_depth = opt->c.min_occ - 1; // if there are more than max_ec_depth 2nd-best bases, don't correct
	opt->c.a1 = 0.05;
	opt->c.a2 = 10;
	opt->c.err = 0.005;
	opt->c.prior = 0.99;

	opt->n_threads = 1;
	opt->defQ = 17;
	opt->ecQ = 30;
	opt->max_heap_size = 256;
	opt->max_penalty_diff = 60;
	opt->batch_size = (1ULL<<28) - (1ULL<<20);
	opt->max_dist4 = 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x2160
movq -0x8(%rbp), %rax
movq (%rax), %rcx
andq $-0x10000, %rcx         # imm = 0xFFFF0000
orq $0x11, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movabsq $-0xffff0001, %rcx      # imm = 0xFFFFFFFF0000FFFF
andq (%rax), %rcx
orq $0x10000, %rcx          # imm = 0x10000
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movabsq $-0xffff00000001, %rcx  # imm = 0xFFFF0000FFFFFFFF
andq (%rax), %rcx
movabsq $0x300000000, %rdx      # imm = 0x300000000
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x11, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shlq $0x10, %rax
sarq $0x30, %rax
movl %eax, %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0xffff, %rdx           # imm = 0xFFFF
shlq $0x30, %rdx
movabsq $0xffffffffffff, %rsi   # imm = 0xFFFFFFFFFFFF
andq %rsi, %rcx
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movsd 0x2522f(%rip), %xmm0    # 0x2c3c0
movsd %xmm0, 0x10(%rax)
movq -0x8(%rbp), %rax
movsd 0x25216(%rip), %xmm0    # 0x2c3b8
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movsd 0x251fd(%rip), %xmm0    # 0x2c3b0
movsd %xmm0, 0x20(%rax)
movq -0x8(%rbp), %rax
movsd 0x251e4(%rip), %xmm0    # 0x2c3a8
movsd %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x11, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0x1e, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x100, 0x3c(%rax)      # imm = 0x100
movq -0x8(%rbp), %rax
movl $0x3c, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0xff00000, 0x50(%rax)  # imm = 0xFF00000
movq -0x8(%rbp), %rax
movl $0x8, 0x48(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: kf_lgamma
double kf_lgamma(double z) // log(gamma(z))
{
	double x = 0;
	x += 0.1659470187408462e-06 / (z+7);
	x += 0.9934937113930748e-05 / (z+6);
	x -= 0.1385710331296526     / (z+5);
	x += 12.50734324009056      / (z+4);
	x -= 176.6150291498386      / (z+3);
	x += 771.3234287757674      / (z+2);
	x -= 1259.139216722289      / (z+1);
	x += 676.5203681218835      / z;
	x += 0.9999999999995183;
	return log(x) - 5.58106146679532777 - z + (z-0.5) * log(z+6.5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x2521b(%rip), %xmm1    # 0x2c458
addsd -0x8(%rbp), %xmm1
movsd 0x25206(%rip), %xmm0    # 0x2c450
divsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x251e8(%rip), %xmm1    # 0x2c448
addsd -0x8(%rbp), %xmm1
movsd 0x251d3(%rip), %xmm0    # 0x2c440
divsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x251b5(%rip), %xmm0    # 0x2c438
addsd -0x8(%rbp), %xmm0
movsd 0x251a0(%rip), %xmm1    # 0x2c430
divsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x2517e(%rip), %xmm1    # 0x2c428
addsd -0x8(%rbp), %xmm1
movsd 0x25169(%rip), %xmm0    # 0x2c420
divsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x2514b(%rip), %xmm0    # 0x2c418
addsd -0x8(%rbp), %xmm0
movsd 0x25136(%rip), %xmm1    # 0x2c410
divsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x25114(%rip), %xmm1    # 0x2c408
addsd -0x8(%rbp), %xmm1
movsd 0x250ff(%rip), %xmm0    # 0x2c400
divsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x250e1(%rip), %xmm0    # 0x2c3f8
addsd -0x8(%rbp), %xmm0
movsd 0x250cc(%rip), %xmm1    # 0x2c3f0
divsd %xmm0, %xmm1
movsd -0x10(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x250aa(%rip), %xmm0    # 0x2c3e8
divsd -0x8(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x2508b(%rip), %xmm0    # 0x2c3e0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x2180
movsd 0x25067(%rip), %xmm1    # 0x2c3d8
subsd %xmm1, %xmm0
subsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x25044(%rip), %xmm1    # 0x2c3d0
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x2502b(%rip), %xmm0    # 0x2c3c8
addsd -0x8(%rbp), %xmm0
callq 0x2180
movsd -0x20(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x18(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: fmc_beta_binomial
double fmc_beta_binomial(int n, int k, double a, double b) // beta-binomial density
{
	double x, y, z;
	x = lgamma(n + 1) - (lgamma(k + 1) + lgamma(n - k + 1));
	y = lgamma(k + a) + lgamma(n - k + b) - lgamma(n + a + b);
	z = lgamma(a + b) - (lgamma(a) + lgamma(b));
	return exp(x + y + z);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x21e0
movsd %xmm0, -0x58(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x21e0
movsd %xmm0, -0x60(%rbp)
movl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
callq 0x21e0
movsd -0x60(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x58(%rbp), %xmm0
addsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
cvtsi2sdl -0x8(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
callq 0x21e0
movsd %xmm0, -0x50(%rbp)
movl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
cvtsi2sd %eax, %xmm0
addsd -0x18(%rbp), %xmm0
callq 0x21e0
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
callq 0x21e0
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
addsd -0x18(%rbp), %xmm0
callq 0x21e0
movsd %xmm0, -0x38(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x21e0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x21e0
movsd -0x40(%rbp), %xmm1
movaps %xmm0, %xmm2
movsd -0x38(%rbp), %xmm0
addsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
callq 0x2360
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: fmc_precal_qtab
uint8_t *fmc_precal_qtab(int max, double e1, double e2, double a1, double a2, double prior1)
{ // precalculate a lookup table q(n,k), the consensus quality given n bases with k differences
	int n, k;
	uint8_t *qtab;
	double b1 = a1 * (1 - e1) / e1, b2 = a2 * (1 - e2) / e2;

	assert(FMC_Q_MAX>>1 < FMC_Q_1);
	qtab = calloc(max * max, 1);
	for (n = 1; n < max; ++n) {
		uint8_t *qn = &qtab[n*max];
		//fprintf(stderr, "=> %d <=", n);
		for (k = 0; k < n; ++k) {
			double p1, p2;
			int q;
			p1 = fmc_beta_binomial(n, k, a1, b1);
			p2 = fmc_beta_binomial(n, k, a2, b2);
			q = (int)(-4.343 * log(1. - p1 * prior1 / (p1 * prior1 + p2 * (1-prior1))) + .499);
			qn[k] = (q < FMC_Q_MAX? q : FMC_Q_MAX) >> 1;
			//if (q) fprintf(stderr, "\t%d:%d", k, q);
		}
		//fprintf(stderr, "\n");
	}
	return qtab;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd %xmm4, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x24ec7(%rip), %xmm1    # 0x2c3f8
subsd -0x10(%rbp), %xmm1
mulsd %xmm1, %xmm0
divsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x24ea7(%rip), %xmm1    # 0x2c3f8
subsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movl -0x4(%rbp), %eax
imull -0x4(%rbp), %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x21a0
movq %rax, -0x40(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7699
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
imull -0x4(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x7689
movl -0x34(%rbp), %edi
movl -0x38(%rbp), %esi
movsd -0x20(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
callq 0x73d0
movsd %xmm0, -0x60(%rbp)
movl -0x34(%rbp), %edi
movl -0x38(%rbp), %esi
movsd -0x28(%rbp), %xmm0
movsd -0x50(%rbp), %xmm1
callq 0x73d0
movsd %xmm0, -0x68(%rbp)
movsd -0x60(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
movsd -0x60(%rbp), %xmm0
movsd -0x30(%rbp), %xmm3
movsd -0x68(%rbp), %xmm2
movsd 0x24dec(%rip), %xmm4    # 0x2c3f8
subsd -0x30(%rbp), %xmm4
mulsd %xmm4, %xmm2
mulsd %xmm3, %xmm0
addsd %xmm2, %xmm0
divsd %xmm0, %xmm1
movsd 0x24dcf(%rip), %xmm0    # 0x2c3f8
subsd %xmm1, %xmm0
callq 0x2180
movsd 0x24e26(%rip), %xmm1    # 0x2c460
mulsd %xmm1, %xmm0
movsd 0x24e22(%rip), %xmm1    # 0x2c468
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x6c(%rbp)
cmpl $0x29, -0x6c(%rbp)
jge 0x765f
movl -0x6c(%rbp), %eax
movl %eax, -0x70(%rbp)
jmp 0x7669
movl $0x29, %eax
movl %eax, -0x70(%rbp)
jmp 0x7669
movl -0x70(%rbp), %eax
sarl %eax
movb %al, %dl
movq -0x58(%rbp), %rax
movslq -0x38(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x75ab
jmp 0x768b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7583
movq -0x40(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: fmc_kmer_stat
void fmc_kmer_stat(int suf_len, const fmc64_v *a)
{
	int i, n_suf = 1<<suf_len*2;
	int64_t tot = 0;
	for (i = 0; i < n_suf; ++i)
		tot += a[i].n<<1;
	fprintf(stderr, "[M::%s] %ld k-mers\n", __func__, (long)tot);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %ecx
shll %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x816d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
shlq %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x813d
movq 0x2ae84(%rip), %rax     # 0x32ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rcx
leaq 0x2433e(%rip), %rsi     # 0x2c4c0
leaq 0x2434b(%rip), %rdx     # 0x2c4d4
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi2/correct.c
// Function: fmc_kmer_write
void fmc_kmer_write(FILE *fp, const fmc_opt_t *opt, const fmc64_v *a)
{
	int i, n = 1<<opt->c.suf_len*2;
	fwrite(FMC_KMER_MAGIC, 1, 4, fp);
	fwrite(&opt->c, sizeof(fmc_collect_opt_t), 1, fp);
	for (i = 0; i < n; ++i) {
		fwrite(&a[i].n, sizeof(size_t), 1, fp);
		fwrite(a[i].a, 8, a[i].n, fp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
shlq $0x20, %rax
sarq $0x30, %rax
movl %eax, %ecx
shll %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
leaq 0x24055(%rip), %rdi     # 0x2c591
movl $0x1, %esi
movl $0x4, %edx
callq 0x2320
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x30, %esi
movl $0x1, %edx
callq 0x2320
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x85d1
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x2320
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rcx
movl $0x8, %esi
callq 0x2320
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x8569
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)