LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_02/wrappers.c
// Function: readn
int readn(int fd, void *buf, size_t count)
{
        int nleft = count, nread;
        char *ptr = buf;

        while (nleft > 0) {
                nread = read(fd, ptr, nleft);
                if (nread < 0) {
                        if (errno != EAGAIN)
                                return -1;
                        nread = 0;
                } else if (nread == 0)
                        break;

                nleft -= nread;
                ptr += nread;
        }

        return count - nleft;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x12d5
movl -0x8(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x1050
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x12ad
callq 0x1030
cmpl $0xb, (%rax)
je 0x12a4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12e3
movl $0x0, -0x20(%rbp)
jmp 0x12b7
cmpl $0x0, -0x20(%rbp)
jne 0x12b5
jmp 0x12d5
jmp 0x12b7
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x1272
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_02/wrappers.c
// Function: writen
int writen(int fd, void *buf, size_t count)
{
        int nleft = count, nwritten;
        char *ptr = buf;

        while (nleft > 0) {
                nwritten = write(fd, ptr, nleft);
                if (nwritten < 0) {
                        if (errno != EAGAIN)
                                return -1;
                        nwritten = 0;
                }

                nleft -= nwritten;
                ptr += nwritten;
        }

        return count - nleft;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x1369
movl -0x8(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x1040
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x134b
callq 0x1030
cmpl $0xb, (%rax)
je 0x1344
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1377
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x1312
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swf2svg.c
// Function: dump_font_to_svg
void dump_font_to_svg(swf_reader *swf,swf_DefineFont *nfo) {
	unsigned int i;
	uint64_t ofs;
	FILE *fp;

	for (i=0;i < nfo->nGlyphs;i++) {
		ofs = (unsigned long long)nfo->absoluteOffsetTable + (unsigned long long)nfo->OffsetTable[i];
		if (swf_reader_seek(swf,ofs) == 0) {
			char tmp[256];

			sprintf(tmp,"swf.font.%u.glyph.%u.svg",nfo->FontID,i);
			fp = fopen(tmp,"w");
			if (fp) do_dump_font_to_svg(swf,fp);
			fclose(fp);
		}
		else {
			fprintf(stderr,"!! Unable to seek to offset (likely reason: non-sequential offsets)\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jae 0x161a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movl -0x14(%rbp), %edx
movzwl (%rcx,%rdx,2), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3fa0
cmpl $0x0, %eax
jne 0x15f2
leaq -0x130(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl (%rax), %edx
movl -0x14(%rbp), %ecx
leaq 0x7c1a(%rip), %rsi      # 0x91cf
movb $0x0, %al
callq 0x1190
leaq -0x130(%rbp), %rdi
leaq 0x7c1e(%rip), %rsi      # 0x91e8
callq 0x1170
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x15e7
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x12a0
movq -0x28(%rbp), %rdi
callq 0x1060
jmp 0x160a
movq 0xb9ff(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x7be7(%rip), %rsi      # 0x91ea
movb $0x0, %al
callq 0x10d0
jmp 0x160c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x155a
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swf2svg.c
// Function: parse_argv
static int parse_argv(int argc,char **argv) {
	int i,swi=0;
	char *a;

	for (i=1;i < argc;) {
		a = argv[i++];

		if (*a == '-') {
			do { a++; } while (*a == '-');

			if (!strcmp(a,"dbg-outline")) {
				outline_only = 1;
			}
			else if (!strcmp(a,"dbg-outline-colormap")) {
				outline_colormap = 1;
			}
			else if (!strcmp(a,"h") || !strcmp(a,"help")) {
				help();
				return 1;
			}
			else {
				fprintf(stderr,"Unknown switch %s\n",a);
				return 1;
			}
		}
		else {
			switch (swi++) {
				case 0:
					swf_file = a;
					break;
				default:
					fprintf(stderr,"Unexpected non-switch %s\n",a);
					return 1;
			}
		}
	}

	if (swf_file == NULL) {
		fprintf(stderr,"You must specify a SWF file to dump\n");
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1a0f
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x19c6
jmp 0x1905
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x1905
movq -0x20(%rbp), %rdi
leaq 0x7968(%rip), %rsi      # 0x9290
callq 0x10c0
cmpl $0x0, %eax
jne 0x1941
movl $0x1, 0xb84c(%rip)      # 0xd188
jmp 0x19c4
movq -0x20(%rbp), %rdi
leaq 0x7950(%rip), %rsi      # 0x929c
callq 0x10c0
cmpl $0x0, %eax
jne 0x1962
movl $0x1, 0xb848(%rip)      # 0xd1a8
jmp 0x19c2
movq -0x20(%rbp), %rdi
leaq 0x7944(%rip), %rsi      # 0x92b1
callq 0x10c0
cmpl $0x0, %eax
je 0x198c
movq -0x20(%rbp), %rdi
leaq 0x7931(%rip), %rsi      # 0x92b3
callq 0x10c0
cmpl $0x0, %eax
jne 0x199d
callq 0x1af0
movl $0x1, -0x4(%rbp)
jmp 0x1a41
movq 0xb654(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x7906(%rip), %rsi      # 0x92b8
movb $0x0, %al
callq 0x10d0
movl $0x1, -0x4(%rbp)
jmp 0x1a41
jmp 0x19c4
jmp 0x1a0a
movl -0x18(%rbp), %eax
movl %eax, %ecx
incl %ecx
movl %ecx, -0x18(%rbp)
testl %eax, %eax
jne 0x19e3
jmp 0x19d6
movq -0x20(%rbp), %rax
movq %rax, 0xb7af(%rip)      # 0xd190
jmp 0x1a08
movq 0xb60e(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x78d3(%rip), %rsi      # 0x92cb
movb $0x0, %al
callq 0x10d0
movl $0x1, -0x4(%rbp)
jmp 0x1a41
jmp 0x1a0a
jmp 0x18cd
cmpq $0x0, 0xb779(%rip)      # 0xd190
jne 0x1a3a
movq 0xb5d8(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x78bb(%rip), %rsi      # 0x92e5
movb $0x0, %al
callq 0x10d0
movl $0x1, -0x4(%rbp)
jmp 0x1a41
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/joncampbell123[P]swfhax/c4_swf2svg.c
// Function: dump_shape_to_svg
static void dump_shape_to_svg(swf_reader *swf,swf_DefineShape *nfo,unsigned int tag_code) {
	FILE *fp;

	{
		char tmp[256];

		sprintf(tmp,"swf.shape.%u.svg",nfo->ShapeId);
		fp = fopen(tmp,"w");
		if (fp == NULL) return;
	}

	if (outline_only)
		do_dump_shape_outline_only(swf,nfo,tag_code,fp);
	else
		do_dump_shape(swf,nfo,tag_code,fp);

	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl (%rax), %edx
leaq 0x7956(%rip), %rsi      # 0x93d1
movb $0x0, %al
callq 0x1190
leaq -0x120(%rbp), %rdi
leaq 0x7758(%rip), %rsi      # 0x91e8
callq 0x1170
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1aa2
jmp 0x1ade
cmpl $0x0, 0xb6df(%rip)      # 0xd188
je 0x1ac1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x1b40
jmp 0x1ad5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x2700
movq -0x20(%rbp), %rdi
callq 0x1060
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/column.c
// Function: tablize
int tablize(char** const array[])
{
    int     status  = 0;

    size_t  x       = 0,
            y       = 0,
        *   length  = NULL;

    regex_t reg;

    y = count_lines(array);
    x = count_cols(array);
    if (regcomp(&reg, ANSI_ESCSEQ, REG_EXTENDED) != 0) {
        status = -1; goto ERR;
    }
    if (count_length(array, x, y, &length, &reg) < 0) {
        status = -2; goto ERR;
    }
    put(array, x, y, length, &reg);
    regfree(&reg);
    free(length);

    return 0;

ERR:
    switch (status) {
        case    -1:
            break;
        case    -2:
            regfree(&reg);
            break;
    }

    return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1300
movq %rax, -0x20(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0xded(%rip), %rsi       # 0x2000
movl $0x1, %edx
callq 0x1090
cmpl $0x0, %eax
je 0x122b
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x1286
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
leaq -0x30(%rbp), %rcx
leaq -0x70(%rbp), %r8
callq 0x1340
cmpl $0x0, %eax
jge 0x1252
movl $0xfffffffe, -0x14(%rbp) # imm = 0xFFFFFFFE
jmp 0x1286
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x70(%rbp), %r8
callq 0x1480
leaq -0x70(%rbp), %rdi
callq 0x1070
movq -0x30(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x12ae
movl -0x14(%rbp), %eax
movl %eax, -0x74(%rbp)
subl $-0x2, %eax
je 0x129f
jmp 0x1293
movl -0x74(%rbp), %eax
subl $-0x1, %eax
jne 0x12a8
jmp 0x129d
jmp 0x12a8
leaq -0x70(%rbp), %rdi
callq 0x1070
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/column.c
// Function: count_lines
static
size_t count_lines(char** const array[])
{
    size_t  y       = 0;

    while (*(array + y) != NULL)
        y++;

    return y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x12ed
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x12d0
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/column.c
// Function: count_cols
static
size_t count_cols(char** const array[])
{
    size_t  x       = 0;

    while (*(*(array) + x) != NULL)
        x++;

    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1330
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1310
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/column.c
// Function: count_length
static
int count_length(char** const array[], size_t x, size_t y, size_t** length, regex_t* reg)
{
    size_t  i       = 0,
            j       = 0,
            len     = 0;

    if ((*length = (size_t*)
                malloc(sizeof(size_t) * x)) == NULL)
        return -1;

    while (i < x) {
        *(*length + i) = j = 0;
        while (j < y && *(*(array + j) + i) != NULL) {
            if ((len = mbstrlen_with_regex(*(*(array + j) + i), reg)) >
                    *(*length + i))
                *(*length + i) = len;
            j++;
        }
        i++;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x10b0
movq -0x28(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0x139a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1468
jmp 0x139c
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1461
movq $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x40(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x49(%rbp)
jae 0x13ef
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x13f8
jmp 0x1450
movq -0x10(%rbp), %rax
movq -0x40(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x30(%rbp), %rsi
callq 0x15d0
cltq
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
movq -0x38(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jbe 0x143f
movq -0x48(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x13c5
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x139c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sasairc[P]yasuna/src/libbenly/src/column.c
// Function: put
static
int put(char** const array[], size_t x, size_t y, size_t* length, regex_t* reg)
{
    size_t  i       = 0,
            j       = 0,
            len     = 0;

    while (i < y) {
        j = 0;
        while (j < x && *(*(array + i) + j) != NULL) {
            fprintf(stdout, "%s",
                    *(*(array + i) + j));
            len = mbstrlen_with_regex(*(*(array + i) + j), reg);
            while (len <= *(length + j) && putchar(' '))
                len++;
            j++;
        }
        putchar('\n');
        i++;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x15bc
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x41(%rbp)
jae 0x14f4
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x1500
jmp 0x15a1
movq 0x2ad9(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0xaed(%rip), %rsi       # 0x2012
movb $0x0, %al
callq 0x10a0
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
callq 0x15d0
cltq
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq -0x38(%rbp), %rsi
xorl %eax, %eax
cmpq (%rdx,%rsi,8), %rcx
movb %al, -0x42(%rbp)
ja 0x1579
movl $0x20, %edi
callq 0x1040
cmpl $0x0, %eax
setne %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x1582
jmp 0x1590
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x154f
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x14ca
movl $0xa, %edi
callq 0x1040
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x14b4
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/misc.c
// Function: fml_opt_init
void fml_opt_init(fml_opt_t *opt)
{
	opt->n_threads = 1;
	opt->ec_k = 0;
	opt->min_cnt = 4;
	opt->max_cnt = 8;
	opt->min_asm_ovlp = 33;
	opt->min_merge_len = 0;
	mag_init_opt(&opt->mag_opt);
	opt->mag_opt.flag = MAG_F_NO_SIMPL | MAG_F_POPOPEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x4, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x8, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x21, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rdi
addq $0x18, %rdi
callq 0x1c460
movq -0x8(%rbp), %rax
movl $0xc0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/misc.c
// Function: fml_opt_adjust
void fml_opt_adjust(fml_opt_t *opt, int n_seqs, const bseq1_t *seqs)
{
	int i, log_len;
	uint64_t tot_len = 0;
	if (opt->n_threads < 1) opt->n_threads = 1;
	for (i = 0; i < n_seqs; ++i) tot_len += seqs[i].l_seq; // compute total length
	for (log_len = 10; log_len < 32; ++log_len) // compute ceil(log2(tot_len))
		if (1ULL<<log_len > tot_len) break;
	if (opt->ec_k == 0) opt->ec_k = (log_len + 12) / 2;
	if (opt->ec_k%2 == 0) ++opt->ec_k;
	opt->mag_opt.min_elen = (int)((double)tot_len / n_seqs * 2.5 + .499);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jge 0x27ca
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x27fe
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq (%rax), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27d1
movl $0xa, -0x20(%rbp)
cmpl $0x20, -0x20(%rbp)
jge 0x282d
movl -0x20(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
cmpq -0x28(%rbp), %rax
jbe 0x2820
jmp 0x282d
jmp 0x2822
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2805
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x284e
movl -0x20(%rbp), %eax
addl $0xc, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x286f
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movaps 0x22aba(%rip), %xmm1    # 0x25330
movq -0x28(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x22ab9(%rip), %xmm1    # 0x25340
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
cvtsi2sdl -0xc(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd 0x22a71(%rip), %xmm1    # 0x25318
mulsd %xmm1, %xmm0
movsd 0x22a6d(%rip), %xmm1    # 0x25320
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/misc.c
// Function: is_rev_same
static inline int is_rev_same(int l, const char *s)
{
	int i;
	if (l&1) return 0;
	for (i = 0; i < l>>1; ++i)
		if (s[i] + s[l-1-i] != 5) break;
	return (i == l>>1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2e1f
movl $0x0, -0x4(%rbp)
jmp 0x2e7d
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x8(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x2e68
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movl -0x8(%rbp), %edx
subl $0x1, %edx
subl -0x14(%rbp), %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
cmpl $0x5, %eax
je 0x2e5b
jmp 0x2e68
jmp 0x2e5d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2e26
movl -0x14(%rbp), %eax
movl -0x8(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/misc.c
// Function: fml_mag_clean
void fml_mag_clean(const fml_opt_t *opt, struct mag_t *g)
{
	magopt_t o = opt->mag_opt;
	o.min_merge_len = opt->min_merge_len;
	mag_g_merge(g, 1, opt->min_merge_len);
	mag_g_clean(g, &o);
	mag_g_trim_open(g, &o);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
leaq -0x48(%rbp), %rdi
movl $0x38, %edx
callq 0x2190
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %edx
movl $0x1, %esi
callq 0x18f70
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1c530
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1ca10
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/misc.c
// Function: fml_utg_print_gfa
void fml_utg_print_gfa(int n, const fml_utg_t *utg)
{
	int i, j;
	FILE *fp = stdout;
	fputs("H\tVN:Z:1.0\n", fp);
	for (i = 0; i < n; ++i) {
		const fml_utg_t *u = &utg[i];
		fprintf(fp, "S\t%d\t", i);
		fputs(u->seq, fp);
		fprintf(fp, "\tLN:i:%d\tRC:i:%d\tPD:Z:", u->len, u->nsr);
		fputs(u->cov, fp);
		fputc('\n', fp);
		for (j = 0; j < u->n_ovlp[0] + u->n_ovlp[1]; ++j) {
			fml_ovlp_t *o = &u->ovlp[j];
			if (i < o->id)
				fprintf(fp, "L\t%d\t%c\t%d\t%c\t%dM\n", i, "+-"[!o->from], o->id, "+-"[o->to], o->len);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x263da(%rip), %rax     # 0x29fc0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x217a7(%rip), %rdi     # 0x2539f
callq 0x2100
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3d75
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x2177a(%rip), %rsi     # 0x253ab
movb $0x0, %al
callq 0x2170
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x2100
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %edx
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x21750(%rip), %rsi     # 0x253b1
movb $0x0, %al
callq 0x2170
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x2100
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x2130
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x28(%rbp), %rcx
movl 0x18(%rcx), %ecx
movq -0x28(%rbp), %rdx
addl 0x1c(%rdx), %ecx
cmpl %ecx, %eax
jge 0x3d65
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
shrq $0x20, %rcx
andq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jge 0x3d55
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x1f, %rax
andq $0x1, %rax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
leaq 0x216d7(%rip), %rax     # 0x253db
movsbl (%rax,%rcx), %ecx
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x20, %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movl %eax, %r8d
movq -0x30(%rbp), %rax
movq (%rax), %rax
shrq $0x3f, %rax
movl %eax, %eax
movl %eax, %esi
leaq 0x216a9(%rip), %rax     # 0x253db
movsbl (%rax,%rsi), %r9d
movq -0x30(%rbp), %rax
movq (%rax), %rax
andq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
leaq 0x2167d(%rip), %rsi     # 0x253c8
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2170
jmp 0x3d57
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3c8e
jmp 0x3d67
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3c04
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/misc.c
// Function: fml_utg_destroy
void fml_utg_destroy(int n, fml_utg_t *utg)
{
	int i;
	for (i = 0; i < n; ++i) {
		free(utg[i].seq);
		free(utg[i].cov);
		free(utg[i].ovlp);
	}
	free(utg);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3df1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x2040
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d96
movq -0x10(%rbp), %rdi
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/misc.c
// Function: fml_assemble
fml_utg_t *fml_assemble(const fml_opt_t *opt0, int n_seqs, bseq1_t *seqs, int *n_utg)
{
	rld_t *e;
	mag_t *g;
	fml_utg_t *utg;
	fml_opt_t opt = *opt0;
	float kcov;

	*n_utg = 0;
	fml_opt_adjust(&opt, n_seqs, seqs);
	if (opt.ec_k >= 0) fml_correct(&opt, n_seqs, seqs);
	kcov = fml_fltuniq(&opt, n_seqs, seqs);
	e = fml_seq2fmi(&opt, n_seqs, seqs);
	if (e == 0) return 0; // this may happen when all sequences are filtered out
	g = fml_fmi2mag(&opt, e);
	opt.mag_opt.min_ensr = opt.mag_opt.min_ensr > kcov * MAG_MIN_NSR_COEF? opt.mag_opt.min_ensr : (int)(kcov * MAG_MIN_NSR_COEF + .499);
	opt.mag_opt.min_ensr = opt.mag_opt.min_ensr < opt0->max_cnt? opt.mag_opt.min_ensr : opt0->max_cnt;
	opt.mag_opt.min_ensr = opt.mag_opt.min_ensr > opt0->min_cnt? opt.mag_opt.min_ensr : opt0->min_cnt;
	opt.mag_opt.min_insr = opt.mag_opt.min_ensr - 1;
	fml_mag_clean(&opt, g);
	utg = fml_mag2utg(g, n_utg);
	return utg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
movl $0x50, %edx
callq 0x2190
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x27a0
cmpl $0x0, -0x8c(%rbp)
jl 0x3e68
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x8f90
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x8fc0
movss %xmm0, -0x94(%rbp)
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0x90(%rbp), %rdi
callq 0x2fe0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x3eae
movq $0x0, -0x8(%rbp)
jmp 0x3fb3
movq -0x30(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x115e0
movq %rax, -0x38(%rbp)
cvtsi2sdl -0x6c(%rbp), %xmm0
movss -0x94(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movsd 0x2144d(%rip), %xmm2    # 0x25328
mulsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3ef0
movl -0x6c(%rbp), %eax
movl %eax, -0x98(%rbp)
jmp 0x3f1e
movss -0x94(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x21424(%rip), %xmm1    # 0x25328
mulsd %xmm1, %xmm0
movsd 0x21410(%rip), %xmm1    # 0x25320
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x98(%rbp)
movl -0x98(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x3f3e
movl -0x6c(%rbp), %eax
movl %eax, -0x9c(%rbp)
jmp 0x3f4b
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x3f6b
movl -0x6c(%rbp), %eax
movl %eax, -0xa0(%rbp)
jmp 0x3f78
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xa0(%rbp)
movl -0xa0(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x68(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x3040
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x30d0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/bseq.c
// Function: bseq_read
bseq1_t *bseq_read(const char *fn, int *n_)
{
	gzFile fp;
	bseq1_t *seqs;
	kseq_t *ks;
	int m, n;
	uint64_t size = 0;

	*n_ = 0;
	fp = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
	if (fp == 0) return 0;
	ks = kseq_init(fp);

	m = n = 0; seqs = 0;
	while (kseq_read(ks) >= 0) {
		bseq1_t *s;
		if (n >= m) {
			m = m? m<<1 : 256;
			seqs = realloc(seqs, m * sizeof(bseq1_t));
		}
		s = &seqs[n];
		s->seq = strdup(ks->seq.s);
		s->qual = ks->qual.l? strdup(ks->qual.s) : 0;
		s->l_seq = ks->seq.l;
		size += seqs[n++].l_seq;
	}
	*n_ = n;

	kseq_destroy(ks);
	gzclose(fp);
	return seqs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x4014
movq -0x10(%rbp), %rdi
leaq 0x213e8(%rip), %rsi     # 0x253dc
callq 0x2150
cmpl $0x0, %eax
je 0x4014
movq -0x10(%rbp), %rdi
leaq 0x213d5(%rip), %rsi     # 0x253de
callq 0x2230
movq %rax, -0x50(%rbp)
jmp 0x4035
movq 0x25fad(%rip), %rax     # 0x29fc8
movq (%rax), %rdi
callq 0x21a0
movl %eax, %edi
leaq 0x213b2(%rip), %rsi     # 0x253de
callq 0x2090
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4051
movq $0x0, -0x8(%rbp)
jmp 0x417c
movq -0x20(%rbp), %rdi
callq 0x4190
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x41d0
cmpl $0x0, %eax
jl 0x4159
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jl 0x40c3
cmpl $0x0, -0x34(%rbp)
je 0x409e
movl -0x34(%rbp), %eax
shll %eax
movl %eax, -0x54(%rbp)
jmp 0x40a8
movl $0x100, %eax            # imm = 0x100
movl %eax, -0x54(%rbp)
jmp 0x40a8
movl -0x54(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x34(%rbp), %rax
imulq $0x18, %rax, %rsi
callq 0x21e0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x22a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x410c
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x22a0
movq %rax, -0x60(%rbp)
jmp 0x4114
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0x4114
movq -0x60(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rax
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x38(%rbp)
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq (%rax), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x4074
movl -0x38(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rdi
callq 0x45b0
movq -0x20(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/bseq.c
// Function: seq_reverse
void seq_reverse(int l, unsigned char *s)
{
	int i;
	for (i = 0; i < l>>1; ++i) {
		int tmp = s[l-1-i];
		s[l-1-i] = s[i]; s[i] = tmp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x468e
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4632
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/bseq.c
// Function: seq_revcomp6
void seq_revcomp6(int l, unsigned char *s)
{
	int i;
	for (i = 0; i < l>>1; ++i) {
		int tmp = s[l-1-i];
		tmp = (tmp >= 1 && tmp <= 4)? 5 - tmp : tmp;
		s[l-1-i] = (s[i] >= 1 && s[i] <= 4)? 5 - s[i] : s[i];
		s[i] = tmp;
	}
	if (l&1) s[i] = (s[i] >= 1 && s[i] <= 4)? 5 - s[i] : s[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
sarl %ecx
cmpl %ecx, %eax
jge 0x476d
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
jl 0x46e2
cmpl $0x4, -0x18(%rbp)
jg 0x46e2
movl $0x5, %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x46e8
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jl 0x4728
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x4, %eax
jg 0x4728
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movl $0x5, %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
jmp 0x4737
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x46a2
movl -0x4(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x47d1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x1, %eax
jl 0x47b2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x4, %eax
jg 0x47b2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
movl $0x5, %eax
subl %ecx, %eax
movl %eax, -0x24(%rbp)
jmp 0x47c1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/bfc.c
// Function: bfc_opt_init
void bfc_opt_init(bfc_opt_t *opt)
{
	memset(opt, 0, sizeof(bfc_opt_t));
	opt->n_threads = 1;
	opt->q = 20;
	opt->k = -1;
	opt->l_pre = -1;

	opt->min_cov = 4; // in BFC, this defaults to 3 because it has Bloom pre-filter
	opt->win_multi_ec = 10;
	opt->max_end_ext = 5;
	opt->min_trim_frac = .8;

	opt->w_ec = 1;
	opt->w_ec_high = 7;
	opt->w_absent = 3;
	opt->w_absent_high = 1;
	opt->max_path_diff = 15;
	opt->max_heap = 100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x2110
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movl $0x14, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl $0x4, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0xa, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x14(%rax)
movq -0x8(%rbp), %rax
movss 0x2053c(%rip), %xmm0    # 0x253e0
movss %xmm0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x7, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0xf, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x64, 0x34(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/bfc.c
// Function: fml_count
struct bfc_ch_s *fml_count(int n, const bseq1_t *seq, int k, int q, int l_pre, int n_threads)
{
	int i;
	cnt_step_t cs;
	cs.n_seqs = n, cs.seqs = seq, cs.k = k, cs.q = q;
	cs.ch = bfc_ch_init(cs.k, l_pre);
	cs.n_buf = calloc(n_threads, sizeof(int));
	cs.buf = calloc(n_threads, sizeof(void*));
	for (i = 0; i < n_threads; ++i)
		cs.buf[i] = malloc(CNT_BUF_SIZE * sizeof(insbuf_t));
	kt_for(n_threads, worker_count, &cs, cs.n_seqs);
	for (i = 0; i < n_threads; ++i) free(cs.buf[i]);
	free(cs.buf); free(cs.n_buf);
	return cs.ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x58(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x21160
movq %rax, -0x40(%rbp)
movslq -0x20(%rbp), %rdi
movl $0x4, %esi
callq 0x2140
movq %rax, -0x38(%rbp)
movslq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x2140
movq %rax, -0x30(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4f9d
movl $0x1800, %edi           # imm = 0x1800
callq 0x21c0
movq %rax, %rdx
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4f71
movl -0x20(%rbp), %edi
movslq -0x50(%rbp), %rcx
leaq 0x55(%rip), %rsi        # 0x5000
leaq -0x58(%rbp), %rdx
callq 0x20e50
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x4fdf
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2040
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4fbb
movq -0x30(%rbp), %rdi
callq 0x2040
movq -0x38(%rbp), %rdi
callq 0x2040
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/bfc.c
// Function: worker_count
static void worker_count(void *_data, long k, int tid)
{
	cnt_step_t *cs = (cnt_step_t*)_data;
	const bseq1_t *s = &cs->seqs[k];
	int i, l;
	bfc_kmer_t x = bfc_kmer_null;
	uint64_t qmer = 0, mask = (1ULL<<cs->k) - 1;
	for (i = l = 0; i < s->l_seq; ++i) {
		int c = seq_nt6_table[(uint8_t)s->seq[i]] - 1;
		if (c < 4) {
			bfc_kmer_append(cs->k, x.x, c);
			qmer = (qmer<<1 | (s->qual == 0 || s->qual[i] - 33 >= cs->q)) & mask;
			if (++l >= cs->k) bfc_kmer_insert(cs, &x, (qmer == mask), tid);
		} else l = 0, qmer = 0, x = bfc_kmer_null;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x2528a(%rip), %rax     # 0x2a2c0
movq %rax, -0x50(%rbp)
movq 0x25287(%rip), %rax     # 0x2a2c8
movq %rax, -0x48(%rbp)
movq 0x25284(%rip), %rax     # 0x2a2d0
movq %rax, -0x40(%rbp)
movq 0x25281(%rip), %rax     # 0x2a2d8
movq %rax, -0x38(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x51ab
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x250cf(%rip), %rax     # 0x2a180
movzbl (%rax,%rcx), %eax
subl $0x1, %eax
movl %eax, -0x64(%rbp)
cmpl $0x4, -0x64(%rbp)
jge 0x5160
movq -0x20(%rbp), %rax
movl (%rax), %edi
leaq -0x50(%rbp), %rsi
movl -0x64(%rbp), %edx
callq 0x5550
movq -0x58(%rbp), %rax
shlq %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rcx
movb $0x1, %al
cmpq $0x0, 0x10(%rcx)
movb %al, -0x65(%rbp)
je 0x5112
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x21, %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
setge %al
movb %al, -0x65(%rbp)
movq -0x70(%rbp), %rax
movb -0x65(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
andq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x515e
movq -0x20(%rbp), %rdi
movq -0x58(%rbp), %rax
cmpq -0x60(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %edx
movl -0x14(%rbp), %ecx
leaq -0x50(%rbp), %rsi
callq 0x8ff0
jmp 0x519b
movl $0x0, -0x30(%rbp)
movq $0x0, -0x58(%rbp)
movq 0x2514a(%rip), %rax     # 0x2a2c0
movq %rax, -0x50(%rbp)
movq 0x25147(%rip), %rax     # 0x2a2c8
movq %rax, -0x48(%rbp)
movq 0x25144(%rip), %rax     # 0x2a2d0
movq %rax, -0x40(%rbp)
movq 0x25141(%rip), %rax     # 0x2a2d8
movq %rax, -0x38(%rbp)
jmp 0x519d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5089
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/bfc.c
// Function: bfc_ec_greedy_k
int bfc_ec_greedy_k(int k, int mode, const bfc_kmer_t *x, const bfc_ch_t *ch)
{
	int i, j, max = 0, max_ec = -1, max2 = 0;
	for (i = 0; i < k; ++i) {
		int c = (x->x[1]>>i&1)<<1 | (x->x[0]>>i&1);
		for (j = 0; j < 4; ++j) {
			bfc_kmer_t y = *x;
			int ret;
			if (j == c) continue;
			bfc_kmer_change(k, y.x, i, j);
			ret = bfc_ch_kmer_occ(ch, &y);
			if (ret < 0) continue;
			if ((max&0xff) < (ret&0xff)) max2 = max, max = ret, max_ec = i<<2 | j;
			else if ((max2&0xff) < (ret&0xff)) max2 = ret;
		}
	}
	return (max&0xff) * 3 > mode && (max2&0xff) < 3? max_ec : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0xffffffff, -0x28(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x5301
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
shrq %cl, %rax
andq $0x1, %rax
shlq %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movl -0x1c(%rbp), %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0x1, %rcx
orq %rcx, %rax
movl %eax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x52f1
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x48(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x40(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x526b
jmp 0x52e3
movl -0x4(%rbp), %edi
leaq -0x50(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x5340
movq -0x18(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x21b20
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jge 0x5295
jmp 0x52e3
movl -0x24(%rbp), %eax
andl $0xff, %eax
movl -0x54(%rbp), %ecx
andl $0xff, %ecx
cmpl %ecx, %eax
jge 0x52c4
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
shll $0x2, %eax
orl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x52e1
movl -0x2c(%rbp), %eax
andl $0xff, %eax
movl -0x54(%rbp), %ecx
andl $0xff, %ecx
cmpl %ecx, %eax
jge 0x52df
movl -0x54(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x52e1
jmp 0x52e3
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5234
jmp 0x52f3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x51f2
movl -0x24(%rbp), %eax
andl $0xff, %eax
imull $0x3, %eax, %eax
cmpl -0x8(%rbp), %eax
jle 0x5326
movl -0x2c(%rbp), %eax
andl $0xff, %eax
cmpl $0x3, %eax
jge 0x5326
movl -0x28(%rbp), %eax
movl %eax, -0x58(%rbp)
jmp 0x5330
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x58(%rbp)
jmp 0x5330
movl -0x58(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/./kmer.h
// Function: bfc_kmer_change
static inline void bfc_kmer_change(int k, uint64_t x[4], int d, int c) // d-bp from the 3'-end of k-mer; 0<=d<k
{ // IMPORTANT: 0 <= c < 4
	uint64_t t = ~(1ULL<<d);
	x[0] = (uint64_t) (c&1)<<d | (x[0]&t);
	x[1] = (uint64_t)(c>>1)<<d | (x[1]&t);
	t = ~(1ULL<<(k-1-d));
	x[2] = (uint64_t)(1^(c&1))<<(k-1-d) | (x[2]&t);
	x[3] = (uint64_t)(1^ c>>1)<<(k-1-d) | (x[3]&t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
cltq
movl -0x14(%rbp), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
andq -0x20(%rbp), %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %eax
sarl %eax
cltq
movl -0x14(%rbp), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
andq -0x20(%rbp), %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x4(%rbp), %eax
subl $0x1, %eax
subl -0x14(%rbp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
xorq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
xorl $0x1, %eax
cltq
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
andq -0x20(%rbp), %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x18(%rbp), %eax
sarl %eax
xorl $0x1, %eax
cltq
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
subl -0x14(%rbp), %ecx
movl %ecx, %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
andq -0x20(%rbp), %rax
orq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]fermi-lite/bfc.c
// Function: bfc_ec_first_kmer
int bfc_ec_first_kmer(int k, const ecseq_t *s, int start, bfc_kmer_t *x)
{
	int i, l;
	*x = bfc_kmer_null;
	for (i = start, l = 0; i < s->n; ++i) {
		ecbase_t *c = &s->a[i];
		if (c->b < 4) {
			bfc_kmer_append(k, x->x, c->b);
			if (++l == k) break;
		} else l = 0, *x = bfc_kmer_null;
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x24e5f(%rip), %rcx     # 0x2a2c0
movq %rcx, (%rax)
movq 0x24e5d(%rip), %rcx     # 0x2a2c8
movq %rcx, 0x8(%rax)
movq 0x24e5a(%rip), %rcx     # 0x2a2d0
movq %rcx, 0x10(%rax)
movq 0x24e57(%rip), %rcx     # 0x2a2d8
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movslq -0x24(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x5539
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movb (%rax), %al
andb $0x7, %al
movzbl %al, %eax
cmpl $0x4, %eax
jge 0x54f3
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movb (%rax), %al
andb $0x7, %al
movzbl %al, %edx
callq 0x5550
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
cmpl -0x4(%rbp), %eax
jne 0x54f1
jmp 0x5539
jmp 0x5529
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x24dbb(%rip), %rcx     # 0x2a2c0
movq %rcx, (%rax)
movq 0x24db9(%rip), %rcx     # 0x2a2c8
movq %rcx, 0x8(%rax)
movq 0x24db6(%rip), %rcx     # 0x2a2d0
movq %rcx, 0x10(%rax)
movq 0x24db3(%rip), %rcx     # 0x2a2d8
movq %rcx, 0x18(%rax)
jmp 0x552b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5492
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)