LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::check_parent_selection()
void check_parent_selection(){
		if (current_path.has_parent_path())
		{
			auto parent_dir = left_col;
			auto dir_name = current_path.filename();
			auto it = std::find_if(parent_dir.begin(), parent_dir.end(),
								   [&](std::filesystem::directory_entry &dir) {
									   return dir.path().filename() == dir_name;
								   });
			if (it != parent_dir.end())
			{
				update_parent_selection(*it);
			}
			else
			{
				//This case should not happen but whooo knows...
				parent_selection.clear();	
			}
		}
		else
		{
			parent_selection.clear();
		}
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x3100
testb %al, %al
je 0x6cb8
leaq 0x78(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6116
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x6d50
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x7290
cmpq 0x10(%rsp), %rax
je 0x6ccb
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x6276
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x7268
leaq 0x48(%rsp), %rdi
callq 0x62f4
jmp 0x6cd7
addq $0x48, %rbx
movq %rbx, %rdi
addq $0x78, %rsp
popq %rbx
popq %r14
jmp 0x69e6
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x69e6
leaq 0x20(%rsp), %rdi
callq 0x62f4
leaq 0x8(%rsp), %rdi
callq 0x5070
addq $0x78, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x62f4
jmp 0x6d0a
movq %rax, %rbx
jmp 0x6d14
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x62f4
leaq 0x8(%rsp), %rdi
callq 0x5070
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/juli9797[P]ssf/src/console_page.hpp
// Function: ssf::ConsolePage::find_pos(std::vector<std::filesystem::__cxx11::directory_entry, std::allocator<std::filesystem::__cxx11::directory_entry>> const&, std::filesystem::__cxx11::directory_entry) const
auto find_pos(const std::vector<std::filesystem::directory_entry> &dl, std::filesystem::directory_entry de) const
        -> std::size_t
    {
        auto it = std::find(dl.begin(), dl.end(), de);
        auto dist = 0;
        dist = std::distance(dl.begin(), it);
        return dist;
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x78f9
subq (%rbx), %rax
pushq $0x30
popq %rcx
cqto
idivq %rcx
cltq
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/juli9797[P]ssf/src/command_line.hpp
// Function: ssf::CommandLine::str[abi:cxx11]() const
std::string str() const
    {
        std::ostringstream p;
        p << c_cmd::set_cursor(_row, 0)
          << c_cmd::clear_line
          << _text;
        return p.str();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0x32c0
movl (%r14), %esi
movq %rsp, %rdi
xorl %edx, %edx
callq 0x37fc
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x31e0
leaq 0x1840(%rip), %rsi      # 0x92cd
movq %rax, %rdi
callq 0x3210
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x31e0
movq %rsp, %rdi
callq 0x30f0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x3370
leaq 0x20(%rsp), %rdi
callq 0x3040
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
retq
jmp 0x7ad3
movq %rax, %rbx
jmp 0x7ae3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30f0
leaq 0x20(%rsp), %rdi
callq 0x3040
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::move_down()
void move_down()
	{
		//iterate down
		if(!selection.empty()){
			auto de = *selection.begin();
			auto it = find_element(active_col,de);
			if(++it != active_col.end()){
				update_selection(*(it));
		       	}
		}
		update();
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
cmpq 0x38(%rdi), %rsi
je 0x8343
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x6276
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x6276
leaq 0x90(%rbx), %rsi
leaq 0x38(%rsp), %rdx
movq %rbx, %rdi
callq 0x6fce
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x62f4
addq $0x30, %r14
cmpq 0x98(%rbx), %r14
je 0x8339
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6276
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6fda
leaq 0x8(%rsp), %rdi
callq 0x62f4
leaq 0x68(%rsp), %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x67d2
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x8368
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x62f4
jmp 0x8372
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::move_up()
void move_up()
	{
		//iterate up
		if(!selection.empty()){
			auto it = find_element(active_col,*selection.begin());
			if(it != active_col.begin()){
				update_selection(*(--it));	
			}
		}	
		update();
			
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
cmpq 0x38(%rdi), %rsi
je 0x83f9
leaq 0x90(%rbx), %r15
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x6276
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6fce
movq %rax, %r12
leaq 0x38(%rsp), %rdi
callq 0x62f4
cmpq (%r15), %r12
je 0x83f9
addq $-0x30, %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x6276
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6fda
leaq 0x8(%rsp), %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x67d2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x840f
movq %rax, %rbx
movq %r14, %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::move_left()
void move_left()
	{

		if (current_path.has_parent_path() &&
			current_path != current_path.root_path())
		{
			current_path = current_path.parent_path();
			if(!parent_selection.empty()){
				update_selection(parent_selection.at(0));
			}
		}
		update();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x3100
testb %al, %al
je 0x84c6
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x32f0
movq %r14, %rdi
movq %r15, %rsi
callq 0x84ec
movl %eax, %ebp
movq %r15, %rdi
callq 0x62f4
testb %bpl, %bpl
je 0x84c6
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3420
movq %r14, %rdi
movq %r15, %rsi
callq 0x679a
movq %r15, %rdi
callq 0x62f4
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
je 0x84c6
leaq 0x48(%rbx), %rdi
xorl %esi, %esi
callq 0x639c
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x6276
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6fda
movq %rsp, %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x67d2
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::move_right()
void move_right()
	{
		try
		{
			if(!selection.empty())
			{
				auto selected = *selection.begin();
				if (selected.is_directory())
				{
					//THIS IS A DIRTY HACK AND SHOULD BE DONE PROPERLY ASAP
					auto probePerm = get_directory_list(selected.path()); //probe if filesystem throws permission error

					current_path = selected.path();
					if(!probePerm.empty()){
						update_selection(*(probePerm.begin()));
					}
				
				}
				else if (selected.is_regular_file() || selected.is_character_file())
				{
					try
					{
						move_right_on_file();
					}
					catch (std::bad_function_call &e)
					{
					}
				}
			}
		}
		catch (std::filesystem::filesystem_error &e)
		{
		}
		update();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
cmpq 0x38(%rdi), %rsi
je 0x85ca
leaq 0x18(%rsp), %rdi
callq 0x6276
leaq 0x18(%rsp), %rdi
callq 0x6d26
testb %al, %al
je 0x8598
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6294
movq %rsp, %rdi
leaq 0x48(%rsp), %rdx
movq %rbx, %rsi
callq 0x69ee
leaq 0x48(%rsp), %rdi
callq 0x62f4
leaq 0x8(%rbx), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3330
movq (%rsp), %rsi
cmpq 0x8(%rsp), %rsi
je 0x858e
leaq 0x70(%rsp), %rdi
callq 0x6276
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x6fda
leaq 0x70(%rsp), %rdi
callq 0x62f4
movq %rsp, %rdi
callq 0x5070
jmp 0x85c0
leaq 0x18(%rsp), %rdi
callq 0x866a
testb %al, %al
jne 0x85b4
leaq 0x18(%rsp), %rdi
callq 0x8678
testb %al, %al
je 0x85c0
leaq 0xc0(%rbx), %rdi
callq 0x7848
leaq 0x18(%rsp), %rdi
callq 0x62f4
movq %rbx, %rdi
callq 0x67d2
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x62f4
jmp 0x8616
jmp 0x8610
movq %rdx, %r15
movq %rax, %r14
cmpl $0x2, %r15d
jne 0x8642
movq %r14, %rdi
callq 0x30c0
callq 0x3390
jmp 0x85c0
jmp 0x863c
movq %rdx, %r15
movq %rax, %r14
movq %rsp, %rdi
callq 0x5070
jmp 0x8642
movq %rdx, %r15
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x62f4
jmp 0x8642
jmp 0x863c
movq %rdx, %r15
movq %rax, %r14
jmp 0x864c
movq %rdx, %r15
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x62f4
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x8664
callq 0x30c0
callq 0x3390
jmp 0x85ca
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/CommandLines.cpp
// Function: destory_enzyme(enzyme*)
void destory_enzyme(enzyme* f)
{
    int i;
    if(f != NULL)
    {
        for (i = 0; i < f->n; i++)
        {
            free(f->a[i]);
        }
        free(f->a);
        free(f->l);
        free(f);
    }
}

// Assembly:
testq %rdi, %rdi
je 0x33cf
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
cmpq %rax, %r14
jge 0x33b3
movq (%rdi,%r14,8), %rdi
callq 0x2220
incq %r14
jmp 0x3398
callq 0x2220
movq (%rbx), %rdi
callq 0x2220
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/CommandLines.cpp
// Function: destory_opt(hifiasm_opt_t*)
void destory_opt(hifiasm_opt_t* asm_opt)
{
    if(asm_opt->read_file_names != NULL) free(asm_opt->read_file_names);
    if(asm_opt->hic_enzymes != NULL) destory_enzyme(asm_opt->hic_enzymes);
    if(asm_opt->hic_reads[0] != NULL) destory_enzyme(asm_opt->hic_reads[0]);
    if(asm_opt->hic_reads[1] != NULL) destory_enzyme(asm_opt->hic_reads[1]);
    if(asm_opt->ar != NULL) destory_enzyme(asm_opt->ar);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2220
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x33eb
callq 0x3389
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x33f9
callq 0x3389
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x3407
callq 0x3389
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x3416
popq %rbx
jmp 0x3389
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/CommandLines.cpp
// Function: ha_opt_update_cov(hifiasm_opt_t*, int)
void ha_opt_update_cov(hifiasm_opt_t *opt, int hom_cov)
{
	int max_n_chain = (int)(hom_cov * opt->high_factor + .499);
	opt->hom_cov = hom_cov;
	if (opt->max_n_chain < max_n_chain)
		opt->max_n_chain = max_n_chain;
	fprintf(stderr, "[M::%s] updated max_n_chain to %d\n", __func__, opt->max_n_chain);
}

// Assembly:
cvtsi2sd %esi, %xmm0
mulsd 0xb8(%rdi), %xmm0
addsd 0x1dcbcc(%rip), %xmm0   # 0x1e0010
cvttsd2si %xmm0, %eax
movl %esi, 0xd0(%rdi)
movl 0xe8(%rdi), %ecx
cmpl %eax, %ecx
jge 0x3460
movl %eax, 0xe8(%rdi)
movl %eax, %ecx
movq 0x24fb79(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0x1de568(%rip), %rsi    # 0x1e19d9
leaq 0x1de584(%rip), %rdx    # 0x1e19fc
xorl %eax, %eax
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/CommandLines.cpp
// Function: ha_opt_update_cov_min(hifiasm_opt_t*, int, int)
void ha_opt_update_cov_min(hifiasm_opt_t *opt, int hom_cov, int min_chain)
{
	int max_n_chain = (int)(hom_cov * opt->high_factor + .499);
	opt->hom_cov = hom_cov; opt->max_n_chain = max_n_chain;
    if(opt->max_n_chain < min_chain) opt->max_n_chain = min_chain;
	fprintf(stderr, "[M::%s] updated max_n_chain to %d\n", __func__, opt->max_n_chain);
}

// Assembly:
cvtsi2sd %esi, %xmm0
mulsd 0xb8(%rdi), %xmm0
addsd 0x1dcb7d(%rip), %xmm0   # 0x1e0010
cvttsd2si %xmm0, %ecx
movl %esi, 0xd0(%rdi)
cmpl %edx, %ecx
cmovlel %edx, %ecx
movl %ecx, 0xe8(%rdi)
movq 0x24fb31(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0x1de520(%rip), %rsi    # 0x1e19d9
leaq 0x1de54e(%rip), %rdx    # 0x1e1a0e
xorl %eax, %eax
jmp 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/CommandLines.cpp
// Function: check_file(char*, char const*)
static int check_file(char* name, const char* opt)
{
    if(!name)
    {
        fprintf(stderr, "[ERROR] file does not exist (-%s)\n", opt);
        return 0;
    } 
    FILE* is_exist = NULL;
    is_exist = fopen(name,"r");
    if(!is_exist)
    {
        fprintf(stderr, "[ERROR] %s does not exist (-%s)\n", name, opt);
        return 0;
    } 

    fclose(is_exist);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x3dc5
movq %rdi, %r14
leaq 0x1ed90e(%rip), %rsi    # 0x1f16b7
callq 0x2210
testq %rax, %rax
je 0x3de4
movq %rax, %rdi
callq 0x2190
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x24f214(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0x1de52c(%rip), %rsi    # 0x1e2302
xorl %ebp, %ebp
movq %rbx, %rdx
xorl %eax, %eax
callq 0x22b0
jmp 0x3dbe
movq 0x24f1f5(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
leaq 0x1de530(%rip), %rsi    # 0x1e2325
xorl %ebp, %ebp
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x22b0
jmp 0x3dbe
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/CommandLines.cpp
// Function: check_hic_reads(enzyme*, char const*)
static int check_hic_reads(enzyme* f, const char* opt)
{
    int32_t i;
    for (i = 0; i < f->n; i++) {
        if(check_file(f->a[i], opt) == 0) return 0;
    }
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
pushq $0x1
popq %rbx
movslq 0x8(%r15), %rax
cmpq %rax, %r12
jge 0x3e3c
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x3d93
incq %r12
testl %eax, %eax
jne 0x3e1a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/CommandLines.cpp
// Function: get_queries(int, char**, ketopt_t*, hifiasm_opt_t*)
void get_queries(int argc, char *argv[], ketopt_t* opt, hifiasm_opt_t* asm_opt)
{
    if(opt->ind == argc) {
        return;
    }

    asm_opt->num_reads = argc - opt->ind;
    asm_opt->read_file_names = (char**)malloc(sizeof(char*)*asm_opt->num_reads);
    
    long long i; int ret;
    gzFile dfp; kseq_t *ks = NULL;
    for (i = 0; i < asm_opt->num_reads; i++) {
        asm_opt->read_file_names[i] = argv[i + opt->ind];
        dfp = gzopen(asm_opt->read_file_names[i], "r");
        if (dfp == 0) {
            fprintf(stderr, "[ERROR] Cannot find the input read file: %s\n", 
                    asm_opt->read_file_names[i]);
		    exit(0);
        } else if(asm_opt->is_sc){
            ks = kseq_init(dfp);
            while (((ret = kseq_read(ks)) >= 0)) {
                if((ks->qual.l == 0) || (ks->qual.s == NULL)) {
                    fprintf(stderr, "[ERROR] %s is in fasta format rather than fastq format\n", asm_opt->read_file_names[i]);
                    asm_opt->is_sc = 0;
                    exit(0);
                }
                break;
            }
            kseq_destroy(ks); ks = NULL;
        }
        gzclose(dfp);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
subl (%rdx), %ebp
jne 0x3e6a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %ebp, 0x4(%rcx)
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0x2280
movq %rax, 0x8(%rbx)
xorl %r12d, %r12d
movslq %ebp, %rax
cmpq %rax, %r12
jge 0x3e5b
movslq (%r14), %rax
leaq (%r15,%rax,8), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%r12,8)
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
leaq 0x1ed804(%rip), %rsi    # 0x1f16b7
callq 0x22d0
testq %rax, %rax
je 0x3f07
movq %rax, %r13
cmpq $0x0, 0x2b0(%rbx)
je 0x3ef7
movq %r13, %rdi
callq 0x3f58
movq %rax, %rbp
movq %rax, %rdi
callq 0x3f9e
testl %eax, %eax
js 0x3eef
cmpq $0x0, 0x48(%rbp)
je 0x3f29
cmpq $0x0, 0x58(%rbp)
je 0x3f29
movq %rbp, %rdi
callq 0x4191
movq %r13, %rdi
callq 0x2390
incq %r12
movl 0x4(%rbx), %ebp
jmp 0x3e89
movq 0x24f0d2(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdx
leaq 0x1de2e8(%rip), %rsi    # 0x1e2208
xorl %eax, %eax
callq 0x22b0
jmp 0x3f51
movq 0x24f0b0(%rip), %rax    # 0x252fe0
movq (%rax), %rdi
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdx
leaq 0x1de2f3(%rip), %rsi    # 0x1e2235
xorl %eax, %eax
callq 0x22b0
andq $0x0, 0x2b0(%rbx)
xorl %edi, %edi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/CommandLines.cpp
// Function: inter_gsize(char*)
int64_t inter_gsize(char *argv)
{
    int64_t len = strlen(argv);
    double s;
    if(len <= 1) return -2;
    char t = argv[len-1];
    if(t != 'k' && t != 'K' && t != 'm' && t != 'M' && t != 'g' && t != 'G') return -2;
    char *ss=(char*)malloc(len);
    memcpy(ss, argv, len-1); ss[len-1] = '\0';
    s = atof(ss);
    free(ss);
    if(t == 'k' || t == 'K') return s*1000;
    if(t == 'm' || t == 'M') return s*1000000;
    if(t == 'g' || t == 'G') return s*1000000000;
    return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x2090
movq %rax, %r14
pushq $-0x2
popq %rax
cmpq $0x2, %r14
jl 0x4479
movzbl -0x1(%rbx,%r14), %r13d
leal -0x47(%r13), %ecx
cmpl $0x26, %ecx
ja 0x4479
movabsq $0x5100000051, %rdx     # imm = 0x5100000051
btq %rcx, %rdx
jae 0x4479
movq %r14, %r15
decq %r15
movq %r14, %rdi
callq 0x2280
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2160
movb $0x0, -0x1(%r12,%r14)
movq %r12, %rdi
callq 0x2260
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0x2220
andl $0x4f, %r13d
cmpl $0x47, %r13d
je 0x4466
cmpl $0x4d, %r13d
je 0x4456
cmpl $0x4b, %r13d
movsd 0x8(%rsp), %xmm0
jne 0x4474
mulsd 0x1dbbd4(%rip), %xmm0   # 0x1e0028
jmp 0x4474
movsd 0x8(%rsp), %xmm0
mulsd 0x1dbba4(%rip), %xmm0   # 0x1e0008
jmp 0x4474
movsd 0x8(%rsp), %xmm0
mulsd 0x1dbbac(%rip), %xmm0   # 0x1e0020
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/./ketopt.h
// Function: ketopt_permute(char**, int, int)
static void ketopt_permute(char *argv[], int j, int n) /* move argv[j] over n elements to the left */
{
	int k;
	char *p = argv[j];
	for (k = 0; k < n; ++k)
		argv[j - k] = argv[j - k - 1];
	argv[j - k] = p;
}

// Assembly:
movslq %esi, %rax
leaq (%rdi,%rax,8), %rcx
movq (%rcx), %rax
xorl %r8d, %r8d
testl %edx, %edx
cmovlel %r8d, %edx
movq %rdx, %r9
negq %r9
cmpq %r8, %r9
je 0x583b
movq -0x8(%rcx,%r8,8), %r10
movq %r10, (%rcx,%r8,8)
decq %r8
jmp 0x5828
subl %edx, %esi
movslq %esi, %rcx
movq %rax, (%rdi,%rcx,8)
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: init_All_reads(All_reads*)
void init_All_reads(All_reads* r)
{
	memset(r, 0, sizeof(All_reads));
	r->index_size = READ_INIT_NUMBER;
	r->read_length = (uint64_t*)malloc(sizeof(uint64_t)*r->index_size);
	r->name_index_size = READ_INIT_NUMBER;
	r->name_index = (uint64_t*)malloc(sizeof(uint64_t)*r->name_index_size);
	r->name_index[0] = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x88, %edx
xorl %esi, %esi
callq 0x20e0
movl $0x3e8, %r14d           # imm = 0x3E8
movq %r14, 0x38(%rbx)
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x2280
movq %rax, 0x18(%rbx)
movq %r14, 0x48(%rbx)
movl $0x1f40, %edi           # imm = 0x1F40
callq 0x2280
movq %rax, 0x40(%rbx)
andq $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: destory_All_reads(All_reads*)
void destory_All_reads(All_reads* r)
{
	uint64_t i = 0;
	for (i = 0; i < r->total_reads; i++) {
		if (r->N_site[i]) free(r->N_site[i]);
		if (r->read_sperate[i]) free(r->read_sperate[i]);
		if (r->paf && r->paf[i].buffer) free(r->paf[i].buffer);
		if (r->reverse_paf && r->reverse_paf[i].buffer) free(r->reverse_paf[i].buffer);
		if(r->rsc && r->rsc[i]) free(r->rsc[i]);
		///if (r->pb_regions) kv_destroy(r->pb_regions[i].a);
	}
	free(r->paf);
	free(r->reverse_paf);
	free(r->N_site);
	free(r->read_sperate);
	free(r->name);
	free(r->name_index);
	free(r->read_length);
	free(r->trio_flag);
	free(r->rsc);
	///if (r->pb_regions) free(r->pb_regions);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq 0x50(%rbx), %r15
jae 0x5900
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2220
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2220
movq 0x78(%rbx), %rax
testq %rax, %rax
je 0x58d0
movq (%rax,%r14), %rdi
callq 0x2220
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x58e5
movq (%rax,%r14), %rdi
callq 0x2220
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x58f7
movq (%rax,%r15,8), %rdi
callq 0x2220
incq %r15
addq $0x18, %r14
jmp 0x589f
movq 0x78(%rbx), %rdi
callq 0x2220
movq 0x80(%rbx), %rdi
callq 0x2220
movq (%rbx), %rdi
callq 0x2220
movq 0x10(%rbx), %rdi
callq 0x2220
movq 0x8(%rbx), %rdi
callq 0x2220
movq 0x40(%rbx), %rdi
callq 0x2220
movq 0x18(%rbx), %rdi
callq 0x2220
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x30(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: read_ma(ma_hit_t*, _IO_FILE*)
void read_ma(ma_hit_t* x, FILE* fp)
{
    int f_flag;
    f_flag = fread(&(x->qns), sizeof(x->qns), 1, fp);
    f_flag += fread(&(x->qe), sizeof(x->qe), 1, fp);
    f_flag += fread(&(x->tn), sizeof(x->tn), 1, fp);
    f_flag += fread(&(x->ts), sizeof(x->ts), 1, fp);
    f_flag += fread(&(x->te), sizeof(x->te), 1, fp);
    f_flag += fread(&(x->el), sizeof(x->el), 1, fp);
    f_flag += fread(&(x->no_l_indel), sizeof(x->no_l_indel), 1, fp);

    uint32_t t;
    f_flag += fread(&(t), sizeof(t), 1, fp);
    x->ml = t;

    f_flag += fread(&(t), sizeof(t), 1, fp);
    x->rev = t;
    
    f_flag += fread(&(t), sizeof(t), 1, fp);
    x->bl = t;

    f_flag += fread(&(t), sizeof(t), 1, fp);
    x->del = t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x8
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
leaq 0x8(%rbx), %rdi
pushq $0x4
popq %r12
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
leaq 0xc(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
leaq 0x10(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
leaq 0x14(%rbx), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
leaq 0x21(%rbx), %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
leaq 0xc(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
movl (%r13), %eax
andl $0x1, %eax
shll $0x1e, %eax
movq $-0x40000001, %rcx      # imm = 0xBFFFFFFF
andq 0x18(%rbx), %rcx
orq %rax, %rcx
movq %rcx, 0x18(%rbx)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
movl (%r13), %eax
shll $0x1f, %eax
movabsq $-0x80000001, %rcx      # imm = 0xFFFFFFFF7FFFFFFF
andq 0x18(%rbx), %rcx
orq %rax, %rcx
movq %rcx, 0x18(%rbx)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andl (%r13), %eax
shlq $0x20, %rax
movabsq $-0x7fffffff00000001, %rcx # imm = 0x80000000FFFFFFFF
andq 0x18(%rbx), %rcx
orq %rax, %rcx
movq %rcx, 0x18(%rbx)
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x22f0
movl (%r13), %eax
shlq $0x3f, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq 0x18(%rbx), %rcx
orq %rax, %rcx
movq %rcx, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: destory_read_bin(All_reads*)
int destory_read_bin(All_reads* r)
{

	uint64_t i = 0;
	for (i = 0; i < r->total_reads; i++)
	{
		if (r->N_site[i]) free(r->N_site[i]);
		if (r->read_sperate[i]) free(r->read_sperate[i]);
		if (r->cigars[i].record) free(r->cigars[i].record);
		if (r->cigars[i].lost_base) free(r->cigars[i].lost_base);
		if (r->second_round_cigar[i].record) free(r->second_round_cigar[i].record);
		if (r->second_round_cigar[i].lost_base) free(r->second_round_cigar[i].lost_base);
	}

	free(r->N_site);
	free(r->read_length);
	free(r->read_size);
	free(r->read_sperate);
	free(r->name);
	free(r->name_index);
	free(r->trio_flag);
	free(r->cigars);
	free(r->second_round_cigar);
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rdi
cmpq 0x50(%rbx), %r15
jae 0x685f
movq (%rdi,%r15,8), %rdi
callq 0x2220
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2220
movq 0x68(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2220
movq 0x68(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
callq 0x2220
movq 0x70(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2220
movq 0x70(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
callq 0x2220
incq %r15
addq $0x28, %r14
jmp 0x6801
callq 0x2220
movq 0x18(%rbx), %rdi
callq 0x2220
movq 0x20(%rbx), %rdi
callq 0x2220
movq 0x10(%rbx), %rdi
callq 0x2220
movq 0x8(%rbx), %rdi
callq 0x2220
movq 0x40(%rbx), %rdi
callq 0x2220
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x68(%rbx), %rdi
callq 0x2220
movq 0x70(%rbx), %rdi
callq 0x2220
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: ha_insert_read_len(All_reads*, int, int)
void ha_insert_read_len(All_reads *r, int read_len, int name_len)
{
	r->total_reads++;
	r->total_reads_bases += (uint64_t)read_len;
	r->total_name_length += (uint64_t)name_len;

	// must +1
	if (r->index_size < r->total_reads + 2) {
		r->index_size = r->index_size * 2 + 2;
		r->read_length = (uint64_t*)realloc(r->read_length, sizeof(uint64_t) * r->index_size);
		r->name_index_size = r->name_index_size * 2 + 2;
		r->name_index = (uint64_t*)realloc(r->name_index, sizeof(uint64_t) * r->name_index_size);
	}

	r->read_length[r->total_reads - 1] = read_len;
	r->name_index[r->total_reads] = r->name_index[r->total_reads - 1] + name_len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
movq 0x50(%rdi), %rdi
leaq 0x1(%rdi), %rcx
movq %rcx, 0x50(%rbx)
movslq %esi, %r15
addq %r15, 0x58(%rbx)
movslq %edx, %r14
addq %r14, 0x60(%rbx)
addq $0x3, %rdi
cmpq %rdi, %rax
jae 0x6936
leaq 0x2(,%rax,2), %rcx
addq %rax, %rax
movq %rcx, 0x38(%rbx)
movq 0x18(%rbx), %rdi
leaq 0x10(,%rax,8), %rsi
callq 0x2370
movq %rax, 0x18(%rbx)
movq 0x40(%rbx), %rdi
movq 0x48(%rbx), %rax
leaq 0x2(,%rax,2), %rcx
addq %rax, %rax
movq %rcx, 0x48(%rbx)
leaq 0x10(,%rax,8), %rsi
callq 0x2370
movq %rax, 0x40(%rbx)
movq 0x50(%rbx), %rcx
jmp 0x693a
movq 0x40(%rbx), %rax
movq 0x18(%rbx), %rdx
movq %r15, -0x8(%rdx,%rcx,8)
movq 0x50(%rbx), %rcx
addq -0x8(%rax,%rcx,8), %r14
movq %r14, (%rax,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: init_aux_table()
void init_aux_table()
{
	if (bit_t_seq_table[0][0] == 0)
	{
		uint64_t i = 0;

		for (i = 0; i < 256; i++)
		{
			bit_t_seq_table[i][0] = s_H[((i >> 6)&(uint64_t)3)];
			bit_t_seq_table[i][1] = s_H[((i >> 4)&(uint64_t)3)];
			bit_t_seq_table[i][2] = s_H[((i >> 2)&(uint64_t)3)];
			bit_t_seq_table[i][3] = s_H[(i&(uint64_t)3)];

			bit_t_seq_table_rc[i][0] = RC_CHAR(bit_t_seq_table[i][3]);
			bit_t_seq_table_rc[i][1] = RC_CHAR(bit_t_seq_table[i][2]);
			bit_t_seq_table_rc[i][2] = RC_CHAR(bit_t_seq_table[i][1]);
			bit_t_seq_table_rc[i][3] = RC_CHAR(bit_t_seq_table[i][0]);
		}
	}
}

// Assembly:
cmpb $0x0, 0x24cf1a(%rip)    # 0x253a30
je 0x6b19
retq
pushq %rbx
xorl %eax, %eax
leaq 0x24cc0d(%rip), %rcx    # 0x253730
leaq 0x24cf06(%rip), %rdx    # 0x253a30
leaq 0x24caff(%rip), %rsi    # 0x253630
leaq 0x24cbfd(%rip), %rdi    # 0x253735
leaq 0x24d2f1(%rip), %r8     # 0x253e30
cmpq $0x100, %rax            # imm = 0x100
je 0x6bcf
movq %rax, %r9
shrq $0x6, %r9
movzbl (%r9,%rcx), %r9d
movb %r9b, (%rdx,%rax,4)
movl %eax, %r10d
shrl $0x4, %r10d
andl $0x3, %r10d
movzbl (%r10,%rcx), %r10d
movb %r10b, 0x1(%rdx,%rax,4)
movl %eax, %r11d
shrl $0x2, %r11d
andl $0x3, %r11d
movzbl (%r11,%rcx), %r11d
movb %r11b, 0x2(%rdx,%rax,4)
movl %eax, %ebx
andl $0x3, %ebx
movzbl (%rbx,%rcx), %ebx
movb %bl, 0x3(%rdx,%rax,4)
movzbl (%rbx,%rsi), %ebx
movb (%rbx,%rdi), %bl
movb %bl, (%r8,%rax,4)
movzbl (%r11,%rsi), %r11d
movb (%r11,%rdi), %r11b
movb %r11b, 0x1(%r8,%rax,4)
movzbl (%r10,%rsi), %r10d
movb (%r10,%rdi), %r10b
movb %r10b, 0x2(%r8,%rax,4)
movzbl (%r9,%rsi), %r9d
movb (%r9,%rdi), %r9b
movb %r9b, 0x3(%r8,%rax,4)
incq %rax
jmp 0x6b3f
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: init_UC_Read(UC_Read*)
void init_UC_Read(UC_Read* r)
{
	r->length = 0;
	r->size = 0;
	r->seq = NULL;
	if (bit_t_seq_table[0][0] == 0)
	{
		uint64_t i = 0;

		for (i = 0; i < 256; i++)
		{
			bit_t_seq_table[i][0] = s_H[((i >> 6)&(uint64_t)3)];
			bit_t_seq_table[i][1] = s_H[((i >> 4)&(uint64_t)3)];
			bit_t_seq_table[i][2] = s_H[((i >> 2)&(uint64_t)3)];
			bit_t_seq_table[i][3] = s_H[(i&(uint64_t)3)];

			bit_t_seq_table_rc[i][0] = RC_CHAR(bit_t_seq_table[i][3]);
			bit_t_seq_table_rc[i][1] = RC_CHAR(bit_t_seq_table[i][2]);
			bit_t_seq_table_rc[i][2] = RC_CHAR(bit_t_seq_table[i][1]);
			bit_t_seq_table_rc[i][3] = RC_CHAR(bit_t_seq_table[i][0]);
		}
	}
}

// Assembly:
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpb $0x0, 0x24ce4d(%rip)    # 0x253a30
je 0x6be6
retq
pushq %rbx
xorl %eax, %eax
leaq 0x24cb40(%rip), %rcx    # 0x253730
leaq 0x24ce39(%rip), %rdx    # 0x253a30
leaq 0x24ca32(%rip), %rsi    # 0x253630
leaq 0x24cb30(%rip), %rdi    # 0x253735
leaq 0x24d224(%rip), %r8     # 0x253e30
cmpq $0x100, %rax            # imm = 0x100
je 0x6c9c
movq %rax, %r9
shrq $0x6, %r9
movzbl (%r9,%rcx), %r9d
movb %r9b, (%rdx,%rax,4)
movl %eax, %r10d
shrl $0x4, %r10d
andl $0x3, %r10d
movzbl (%r10,%rcx), %r10d
movb %r10b, 0x1(%rdx,%rax,4)
movl %eax, %r11d
shrl $0x2, %r11d
andl $0x3, %r11d
movzbl (%r11,%rcx), %r11d
movb %r11b, 0x2(%rdx,%rax,4)
movl %eax, %ebx
andl $0x3, %ebx
movzbl (%rbx,%rcx), %ebx
movb %bl, 0x3(%rdx,%rax,4)
movzbl (%rbx,%rsi), %ebx
movb (%rbx,%rdi), %bl
movb %bl, (%r8,%rax,4)
movzbl (%r11,%rsi), %r11d
movb (%r11,%rdi), %r11b
movb %r11b, 0x1(%r8,%rax,4)
movzbl (%r10,%rsi), %r10d
movb (%r10,%rdi), %r10b
movb %r10b, 0x2(%r8,%rax,4)
movzbl (%r9,%rsi), %r9d
movb (%r9,%rdi), %r9b
movb %r9b, 0x3(%r8,%rax,4)
incq %rax
jmp 0x6c0c
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: recover_UC_Read(UC_Read*, All_reads const*, unsigned long)
void recover_UC_Read(UC_Read* r, const All_reads *R_INF, uint64_t ID)
{
	r->length = Get_READ_LENGTH((*R_INF), ID);
	uint8_t* src = Get_READ((*R_INF), ID);

	if (r->length + 4 > r->size) {
		r->size = r->length + 4;
		r->seq = (char*)realloc(r->seq,sizeof(char)*(r->size));
	}

	uint64_t i = 0;

	if(src) {
		while ((long long)i < r->length) {
			memcpy(r->seq+i, bit_t_seq_table[src[i>>2]], 4);
			i = i + 4;
		}

		if (R_INF->N_site[ID]) {
			for (i = 1; i <= R_INF->N_site[ID][0]; i++) r->seq[R_INF->N_site[ID][i]] = 'N';
		}
	} else {///N
		memset(r->seq, 'N', r->length);
	}

	r->RID = ID;	
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rsi), %rax
movq (%rax,%rdx,8), %rsi
movq %rsi, 0x8(%rdi)
movq 0x10(%r15), %rax
movq (%rax,%rdx,8), %r12
addq $0x4, %rsi
cmpq 0x10(%rdi), %rsi
jle 0x719c
movq %rsi, 0x10(%r14)
movq (%r14), %rdi
callq 0x2370
movq %rax, (%r14)
testq %r12, %r12
je 0x71f6
xorl %eax, %eax
leaq 0x24c886(%rip), %rcx    # 0x253a30
cmpq 0x8(%r14), %rax
jge 0x71cb
movq (%r14), %rdx
movq %rax, %rsi
shrq $0x2, %rsi
movzbl (%r12,%rsi), %esi
movl (%rcx,%rsi,4), %esi
movl %esi, (%rdx,%rax)
addq $0x4, %rax
jmp 0x71aa
movq (%r15), %rax
movq (%rax,%rbx,8), %rax
testq %rax, %rax
je 0x7205
pushq $0x1
popq %rcx
cmpq (%rax), %rcx
ja 0x7205
movq (%r14), %rdx
movq (%rax,%rcx,8), %rax
movb $0x4e, (%rdx,%rax)
incq %rcx
movq (%r15), %rax
movq (%rax,%rbx,8), %rax
jmp 0x71da
movq (%r14), %rdi
movq 0x8(%r14), %rdx
pushq $0x4e
popq %rsi
callq 0x20e0
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: recover_UC_Read_RC(UC_Read*, All_reads*, unsigned long)
void recover_UC_Read_RC(UC_Read* r, All_reads* R_INF, uint64_t ID)
{
	r->length = Get_READ_LENGTH((*R_INF), ID);
	uint8_t* src = Get_READ((*R_INF), ID);

	if (r->length + 4 > r->size) {
		r->size = r->length + 4;
		r->seq = (char*)realloc(r->seq,sizeof(char)*(r->size));
	}

	long long last_chr = r->length % 4;
	long long i = r->length / 4 - 1 + (last_chr != 0);
	long long index = 0;

	if(src) {
		if(last_chr!=0) {
			memcpy(r->seq + index, bit_t_seq_table_rc[src[i]] + 4 - last_chr, last_chr);
			index = last_chr;
			i--;
		}

		while (i >= 0) {
			memcpy(r->seq + index, bit_t_seq_table_rc[src[i]], 4);
			i--;
			index = index + 4;
		}

		if (R_INF->N_site[ID]) {
			for (i = 1; i <= (long long)R_INF->N_site[ID][0]; i++) {
				r->seq[r->length - R_INF->N_site[ID][i] - 1] = 'N';
			}
		}
	} else {///N
		memset(r->seq, 'N', r->length);
	}

	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rsi), %rax
movq (%rax,%rdx,8), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%rsi), %rax
movq (%rax,%rdx,8), %r13
leaq 0x4(%rcx), %rsi
cmpq 0x10(%rdi), %rsi
jle 0x725a
movq %rsi, 0x10(%r14)
movq (%r14), %rdi
callq 0x2370
movq %rax, (%r14)
movq 0x8(%r14), %rcx
pushq $0x4
popq %rsi
movq %rcx, %rax
cqto
idivq %rsi
leaq (,%rax,4), %rsi
xorl %edx, %edx
movq %rcx, %r12
subq %rsi, %r12
setne %sil
testq %r13, %r13
je 0x731e
movq %rbx, (%rsp)
movb %sil, %dl
leaq (%rax,%rdx), %rbp
decq %rbp
leaq 0x24cb99(%rip), %rbx    # 0x253e30
testq %r12, %r12
je 0x72d4
movq (%r14), %rdi
movzbl (%r13,%rbp), %eax
leaq (%rbx,%rax,4), %rsi
subq %r12, %rsi
addq $0x4, %rsi
movq %r12, %rdx
callq 0x2160
decq %rbp
jmp 0x72d4
movq (%r14), %rax
movzbl (%r13,%rbp), %ecx
movl (%rbx,%rcx,4), %ecx
movl %ecx, (%rax,%r12)
decq %rbp
addq $0x4, %r12
testq %rbp, %rbp
jns 0x72bd
movq (%r15), %rax
movq (%rsp), %rsi
movq (%rax,%rsi,8), %rcx
testq %rcx, %rcx
je 0x730f
pushq $0x1
popq %rax
cmpq (%rcx), %rax
jg 0x730f
movq (%r14), %rdx
movq (%rcx,%rax,8), %rcx
notq %rcx
addq 0x8(%r14), %rdx
movb $0x4e, (%rcx,%rdx)
incq %rax
movq (%r15), %rcx
movq (%rcx,%rsi,8), %rcx
jmp 0x72ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
pushq $0x4e
popq %rsi
movq %rcx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: ha_compress_base(unsigned char*, char*, unsigned long, unsigned long**, unsigned long)
void ha_compress_base(uint8_t* dest, char* src, uint64_t src_l, uint64_t** N_site_lis, uint64_t N_site_occ)
{
	///N_site_lis saves the pos of all Ns in this read
	///N_site_lis[0] is the number of Ns
	free((*N_site_lis));
	if (N_site_occ)
	{
		(*N_site_lis) = (uint64_t*)malloc(sizeof(uint64_t)*(N_site_occ + 1));
		(*N_site_lis)[0] = N_site_occ;
	}
	else
	{
		(*N_site_lis) = NULL;
	}

	uint64_t i = 0;
	uint64_t N_site_i = 1;
	uint64_t dest_i = 0;
	uint8_t tmp = 0;
	uint8_t c = 0;

	while (i + 4 <= src_l)
	{
		tmp = 0;

		COMPRESS_BASE;
		tmp = tmp | (c<<6);

		COMPRESS_BASE;
		tmp = tmp | (c<<4);

		COMPRESS_BASE;
		tmp = tmp | (c<<2);

		COMPRESS_BASE;
		tmp = tmp | c;

		dest[dest_i] = tmp;

		dest_i++;
	}

	//at most 3 bases here
	uint64_t shift = 6;
	if (i < src_l)
	{
		tmp = 0;

		while (i < src_l)
		{
			COMPRESS_BASE;
			tmp = tmp | (c << shift);
			shift = shift -2;
		}
		
		dest[dest_i] = tmp;
		dest_i++;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq (%rcx), %rdi
callq 0x2220
testq %r13, %r13
je 0x7371
leaq 0x8(,%r13,8), %rdi
callq 0x2280
movq %r13, (%rax)
jmp 0x7373
xorl %eax, %eax
movq %rax, (%rbx)
pushq $0x1
popq %rax
pushq $0x2
popq %rcx
leaq 0x24c2ad(%rip), %rdx    # 0x253630
leaq -0x2(%rcx), %rdi
leaq 0x2(%rcx), %rsi
cmpq %r14, %rsi
ja 0x7431
movzbl -0x2(%r12,%rcx), %esi
movb (%rsi,%rdx), %sil
cmpb $0x4, %sil
jb 0x73b0
movq (%rbx), %rsi
movq %rdi, (%rsi,%rax,8)
incq %rax
xorl %esi, %esi
movzbl -0x1(%r12,%rcx), %edi
movb (%rdi,%rdx), %dil
cmpb $0x4, %dil
jb 0x73d0
leaq -0x1(%rcx), %rdi
movq (%rbx), %r8
movq %rdi, (%r8,%rax,8)
incq %rax
xorl %edi, %edi
movzbl (%r12,%rcx), %r8d
movb (%r8,%rdx), %r8b
cmpb $0x4, %r8b
jb 0x73ec
movq (%rbx), %r8
movq %rcx, (%r8,%rax,8)
incq %rax
xorl %r8d, %r8d
movzbl 0x1(%r12,%rcx), %r9d
movb (%r9,%rdx), %r9b
cmpb $0x4, %r9b
jb 0x740d
leaq 0x1(%rcx), %r9
movq (%rbx), %r10
movq %r9, (%r10,%rax,8)
incq %rax
xorl %r9d, %r9d
shlb $0x6, %sil
shlb $0x4, %dil
orb %sil, %dil
shlb $0x2, %r8b
orb %dil, %r8b
orb %r9b, %r8b
movb %r8b, (%r15)
addq $0x4, %rcx
incq %r15
jmp 0x7383
cmpq %r14, %rdi
jae 0x7471
pushq $0x6
popq %rcx
xorl %esi, %esi
cmpq %r14, %rdi
jae 0x746e
movzbl (%r12,%rdi), %r8d
movb (%r8,%rdx), %r8b
cmpb $0x4, %r8b
jb 0x745c
movq (%rbx), %r8
movq %rdi, (%r8,%rax,8)
incq %rax
xorl %r8d, %r8d
movzbl %r8b, %r8d
shll %cl, %r8d
incq %rdi
orb %r8b, %sil
addl $-0x2, %ecx
jmp 0x743b
movb %sil, (%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: convert_qual(unsigned char*, char*, unsigned long, unsigned long, unsigned long, unsigned long)
void convert_qual(uint8_t* dest, char* src, uint64_t src_l, uint64_t bitu, uint64_t rev, uint64_t sc_off)
{
	uint64_t i = 0; uint8_t c = 0, sc;
	// fprintf(stderr, "\n[M::%s]\n", __func__);
	for (i = 0; i < src_l; i++) {
		for (c = 0, sc = ((uint8_t)src[i]) - sc_off; (c < bitu) && (sc_tb[c] < sc); c++);
		if(c >= bitu) c = bitu - 1;
		dest[(rev?(src_l-i-1):(i))] = c;
		// fprintf(stderr, "%u->%u\n", sc, c);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leal -0x1(%rcx), %eax
xorl %r10d, %r10d
leaq 0x1db6a3(%rip), %r11    # 0x1e2b30
cmpq %rdx, %r10
je 0x74cd
movb (%rsi,%r10), %bl
subb %r9b, %bl
movzbl %bl, %r14d
xorl %ebx, %ebx
movzbl %bl, %r15d
cmpq %rcx, %r15
jae 0x74b2
cmpq %r14, (%r11,%r15,8)
jae 0x74b4
incb %bl
jmp 0x749f
movl %eax, %ebx
movq %r10, %r14
notq %r14
addq %rdx, %r14
testq %r8, %r8
cmoveq %r10, %r14
movb %bl, (%rdi,%r14)
incq %r10
jmp 0x748d
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: ha_compress_qual_bit(unsigned char*, char*, unsigned long, unsigned long)
void ha_compress_qual_bit(uint8_t* dest, char* src, uint64_t src_l, uint64_t bitn)
{

	uint64_t i = 0, k, bit_r = 8/bitn, dest_i = 0;
	uint8_t tmp = 0, c = 0;

	for (i = 0; i + bit_r <= src_l;) {
		for (k = tmp = 0; k < bit_r; k++) {
			c = ((uint8_t)src[i]);
			tmp <<= bitn; tmp |= c; i++;
		}
		dest[dest_i++] = tmp;
	}

	if(i < src_l) {
		for (k = tmp = 0; i < src_l; k++) {
			c = ((uint8_t)src[i]);
			tmp <<= bitn; tmp |= c; i++;
		}
		 
		dest[dest_i++] = (tmp<<(8-(bitn*k)));
	}
}

// Assembly:
pushq %rbx
movq %rdx, %r8
xorl %r9d, %r9d
movabsq $0x8, %rax
xorl %edx, %edx
divq %rcx
xorl %edx, %edx
leaq (%r9,%rax), %r10
cmpq %r8, %r10
ja 0x751b
leaq (%rsi,%r9), %r11
xorl %r10d, %r10d
xorl %ebx, %ebx
cmpq %rax, %r10
jae 0x7510
movzbl %bl, %ebx
shll %cl, %ebx
orb (%r11,%r10), %bl
incq %r10
jmp 0x74fd
movb %bl, (%rdi,%rdx)
incq %rdx
addq %r10, %r9
jmp 0x74eb
cmpq %r8, %r9
jae 0x7548
movl $0x8, %eax
xorl %r10d, %r10d
movzbl %r10b, %r10d
cmpq %r8, %r9
jae 0x753f
shll %cl, %r10d
orb (%rsi,%r9), %r10b
incq %r9
subl %ecx, %eax
jmp 0x7528
movl %eax, %ecx
shll %cl, %r10d
movb %r10b, (%rdi,%rdx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: ha_compress_qual(unsigned char*, char*, unsigned long, unsigned long, unsigned long)
void ha_compress_qual(uint8_t* dest, char* src, uint64_t src_l, uint64_t bitn, uint64_t sc_off)
{

	uint64_t i = 0, k, bit_r = 8/bitn, dest_i = 0, bitu = (1<<bitn);
	uint8_t tmp = 0, c = 0, sc;

	for (i = 0; i + bit_r <= src_l;) {
		for (k = tmp = 0; k < bit_r; k++) {
			for (c = 0, sc = ((uint8_t)src[i]) - sc_off; (c < bitu) && (sc_tb[c] < sc); c++);
			if(c >= bitu) c = bitu - 1;
			tmp <<= bitn; tmp |= c; i++;
		}
		dest[dest_i++] = tmp;
	}

	if(i < src_l) {
		for (k = tmp = 0; i < src_l; k++) {
			for (c = 0, sc = ((uint8_t)src[i]) - sc_off; (c < bitu) && (sc_tb[c] < sc); c++);
			if(c >= bitu) c = bitu - 1;
			tmp <<= bitn; tmp |= c; i++;
		}
		 
		dest[dest_i++] = (tmp<<(8-(bitn*k)));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, -0x8(%rsp)
xorl %r10d, %r10d
movabsq $0x8, %rax
xorl %edx, %edx
divq %rcx
movl $0x1, %edx
shll %cl, %edx
movslq %edx, %rdx
leal -0x1(%rdx), %r11d
leaq 0x1db5b0(%rip), %rbx    # 0x1e2b30
xorl %r14d, %r14d
leaq (%r14,%rax), %r9
cmpq -0x8(%rsp), %r9
ja 0x75d7
xorl %r15d, %r15d
xorl %ebp, %ebp
cmpq %rax, %r15
jae 0x75ce
movb (%rsi,%r14), %r9b
subb %r8b, %r9b
movzbl %r9b, %r13d
xorl %r12d, %r12d
movzbl %r12b, %r9d
cmpq %rdx, %r9
jae 0x75ba
cmpq %r13, (%rbx,%r9,8)
jae 0x75bd
incb %r12b
jmp 0x75a6
movl %r11d, %r12d
movzbl %bpl, %ebp
shll %cl, %ebp
orb %r12b, %bpl
incq %r14
incq %r15
jmp 0x7593
movb %bpl, (%rdi,%r10)
incq %r10
jmp 0x7583
cmpq -0x8(%rsp), %r14
jae 0x762d
xorl %r15d, %r15d
xorl %eax, %eax
movzbl %al, %eax
cmpq -0x8(%rsp), %r14
jae 0x761e
movb (%rsi,%r14), %r9b
subb %r8b, %r9b
movzbl %r9b, %r12d
xorl %ebp, %ebp
movzbl %bpl, %r9d
cmpq %rdx, %r9
jae 0x760e
cmpq %r12, (%rbx,%r9,8)
jae 0x7611
incb %bpl
jmp 0x75fa
movl %r11d, %ebp
shll %cl, %eax
orb %bpl, %al
incq %r14
incq %r15
jmp 0x75e3
imull %ecx, %r15d
movb $0x8, %cl
subb %r15b, %cl
shll %cl, %eax
movb %al, (%rdi,%r10)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: reverse_complement(char*, unsigned long)
void reverse_complement(char* pattern, uint64_t length)
{
	uint64_t i = 0;
	uint64_t end = length / 2;
	char k;
	uint64_t index;

	for (i = 0; i < end; i++)
	{
		
		index = length - i - 1;
		k = pattern[index];
		pattern[index] = RC_CHAR(pattern[i]);
		pattern[i] = RC_CHAR(k);
	}

	if(length&(uint64_t)1)
	{
		pattern[end] = RC_CHAR(pattern[end]);
	}
}

// Assembly:
movq %rsi, %rax
shrq %rax
leaq (%rsi,%rdi), %r8
decq %r8
xorl %r9d, %r9d
leaq 0x24bcb5(%rip), %rdx    # 0x253630
leaq 0x24bdb3(%rip), %rcx    # 0x253735
cmpq %r9, %rax
je 0x79b1
movzbl (%r8), %r10d
movzbl (%rdi,%r9), %r11d
movzbl (%r11,%rdx), %r11d
movb (%r11,%rcx), %r11b
movb %r11b, (%r8)
movzbl (%r10,%rdx), %r10d
movb (%r10,%rcx), %r10b
movb %r10b, (%rdi,%r9)
incq %r9
decq %r8
jmp 0x7982
testb $0x1, %sil
je 0x79c5
movzbl (%rdi,%rax), %esi
movzbl (%rsi,%rdx), %edx
movb (%rdx,%rcx), %cl
movb %cl, (%rdi,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: print_fastq(_IO_FILE*, char*, char*, char*, unsigned long, unsigned long)
void print_fastq(FILE *fp, char *id, char *bs, char *qual, uint64_t bitu, uint64_t sc_off)
{
	uint64_t i = 0, ql = strlen(qual); uint8_t c = 0, sc;
	
	if(fp) fprintf(fp, "@%s\n%s\n+\n", id, bs);
	else fprintf(stdout, "@%s\n%s\n+\n", id, bs);

	for (i = 0; i < ql; i++) {
		for (c = 0, sc = ((uint8_t)qual[i]) - sc_off; (c < bitu) && (sc_tb[c] < sc); c++);
		if(c >= bitu) c = bitu - 1;
		if(fp) fprintf(fp, "%u", c);
		else fprintf(stdout, "%u", c);
	}

	if(fp) fprintf(fp, "\n");
	else fprintf(stdout, "\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
movq %rcx, %rdi
callq 0x2090
movq %rax, %r13
testq %rbx, %rbx
je 0x7a04
leaq 0x1dad66(%rip), %rsi    # 0x1e2765
movq %rbx, %rdi
jmp 0x7a15
movq 0x24b5ad(%rip), %rax    # 0x252fb8
movq (%rax), %rdi
leaq 0x1dad50(%rip), %rsi    # 0x1e2765
movq %rbp, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x22b0
leal -0x1(%r15), %eax
movl %eax, 0xc(%rsp)
leaq 0x1db0ff(%rip), %rbp    # 0x1e2b30
xorl %r14d, %r14d
cmpq %r13, %r14
je 0x7a87
movb (%r12,%r14), %al
subb 0x10(%rsp), %al
movzbl %al, %ecx
xorl %eax, %eax
movzbl %al, %edx
cmpq %r15, %rdx
jae 0x7a59
cmpq %rcx, (%rbp,%rdx,8)
jae 0x7a5d
incb %al
jmp 0x7a46
movl 0xc(%rsp), %eax
movzbl %al, %edx
testq %rbx, %rbx
je 0x7a6a
movq %rbx, %rdi
jmp 0x7a74
movq 0x24b547(%rip), %rax    # 0x252fb8
movq (%rax), %rdi
leaq 0x1e146d(%rip), %rsi    # 0x1e8ee8
xorl %eax, %eax
callq 0x22b0
incq %r14
jmp 0x7a34
testq %rbx, %rbx
je 0x7a94
pushq $0xa
popq %rdi
movq %rbx, %rsi
jmp 0x7aa1
movq 0x24b51d(%rip), %rax    # 0x252fb8
movq (%rax), %rsi
pushq $0xa
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: destory_Debug_reads(Debug_reads*)
void destory_Debug_reads(Debug_reads* x)
{
	uint64_t i;
	for (i = 0; i < x->query_num; i++)
	{
		free(x->read_name[i]);
		kv_destroy(x->candidate_count[i].a);
	}
	
	free(x->read_name); free(x->read_id);
	fclose(x->fp); fclose(x->fp_r0); fclose(x->fp_r1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x10
popq %r14
xorl %r15d, %r15d
movq (%rbx), %rdi
cmpq 0x10(%rbx), %r15
jae 0x7d04
movq (%rdi,%r15,8), %rdi
callq 0x2220
movq 0x18(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x2220
incq %r15
addq $0x20, %r14
jmp 0x7cdc
callq 0x2220
movq 0x8(%rbx), %rdi
callq 0x2220
movq 0x20(%rbx), %rdi
callq 0x2190
movq 0x28(%rbx), %rdi
callq 0x2190
movq 0x30(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/chhylp123[P]hifiasm/Process_Read.cpp
// Function: destory_all_ul_t(all_ul_t*)
void destory_all_ul_t(all_ul_t *x) {
	uint64_t i;
	for (i = 0; i < x->n; i++) {
		free(x->a[i].N_site.a); free(x->a[i].r_base.a); free(x->a[i].bb.a);
	}
	free(x->a);

	for (i = 0; i < x->nid.n; i++) free(x->nid.a[i].a);
	free(x->nid.a);
	free(x->ridx.idx.a); free(x->ridx.occ.a);

	// if(x->mm) {
	// 	for (i = 0; i < x->mm->n; i++) free(x->mm->a[i].a);
	// 	free(x->mm->a); free(x->mm); x->mm = NULL;
	// }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x48(%rbx), %rdi
cmpq 0x50(%rbx), %r15
jae 0x7d9c
movq 0x38(%rdi,%r14), %rdi
callq 0x2220
movq 0x48(%rbx), %rax
movq 0x10(%rax,%r14), %rdi
callq 0x2220
movq 0x48(%rbx), %rax
movq 0x30(%rax,%r14), %rdi
callq 0x2220
incq %r15
addq $0x58, %r14
jmp 0x7d63
callq 0x2220
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rdi
cmpq (%rbx), %r15
jae 0x7dc2
movq (%rdi,%r14), %rdi
callq 0x2220
incq %r15
addq $0x10, %r14
jmp 0x7da7
callq 0x2220
movq 0x28(%rbx), %rdi
callq 0x2220
movq 0x40(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220