LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_stat
parasail_file_stat_t* parasail_stat(const parasail_file_t *pf)
{
    parasail_file_stat_t *stat = NULL;

    if (NULL == pf) {
        fprintf(stderr, "parasail_stat: NULL pointer\n");
        return NULL;
    }

    if (1 == parasail_is_fasta(pf)) {
        stat = parasail_stat_fasta(pf);
    }
    else if (1 == parasail_is_fastq(pf)) {
        stat = parasail_stat_fastq(pf);
    }
    else {
        fprintf(stderr, "parasail_stat: cannot determine file format\n");
        return NULL;
    }

    if (NULL == stat) {
        fprintf(stderr, "parasail_stat: failed\n");
        return NULL;
    }

    return stat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f45a1
movq 0xc2da55(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d72d(%rip), %rsi    # 0xd01cba
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f463d
movq -0x10(%rbp), %rdi
callq 0x1f43e0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1f45c4
movq -0x10(%rbp), %rdi
callq 0x1f4650
movq %rax, -0x18(%rbp)
jmp 0x1f460b
movq -0x10(%rbp), %rdi
callq 0x1f44a0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1f45e7
movq -0x10(%rbp), %rdi
callq 0x1f46b0
movq %rax, -0x18(%rbp)
jmp 0x1f4609
movq 0xc2d9ea(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d6df(%rip), %rsi    # 0xd01cd7
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f463d
jmp 0x1f460b
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x1f4635
movq 0xc2d9be(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d6e0(%rip), %rsi    # 0xd01d04
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f463d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_stat_fasta
parasail_file_stat_t* parasail_stat_fasta(const parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_stat_fasta: NULL pointer\n");
        return NULL;
    }

    return parasail_stat_fasta_buffer(pf->buf, pf->size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f4686
movq 0xc2d96d(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d6e8(%rip), %rsi    # 0xd01d5d
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f469f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1f4810
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_stat_fastq
parasail_file_stat_t* parasail_stat_fastq(const parasail_file_t *pf)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_stat_fastq: NULL pointer\n");
        return NULL;
    }

    return parasail_stat_fastq_buffer(pf->buf, pf->size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f46e6
movq 0xc2d90d(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d7ff(%rip), %rsi    # 0xd01ed4
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f46ff
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1f4bf0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_stat_buffer
parasail_file_stat_t* parasail_stat_buffer(const char *buf, off_t size)
{
    parasail_file_stat_t *stat = NULL;

    if (NULL == buf) {
        fprintf(stderr, "parasail_stat_buffer: NULL pointer\n");
        return NULL;
    }

    if (1 == parasail_is_fasta_buffer(buf, size)) {
        stat = parasail_stat_fasta_buffer(buf, size);
    }
    else if (parasail_is_fastq_buffer(buf, size)) {
        stat = parasail_stat_fastq_buffer(buf, size);
    }
    else {
        fprintf(stderr, "parasail_stat: cannot determine file format\n");
        return NULL;
    }

    if (NULL == stat) {
        fprintf(stderr, "parasail_stat_buffer: failed\n");
        return NULL;
    }

    return stat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f4755
movq 0xc2d8a1(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d5da(%rip), %rsi    # 0xd01d1b
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f47fb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f4440
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1f4780
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f4810
movq %rax, -0x20(%rbp)
jmp 0x1f47c9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f4500
cmpl $0x0, %eax
je 0x1f47a5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f4bf0
movq %rax, -0x20(%rbp)
jmp 0x1f47c7
movq 0xc2d82c(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d521(%rip), %rsi    # 0xd01cd7
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f47fb
jmp 0x1f47c9
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1f47f3
movq 0xc2d800(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0d55d(%rip), %rsi    # 0xd01d3f
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f47fb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: skip_line
inline static off_t skip_line(const char *T, off_t i)
{
    while (T[i] != '\n' && T[i] != '\r') {
        ++i;
    }

    /* for the case of "\r\n" or "\n\r" */
    if (T[i+1] == '\n' || T[i+1] == '\r') {
        ++i;
    }

    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x11(%rbp)
je 0x1f5037
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x1f5040
jmp 0x1f504e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1f500c
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x1f5072
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x1f507e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_read
char * parasail_read(const parasail_file_t *pf, long * size)
{
    char * buffer = NULL;

    if (NULL == pf) {
        fprintf(stderr, "parasail_read: NULL pointer\n");
        return NULL;
    }

    if (NULL == size) {
        fprintf(stderr, "parasail_read: NULL size pointer\n");
        return NULL;
    }

    buffer = (char*)malloc(sizeof(char) * (pf->size+1));
    if (NULL == buffer) {
        perror("malloc");
        fprintf(stderr, "parasail_read: "
                "cannont malloc buffer for input file");
        return NULL;
    }

    (void)memcpy(buffer, pf->buf, pf->size);
    buffer[pf->size] = '\0';
    *size = pf->size;
    return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f5265
movq 0xc2cd91(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cd55(%rip), %rsi    # 0xd01fa6
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f5321
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x1f5292
movq 0xc2cd64(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cd45(%rip), %rsi    # 0xd01fc3
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f5321
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1f01c0
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1f52e1
leaq 0xb0c8b5(%rip), %rdi    # 0xd01b6f
callq 0x1f0120
movq 0xc2cd12(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cd15(%rip), %rsi    # 0xd01fe5
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f5321
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x1f0110
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_pack
char * parasail_pack(const parasail_file_t *pf, long * size)
{
    char *packed = NULL;

    if (NULL == pf) {
        fprintf(stderr, "parasail_pack: NULL pointer\n");
        return NULL;
    }

    if (NULL == size) {
        fprintf(stderr, "parasail_pack: NULL size pointer\n");
        return NULL;
    }

    if (1 == parasail_is_fasta(pf)) {
        packed = parasail_pack_fasta(pf, size);
    }
    else if (1 == parasail_is_fastq(pf)) {
        packed = parasail_pack_fastq(pf, size);
    }
    else {
        fprintf(stderr, "parasail_pack: cannot determine file format\n");
        return NULL;
    }

    if (NULL == packed) {
        fprintf(stderr, "parasail_pack: failed\n");
        return NULL;
    }

    return packed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f5375
movq 0xc2cc81(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0ccb8(%rip), %rsi    # 0xd02019
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f5446
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x1f53a2
movq 0xc2cc54(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cca8(%rip), %rsi    # 0xd02036
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f5446
movq -0x10(%rbp), %rdi
callq 0x1f43e0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1f53c9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f5450
movq %rax, -0x20(%rbp)
jmp 0x1f5414
movq -0x10(%rbp), %rdi
callq 0x1f44a0
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1f53f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f54e0
movq %rax, -0x20(%rbp)
jmp 0x1f5412
movq 0xc2cbe1(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cc57(%rip), %rsi    # 0xd02058
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f5446
jmp 0x1f5414
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1f543e
movq 0xc2cbb5(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cc58(%rip), %rsi    # 0xd02085
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f5446
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_pack_fasta
char * parasail_pack_fasta(const parasail_file_t *pf, long * packed_size)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_pack_fasta: NULL pointer\n");
        return NULL;
    }

    if (NULL == packed_size) {
        fprintf(stderr, "parasail_pack_fasta: NULL size pointer\n");
        return NULL;
    }

    return parasail_pack_fasta_buffer(pf->buf, pf->size, packed_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f548a
movq 0xc2cb69(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cc8e(%rip), %rsi    # 0xd02107
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f54d1
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x1f54b4
movq 0xc2cb3f(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cc87(%rip), %rsi    # 0xd0212a
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f54d1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f56b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_pack_fastq
char * parasail_pack_fastq(const parasail_file_t *pf, long * size)
{
    if (NULL == pf) {
        fprintf(stderr, "parasail_pack_fastq: NULL pointer\n");
        return NULL;
    }

    if (NULL == size) {
        fprintf(stderr, "parasail_pack_fastq: NULL size pointer\n");
        return NULL;
    }

    return parasail_pack_fastq_buffer(pf->buf, pf->size, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f551a
movq 0xc2cad9(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cda8(%rip), %rsi    # 0xd022b1
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f5561
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x1f5544
movq 0xc2caaf(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0cda1(%rip), %rsi    # 0xd022d4
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f5561
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x1f5a30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: parasail_pack_buffer
char * parasail_pack_buffer(const char *buf, off_t size, long * packed_size)
{
    char *packed = NULL;

    if (NULL == buf) {
        fprintf(stderr, "parasail_pack_buffer: NULL pointer\n");
        return NULL;
    }

    if (NULL == packed_size) {
        fprintf(stderr, "parasail_pack_buffer: NULL size pointer\n");
        return NULL;
    }

    if (1 == parasail_is_fasta_buffer(buf, size)) {
        packed = parasail_pack_fasta_buffer(buf, size, packed_size);
    }
    else if (1 == parasail_is_fastq_buffer(buf, size)) {
        packed = parasail_pack_fastq_buffer(buf, size, packed_size);
    }
    else {
        fprintf(stderr, "parasail_pack: cannot determine file format\n");
        return NULL;
    }

    if (NULL == packed) {
        fprintf(stderr, "parasail_pack_buffer: failed\n");
        return NULL;
    }

    return packed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1f55b9
movq 0xc2ca3d(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0caf7(%rip), %rsi    # 0xd0209c
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f569a
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0x1f55e6
movq 0xc2ca10(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0caee(%rip), %rsi    # 0xd020c0
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f569a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f4440
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1f5615
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f56b0
movq %rax, -0x28(%rbp)
jmp 0x1f5668
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1f4500
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jne 0x1f5644
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1f5a30
movq %rax, -0x28(%rbp)
jmp 0x1f5666
movq 0xc2c98d(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0ca03(%rip), %rsi    # 0xd02058
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f569a
jmp 0x1f5668
xorl %eax, %eax
cmpq -0x28(%rbp), %rax
jne 0x1f5692
movq 0xc2c961(%rip), %rax    # 0xe21fd8
movq (%rax), %rdi
leaq 0xb0ca68(%rip), %rsi    # 0xd020e9
movb $0x0, %al
callq 0x1f01f0
movq $0x0, -0x8(%rbp)
jmp 0x1f569a
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/io.c
// Function: get_num
inline static int get_num(const char *T, off_t *i_, int *result)
{
    off_t i = *i_;
    int retval = 0;
    int p = 0;
    char token[TOKEN_MAX];

    /* skip any whitespace */
    while (T[i] == ' ' || T[i] == '\t') {
        ++i;
    }

    if (isdigit(T[i]) || T[i] == '-') {
        token[0] = T[i];
    }
    else {
        return -1;
    }

    ++i;
    for (p=1; p<TOKEN_MAX; ++p) {
        if (isdigit(T[i])) {
            token[p] = T[i];
            ++i;
        }
        else {
            break;
        }
    }
    if (TOKEN_MAX == p) {
        return -1;
    }
    token[p] = '\0';

    retval = sscanf(token, "%d", result);
    if (1 != retval) {
        return -1;
    }

    *i_ = i;

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x3b(%rbp)
je 0x1f6cd8
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
testb $0x1, %al
jne 0x1f6ce1
jmp 0x1f6cef
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1f6cad
callq 0x1f0170
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x1f6d25
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x1f6d35
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x3a(%rbp)
jmp 0x1f6d41
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f6e09
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x30(%rbp)
cmpl $0xa, -0x30(%rbp)
jge 0x1f6daf
callq 0x1f0170
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x1f6da0
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %cl
movslq -0x30(%rbp), %rax
movb %cl, -0x3a(%rbp,%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1f6da2
jmp 0x1f6daf
jmp 0x1f6da4
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1f6d54
movl $0xa, %eax
cmpl -0x30(%rbp), %eax
jne 0x1f6dc2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f6e09
movslq -0x30(%rbp), %rax
movb $0x0, -0x3a(%rbp,%rax)
leaq -0x3a(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xb0b96d(%rip), %rsi    # 0xd02747
movb $0x0, %al
callq 0x1f0140
movl %eax, -0x2c(%rbp)
movl $0x1, %eax
cmpl -0x2c(%rbp), %eax
je 0x1f6df7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f6e09
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/pssw.c
// Function: parasail_ssw_init
parasail_profile_t* parasail_ssw_init(
        const char * const restrict s1, const int s1Len,
        const parasail_matrix_t* matrix, const int8_t score_size)
{
    parasail_profile_t *profile8 = NULL;
    parasail_profile_t *profile16 = NULL;

    if (score_size == 0 || score_size == 2) {
        profile8 = parasail_profile_create_8(s1, s1Len, matrix);
    }
    if (score_size == 1 || score_size == 2) {
        profile16 = parasail_profile_create_16(s1, s1Len, matrix);
    }

    if (profile8 && profile16) {
        profile8->profile16 = profile16->profile16;
        free(profile16);
        return profile8;
    }
    else if (profile8) {
        return profile8;
    }
    else if (profile16) {
        return profile16;
    }

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x0, %eax
je 0x1fc6da
movsbl -0x21(%rbp), %eax
cmpl $0x2, %eax
jne 0x1fc6ee
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x270660
movq %rax, -0x30(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x1, %eax
je 0x1fc700
movsbl -0x21(%rbp), %eax
cmpl $0x2, %eax
jne 0x1fc714
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x270630
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1fc755
cmpq $0x0, -0x38(%rbp)
je 0x1fc755
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x30(%rcx), %rdx
movq %rdx, 0x30(%rax)
movq 0x38(%rcx), %rdx
movq %rdx, 0x38(%rax)
movq 0x40(%rcx), %rcx
movq %rcx, 0x40(%rax)
movq -0x38(%rbp), %rdi
callq 0x1f01a0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1fc783
cmpq $0x0, -0x30(%rbp)
je 0x1fc766
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1fc783
cmpq $0x0, -0x38(%rbp)
je 0x1fc777
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1fc783
jmp 0x1fc779
jmp 0x1fc77b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/pssw.c
// Function: parasail_ssw
parasail_result_ssw_t* parasail_ssw(
        const char * const restrict s1, const int s1Len,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap, const parasail_matrix_t* matrix)
{
    parasail_profile_t *profile = parasail_ssw_init(s1, s1Len, matrix, 2);
    parasail_result_ssw_t *result = parasail_ssw_profile(profile, s2, s2Len, open, gap);
    parasail_profile_free(profile);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x10(%rbp), %rdx
movl $0x2, %ecx
callq 0x1fc6a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movl -0x24(%rbp), %r8d
callq 0x1fc800
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1f98d0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/parasail/src/striped_unwind.c
// Function: parasail_striped_unwind_8
static inline int* CONCAT(parasail_striped_unwind_, T) (
        int lena,
        int lenb,
        int segWidth,
        void *array_)
{
    int i;
    int j;
    int *ret = (int*)malloc(sizeof(int)*lena*lenb);
    D *array = (D*)array_;
    const int32_t segLen = (lena + segWidth - 1) / segWidth;
    int32_t column_len = segLen * segWidth;
    for (j=0; j<lenb; ++j) {
        for (i=0; i<column_len; ++i) {
            int32_t i_unwound = i / segWidth + i % segWidth * segLen;
            if (i_unwound < lena) {
                ret[i_unwound*lenb + j] = (int)array[j*column_len + i];
            }
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
movslq -0x8(%rbp), %rax
imulq %rax, %rdi
callq 0x1f01c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %eax
addl -0xc(%rbp), %eax
subl $0x1, %eax
cltd
idivl -0xc(%rbp)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2cbfb6
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x2cbfa9
movl -0x1c(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl -0x40(%rbp), %eax
imull -0x34(%rbp), %edx
addl %edx, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2cbf9c
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %ecx
imull -0x38(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edx
movq -0x28(%rbp), %rax
movl -0x3c(%rbp), %ecx
imull -0x8(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2cbf9e
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2cbf46
jmp 0x2cbfab
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2cbf37
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: atomic_int_create
atomic_int	*
atomic_int_create(uint64_t val)
{
	atomic_int *ai = malloc(sizeof(atomic_int));
	ai->val = val;
	pthread_mutex_init(&ai->lock,0);
	return(ai);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x30, %edi
callq 0x2310
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: atomic_int_add
uint64_t
atomic_int_add(atomic_int *ai, int val)
{
	uint32_t	rv;
	pthread_mutex_lock(&ai->lock);
	ai->val += val;
	rv = ai->val;
	pthread_mutex_unlock(&ai->lock);
	return(rv);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x23e0
movslq 0xc(%rsp), %rcx
movq 0x10(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x21c0
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: atomic_int_get
uint64_t		
atomic_int_get(atomic_int *ai)
{
	uint64_t	val;
	pthread_mutex_lock(&ai->lock);
	val = ai->val;
	pthread_mutex_unlock(&ai->lock);
	return(val);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x23e0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x21c0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: counter_fn
void *
counter_fn(void *arg)
{
	counter_thread_control *ctc = (counter_thread_control *) arg;
	
	while (ctc->death == 0) {
		sleep(1);
		fprintf(stderr, "loopTest: reads %"PRIu64" writes %"PRIu64" deletes %"PRIu64" (total keys: %"PRIu64")\n",
			atomic_int_get(ctc->reads), atomic_int_get(ctc->writes), atomic_int_get(ctc->deletes),
			atomic_int_get(ctc->keys) );
        	citrusleaf_print_stats();
	}
	return(0);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x2830
movl $0x1, %edi
callq 0x21b0
movq 0x1b82d(%rip), %rax     # 0x1dfe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x2740
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2740
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2740
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x2740
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
movq %rax, %r9
leaq 0x158a1(%rip), %rsi     # 0x180c0
movb $0x0, %al
callq 0x23b0
callq 0x9a20
jmp 0x2793
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: start_counter_thread
void *
start_counter_thread(atomic_int *reads, atomic_int *writes, atomic_int *deletes, atomic_int *keys)
{
	counter_thread_control *ctc = (counter_thread_control *) malloc(sizeof(counter_thread_control));
	ctc->reads = reads;
	ctc->writes = writes;
	ctc->deletes = deletes;
	ctc->keys = keys;
	ctc->death = 0;
	pthread_create(&ctc->th, 0, counter_fn, ctc);
	return(ctc);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x30, %edi
callq 0x2310
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movl $0x0, 0x20(%rax)
movq (%rsp), %rdi
addq $0x28, %rdi
movq (%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x13b(%rip), %rdx      # 0x2780
callq 0x2500
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: stop_counter_thread
void
stop_counter_thread(void *control)
{
	counter_thread_control *ctc = (counter_thread_control *)control;
	ctc->death = 1;
	pthread_join(ctc->th, 0);
	free(ctc);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x1, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2250
movq 0x8(%rsp), %rdi
callq 0x22e0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: rand_64
uint64_t
rand_64()
{
	uint64_t r;
	if (g_config.pseudo_seed) {

		r = random();
		
	}
	else {
		pthread_mutex_lock(&rand_buf_lock);
		if (rand_buf_off < sizeof(uint64_t) ) {
			if (seeded == 0) {
				int rfd = open("/dev/urandom",	O_RDONLY);
				int rsz = read(rfd, rand_buf, SEED_SZ);
				if (rsz < SEED_SZ) {
					fprintf(stderr, "warning! can't seed random number generator");
					return(0);
				}
				close(rfd);
				RAND_seed(rand_buf, rsz);
				seeded = 1;
			}
			if (1 != RAND_bytes(rand_buf, sizeof(rand_buf))) {
				fprintf(stderr, "RAND_bytes not so happy.\n");
				pthread_mutex_unlock(&rand_buf_lock);
				return(0);
			}
			rand_buf_off = sizeof(rand_buf);
		}
		
		rand_buf_off -= sizeof(uint64_t);
		r = *(uint64_t *) (&rand_buf[rand_buf_off]);
		pthread_mutex_unlock(&rand_buf_lock);
	}
	return(r);
}

// Assembly:
subq $0x18, %rsp
cmpl $0x0, 0x1ba55(%rip)     # 0x1e370
je 0x292c
callq 0x2150
movq %rax, 0x8(%rsp)
jmp 0x2a54
leaq 0x1ba4d(%rip), %rdi     # 0x1e380
callq 0x23e0
movl 0x1ba6a(%rip), %eax     # 0x1e3a8
cmpq $0x8, %rax
jae 0x2a20
cmpl $0x0, 0x1ba5d(%rip)     # 0x1e3ac
jne 0x29cb
leaq 0x157a6(%rip), %rdi     # 0x180fe
xorl %esi, %esi
movb $0x0, %al
callq 0x24d0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
leaq 0x1ba40(%rip), %rsi     # 0x1e3b0
movl $0x40, %edx
callq 0x23c0
movl %eax, (%rsp)
cmpl $0x40, (%rsp)
jge 0x29a9
movq 0x1b656(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x15777(%rip), %rsi     # 0x1810b
movb $0x0, %al
callq 0x23b0
movq $0x0, 0x10(%rsp)
jmp 0x2a5e
movl 0x4(%rsp), %edi
callq 0x2570
movl (%rsp), %esi
leaq 0x1b9f4(%rip), %rdi     # 0x1e3b0
callq 0x24c0
movl $0x1, 0x1b9e1(%rip)     # 0x1e3ac
leaq 0x1b9de(%rip), %rdi     # 0x1e3b0
movl $0x2000, %esi           # imm = 0x2000
callq 0x2400
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x2a16
movq 0x1b5f2(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x1573f(%rip), %rsi     # 0x18137
movb $0x0, %al
callq 0x23b0
leaq 0x1b97a(%rip), %rdi     # 0x1e380
callq 0x21c0
movq $0x0, 0x10(%rsp)
jmp 0x2a5e
movl $0x2000, 0x1b988(%rip)  # imm = 0x2000
movl 0x1b982(%rip), %eax     # 0x1e3a8
subq $0x8, %rax
movl %eax, 0x1b978(%rip)     # 0x1e3a8
movl 0x1b972(%rip), %eax     # 0x1e3a8
movl %eax, %ecx
leaq 0x1b971(%rip), %rax     # 0x1e3b0
movq (%rax,%rcx), %rax
movq %rax, 0x8(%rsp)
leaq 0x1b931(%rip), %rdi     # 0x1e380
callq 0x21c0
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/main.c
// Function: usage
void usage(void) {
	fprintf(stderr, "Usage key_c:\n");
	fprintf(stderr, "-h host [default 127.0.0.1] \n");
	fprintf(stderr, "-p port [default 3000]\n");
	fprintf(stderr, "-H host:port [default 127.0.0.1:3000]\n");
	fprintf(stderr, "-n namespace [default test]\n");
	fprintf(stderr, "-s set [default 'set']\n");
	fprintf(stderr, "-S Strict - verify all keys and halt on error\n");
	fprintf(stderr, "-b bin [default value]\n");
	fprintf(stderr, "-t threads [default 32]\n");
	fprintf(stderr, "-k keys [default 100000]\n");
	fprintf(stderr, "-K key size [default 10]\n");
	fprintf(stderr, "-V value size [default 20]\n");
	fprintf(stderr, "-r random seed [default random]\n");
	fprintf(stderr, "-m milliseconds timeout [default 200]\n");
	fprintf(stderr, "-f do not follow cluster [default do follow]\n");
	fprintf(stderr, "-v is verbose\n");
}

// Assembly:
pushq %rax
movq 0x1b528(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x1568f(%rip), %rsi     # 0x18151
movb $0x0, %al
callq 0x23b0
movq 0x1b510(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x15685(%rip), %rsi     # 0x1815f
movb $0x0, %al
callq 0x23b0
movq 0x1b4f8(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x1568b(%rip), %rsi     # 0x1817d
movb $0x0, %al
callq 0x23b0
movq 0x1b4e0(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x1568b(%rip), %rsi     # 0x18195
movb $0x0, %al
callq 0x23b0
movq 0x1b4c8(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x1569a(%rip), %rsi     # 0x181bc
movb $0x0, %al
callq 0x23b0
movq 0x1b4b0(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x1569f(%rip), %rsi     # 0x181d9
movb $0x0, %al
callq 0x23b0
movq 0x1b498(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x1569f(%rip), %rsi     # 0x181f1
movb $0x0, %al
callq 0x23b0
movq 0x1b480(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x156b6(%rip), %rsi     # 0x18220
movb $0x0, %al
callq 0x23b0
movq 0x1b468(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x156b6(%rip), %rsi     # 0x18238
movb $0x0, %al
callq 0x23b0
movq 0x1b450(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x156b7(%rip), %rsi     # 0x18251
movb $0x0, %al
callq 0x23b0
movq 0x1b438(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x156b9(%rip), %rsi     # 0x1826b
movb $0x0, %al
callq 0x23b0
movq 0x1b420(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x156bb(%rip), %rsi     # 0x18285
movb $0x0, %al
callq 0x23b0
movq 0x1b408(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x156bf(%rip), %rsi     # 0x182a1
movb $0x0, %al
callq 0x23b0
movq 0x1b3f0(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x156c8(%rip), %rsi     # 0x182c2
movb $0x0, %al
callq 0x23b0
movq 0x1b3d8(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x156d7(%rip), %rsi     # 0x182e9
movb $0x0, %al
callq 0x23b0
movq 0x1b3c0(%rip), %rax     # 0x1dfe0
movq (%rax), %rdi
leaq 0x156ed(%rip), %rsi     # 0x18317
movb $0x0, %al
callq 0x23b0
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/loop.c
// Function: my_itoa
void
my_itoa(char *s, uint64_t v, uint sz)
{
	s[sz] = 0;
	int i;
	for (i = sz-1; i >= 0; i--) {
		s[i] = (v % 10) + '0';
		if (v) v = v / 10;
	}
	
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movl -0x14(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movl -0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rsp)
cmpl $0x0, -0x18(%rsp)
jl 0x30d8
movq -0x10(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
addq $0x30, %rdx
movq -0x8(%rsp), %rax
movslq -0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
cmpq $0x0, -0x10(%rsp)
je 0x30c9
movq -0x10(%rsp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rsp)
jmp 0x30cb
movl -0x18(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x3086
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/../../../include/citrusleaf/citrusleaf.h
// Function: cl_write_parameters_set_default
static inline void
cl_write_parameters_set_default(cl_write_parameters *cl_w_p)
{
	cl_w_p->unique = false;
	cl_w_p->unique_bin = false;
	cl_w_p->use_generation = false;
	cl_w_p->use_generation_gt = false;
	cl_w_p->use_generation_dup = false;
	cl_w_p->timeout_ms = 0;
	cl_w_p->record_ttl = 0;
	cl_w_p->w_pol = CL_WRITE_RETRY;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, (%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x1(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x2(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x3(%rax)
movq -0x8(%rsp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movl $0x2, 0x14(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/shash.c
// Function: shash_get
int
shash_get(shash *h, void *key, void *value)
{
	int rv = SHASH_ERR;
	
	uint hash = h->h_fn(key);
	hash %= h->table_len;

	pthread_mutex_t		*l = 0;
	if (h->flags & SHASH_CR_MT_BIGLOCK) {
		l = &h->biglock;
	}
	else if (h->flags & SHASH_CR_MT_MANYLOCK) {
		l = & (h->lock_table[hash]);
	}
	if (l)     pthread_mutex_lock( l );
	
	shash_elem *e = (shash_elem *) ( ((uint8_t *)h->table) + (SHASH_ELEM_SZ(h) * hash));	

	if (e->in_use == false) {
		rv = SHASH_ERR_NOTFOUND;
		goto Out;
	}
	
	do {
		if ( memcmp(SHASH_ELEM_KEY_PTR(h, e), key, h->key_len) == 0) {
			memcpy(value, SHASH_ELEM_VALUE_PTR(h, e), h->value_len);
			rv = SHASH_OK; 
			goto Out;
		}
		e = e->next;
	} while (e);
	rv = SHASH_ERR_NOTFOUND;
	
Out:
	if (l) pthread_mutex_unlock(l);

	return(rv);
					
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rdi
callq *%rax
movl %eax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %ecx
movl 0x18(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x46bc
movq 0x30(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
jmp 0x46e7
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x46e5
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x18(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x46e7
cmpq $0x0, 0x10(%rsp)
je 0x46f9
movq 0x10(%rsp), %rdi
callq 0x23e0
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
movq 0x30(%rsp), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
movl 0x18(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4745
movl $0xfffffffd, 0x1c(%rsp) # imm = 0xFFFFFFFD
jmp 0x47b8
jmp 0x4747
movq 0x8(%rsp), %rdi
addq $0x9, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x2110
cmpl $0x0, %eax
jne 0x479b
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x9, %rsi
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
addq %rax, %rsi
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, %edx
callq 0x21e0
movl $0x0, 0x1c(%rsp)
jmp 0x47b8
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4747
movl $0xfffffffd, 0x1c(%rsp) # imm = 0xFFFFFFFD
cmpq $0x0, 0x10(%rsp)
je 0x47ca
movq 0x10(%rsp), %rdi
callq 0x21c0
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/shash.c
// Function: shash_get_vlock
int
shash_get_vlock(shash *h, void *key, void **value, pthread_mutex_t **vlock)
{
	int rv = SHASH_ERR;
	
	uint hash = h->h_fn(key);
	hash %= h->table_len;

	pthread_mutex_t		*l = 0;
	if (h->flags & SHASH_CR_MT_BIGLOCK) {
		l = &h->biglock;
	}
	else if (h->flags & SHASH_CR_MT_MANYLOCK) {
		l = & (h->lock_table[hash]);
	}
	if (l)     pthread_mutex_lock( l );
	
	shash_elem *e = (shash_elem *) ( ((uint8_t *)h->table) + (SHASH_ELEM_SZ(h) * hash));	

	if (e->in_use == false) {
		rv = SHASH_ERR_NOTFOUND;
		goto Out;
	}
	
	do {
		if ( memcmp(SHASH_ELEM_KEY_PTR(h, e), key, h->key_len) == 0) {
			*value = SHASH_ELEM_VALUE_PTR(h, e);
			rv = SHASH_OK; 
			goto Out;
		}
		e = e->next;
	} while (e);
	
	rv = SHASH_ERR_NOTFOUND;
	
Out:
	if (l) {
		if (rv == SHASH_OK) {
			*vlock = l;
		}
		else {
			pthread_mutex_unlock( l );
			*vlock = 0;
		}
	}
	else {
		// for safety sake
		if (vlock) *vlock = 0;
	}

	return(rv);
					
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rdi
callq *%rax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %ecx
movl 0x10(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4851
movq 0x30(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
jmp 0x487c
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x487a
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x10(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x487c
cmpq $0x0, 0x8(%rsp)
je 0x488e
movq 0x8(%rsp), %rdi
callq 0x23e0
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
movq 0x30(%rsp), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
movl 0x10(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x48d8
movl $0xfffffffd, 0x14(%rsp) # imm = 0xFFFFFFFD
jmp 0x493a
jmp 0x48da
movq (%rsp), %rdi
addq $0x9, %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x2110
cmpl $0x0, %eax
jne 0x4920
movq (%rsp), %rcx
addq $0x9, %rcx
movq 0x30(%rsp), %rax
movl 0x4(%rax), %eax
addq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x14(%rsp)
jmp 0x493a
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x48da
movl $0xfffffffd, 0x14(%rsp) # imm = 0xFFFFFFFD
cmpq $0x0, 0x8(%rsp)
je 0x4970
cmpl $0x0, 0x14(%rsp)
jne 0x4958
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x496e
movq 0x8(%rsp), %rdi
callq 0x21c0
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
jmp 0x4986
cmpq $0x0, 0x18(%rsp)
je 0x4984
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
jmp 0x4986
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/shash.c
// Function: shash_delete_lockfree
int
shash_delete_lockfree(shash *h, void *key)
{
	// Calculate hash
	uint hash = h->h_fn(key);
	hash %= h->table_len;

	shash_elem *e = (shash_elem *) ( ((uint8_t *)h->table) + (SHASH_ELEM_SZ(h) * hash));	

	// If bucket empty, def can't delete
	if ( e->in_use == false )
		return( SHASH_ERR_NOTFOUND );

	shash_elem *e_prev = 0;

	// Look for teh element and destroy if found
	while (e) {
		if ( memcmp(SHASH_ELEM_KEY_PTR(h, e), key, h->key_len) == 0) {
			// Found it
			// patchup pointers & free element if not head
			if (e_prev) {
				e_prev->next = e->next;
				free (e);
			}
			// am at head - more complicated
			else {
				// at head with no next - easy peasy!
				if (0 == e->next) {
					e->in_use = false;
				}
				// at head with a next - more complicated
				else {
					shash_elem *_t = e->next;
					memcpy(e, e->next, SHASH_ELEM_SZ(h) );
					free(_t);
				}
			}
			h->elements--;
			return( SHASH_OK );
		}
		e_prev = e;
		e = e->next;
	}
	
	return ( SHASH_ERR_NOTFOUND );

	
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rdi
callq *%rax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movl 0x18(%rax), %ecx
movl 0x1c(%rsp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
movq 0x28(%rsp), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
movl 0x1c(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x4c15
movl $0xfffffffd, 0x34(%rsp) # imm = 0xFFFFFFFD
jmp 0x4d07
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4cff
movq 0x10(%rsp), %rdi
addq $0x9, %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
callq 0x2110
cmpl $0x0, %eax
jne 0x4ce3
cmpq $0x0, 0x8(%rsp)
je 0x4c74
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x22e0
jmp 0x4ccd
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x4c8b
movq 0x10(%rsp), %rax
movb $0x0, 0x8(%rax)
jmp 0x4ccb
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
addq $0x10, %rdx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
addq %rax, %rdx
callq 0x21e0
movq (%rsp), %rdi
callq 0x22e0
jmp 0x4ccd
movq 0x28(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
jmp 0x4d07
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x4c1e
movl $0xfffffffd, 0x34(%rsp) # imm = 0xFFFFFFFD
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/shash.c
// Function: shash_reduce
int
shash_reduce(shash *h, shash_reduce_fn reduce_fn, void *udata)
{
	int rv = 0;
	
	if (h->flags & SHASH_CR_MT_BIGLOCK) {
		pthread_mutex_lock( &h->biglock);
	}

	for (uint i=0; i<h->table_len ; i++) {
		
		pthread_mutex_t *l = 0;
		if (h->flags & SHASH_CR_MT_MANYLOCK) {
			l = &(h->lock_table[i]);
			pthread_mutex_lock( l );
		}
		
		shash_elem *list_he = (shash_elem *) ( ((uint8_t *)h->table) + (SHASH_ELEM_SZ(h) * i));
		while (list_he) {
			
			// not in use is common at head pointer - unused bucket
			if (list_he->in_use == false) {
				if (l) 	pthread_mutex_unlock(l);
				break;
			}
			
			rv = reduce_fn(	SHASH_ELEM_KEY_PTR(h, list_he), SHASH_ELEM_VALUE_PTR(h, list_he), udata);
			if (0 != rv) {
				if (l)  pthread_mutex_unlock(l);
				goto Out;
			}
			
			list_he = list_he->next;
		};

		if (l)	pthread_mutex_unlock(l);

	}
Out:
	if (h->flags & SHASH_CR_MT_BIGLOCK)
		pthread_mutex_unlock(&h->biglock);

	return(rv);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x4f79
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
callq 0x23e0
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x50b0
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x4fcf
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x18(%rsp), %ecx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x23e0
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
movq 0x30(%rsp), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
movl 0x18(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x508c
movq 0x8(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x5031
cmpq $0x0, 0x10(%rsp)
je 0x502f
movq 0x10(%rsp), %rdi
callq 0x21c0
jmp 0x508c
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rdi
addq $0x9, %rdi
movq 0x8(%rsp), %rsi
addq $0x9, %rsi
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq %rcx, %rsi
movq 0x20(%rsp), %rdx
callq *%rax
movl %eax, 0x1c(%rsp)
xorl %eax, %eax
cmpl 0x1c(%rsp), %eax
je 0x507a
cmpq $0x0, 0x10(%rsp)
je 0x5078
movq 0x10(%rsp), %rdi
callq 0x21c0
jmp 0x50b2
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x4fff
cmpq $0x0, 0x10(%rsp)
je 0x509e
movq 0x10(%rsp), %rdi
callq 0x21c0
jmp 0x50a0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x4f81
jmp 0x50b2
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x50d0
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
callq 0x21c0
movl 0x1c(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)