LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::get_directory_list(std::filesystem::__cxx11::path)
std::vector<std::filesystem::directory_entry> get_directory_list(std::filesystem::path temp)
	{
		auto di = std::filesystem::directory_iterator(temp);
		std::vector<std::filesystem::directory_entry> res;
		for (auto &d : di)
		{
			auto comp = d.path().filename().string().at(0);
			if (comp != '.' || !hide_dot_files)
			{
				res.push_back(d);
			}
		}
		return res;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdx, -0x100(%rbp)
movq %rsi, %rax
movq -0x100(%rbp), %rsi
movq %rdi, -0xe8(%rbp)
movq %rdi, %rcx
movq %rcx, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xffe0
movq -0xe8(%rbp), %rdi
movb $0x0, -0x29(%rbp)
callq 0xcce0
leaq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x10040
leaq -0x48(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x10010
leaq -0x58(%rbp), %rdi
callq 0x10070
movq -0x38(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x10040
leaq -0x68(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x10090
leaq -0x78(%rbp), %rdi
callq 0x10070
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x100d0
testb $0x1, %al
jne 0xfa03
leaq -0x68(%rbp), %rdi
callq 0x10070
leaq -0x48(%rbp), %rdi
callq 0x10070
jmp 0xfb46
leaq -0x48(%rbp), %rdi
callq 0x4590
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x10100
movq %rax, %rsi
leaq -0xd0(%rbp), %rdi
callq 0x10110
jmp 0xfa2a
leaq -0xa8(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x10210
jmp 0xfa3f
xorl %eax, %eax
movl %eax, %esi
leaq -0xa8(%rbp), %rdi
callq 0x45c0
movq %rax, -0x108(%rbp)
jmp 0xfa58
movq -0x108(%rbp), %rax
movb (%rax), %al
movb %al, -0x109(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x41c0
leaq -0xd0(%rbp), %rdi
callq 0xddb0
movb -0x109(%rbp), %al
movb %al, -0x81(%rbp)
movsbl -0x81(%rbp), %eax
cmpl $0x2e, %eax
jne 0xfaa3
movq -0xf0(%rbp), %rax
testb $0x1, (%rax)
jne 0xfb0b
movq -0xe8(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0xe200
jmp 0xfab5
jmp 0xfb0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0xfb1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0xfafd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x41c0
leaq -0xd0(%rbp), %rdi
callq 0xddb0
jmp 0xfb1d
jmp 0xfb0d
leaq -0x48(%rbp), %rdi
callq 0x40a0
jmp 0xfb18
jmp 0xf9db
leaq -0x68(%rbp), %rdi
callq 0x10070
leaq -0x48(%rbp), %rdi
callq 0x10070
movq -0xe8(%rbp), %rdi
callq 0xa720
leaq -0x28(%rbp), %rdi
callq 0x10070
jmp 0xfb75
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0xfb5c
movq -0xe8(%rbp), %rdi
callq 0xa720
leaq -0x28(%rbp), %rdi
callq 0x10070
movq -0xf8(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: juli9797[P]ssf/src/filetree.hpp
// Function: ssf::Filetree::check_selection()
void check_selection(){
		//check if not valid
		if(!selection.empty()){
			if(find_element(active_col, selection.at(0)) == active_col.end()){
				selection.clear();			
			}
		}
		//default to first entry if possible
		if(selection.empty() && !active_col.empty()){
			update_selection(*active_col.begin());
		}
		
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x30, %rdi
callq 0xe130
testb $0x1, %al
jne 0xfcbd
movq -0x98(%rbp), %rdi
movq %rdi, %rax
addq $0x90, %rax
movq %rax, -0xb0(%rbp)
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe270
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xdc90
movq -0x98(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0x10bd0
movq %rax, -0xa0(%rbp)
jmp 0xfc45
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x90, %rdi
callq 0xeff0
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x10b90
movb %al, -0xb1(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xdd90
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0xfc8f
jmp 0xfcbb
movq -0x98(%rbp), %rdi
addq $0x30, %rdi
callq 0xf910
jmp 0xfcbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xdd90
jmp 0xfd6f
jmp 0xfcbd
movq -0x98(%rbp), %rdi
addq $0x30, %rdi
callq 0xe130
testb $0x1, %al
jne 0xfcd6
jmp 0xfd66
movq -0x98(%rbp), %rdi
addq $0x90, %rdi
callq 0xe130
testb $0x1, %al
jne 0xfd66
movq -0x98(%rbp), %rdi
addq $0x90, %rdi
callq 0xf0a0
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xff20
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xdc90
movq -0x98(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x10c30
jmp 0xfd3e
leaq -0x88(%rbp), %rdi
callq 0xdd90
jmp 0xfd66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xdd90
jmp 0xfd6f
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4560
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
addq $0x8, %rdi
callq 0x4150
testb $0x1, %al
jne 0xfdac
jmp 0xfef2
movq -0xb8(%rbp), %rsi
addq $0x78, %rsi
leaq -0x20(%rbp), %rdi
callq 0xd5a0
movq -0xb8(%rbp), %rsi
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
callq 0x10110
jmp 0xfdd6
leaq -0x20(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xf0a0
movq -0xc8(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0xeff0
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x113e0
movq %rax, -0xc0(%rbp)
jmp 0xfe1c
movq -0xc0(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xeff0
movq %rax, -0x80(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x11440
testb $0x1, %al
jne 0xfe47
jmp 0xfeba
leaq -0x60(%rbp), %rdi
callq 0xff20
movq %rax, %rsi
leaq -0xb0(%rbp), %rdi
callq 0xdc90
jmp 0xfe61
movq -0xb8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x11480
jmp 0xfe76
leaq -0xb0(%rbp), %rdi
callq 0xdd90
jmp 0xfeca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xfee7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xfede
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xdd90
jmp 0xfede
movq -0xb8(%rbp), %rdi
addq $0x48, %rdi
callq 0xf910
leaq -0x48(%rbp), %rdi
callq 0xddb0
leaq -0x20(%rbp), %rdi
callq 0xa720
jmp 0xff02
leaq -0x48(%rbp), %rdi
callq 0xddb0
leaq -0x20(%rbp), %rdi
callq 0xa720
jmp 0xff0b
movq -0xb8(%rbp), %rdi
addq $0x48, %rdi
callq 0xf910
addq $0xd0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd7c0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd7f0
movq -0x50(%rbp), %rdx
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x13460
movq %rax, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd7c0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x134b0
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x4430
movq -0x1c0(%rbp), %rax
movl (%rax), %esi
leaq -0x1a8(%rbp), %rdi
xorl %edx, %edx
callq 0x4dc0
jmp 0x13a04
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x42b0
movq %rax, -0x1d8(%rbp)
jmp 0x13a20
movq -0x1d8(%rbp), %rdi
leaq 0x395c(%rip), %rsi      # 0x1738a
callq 0x42f0
movq %rax, -0x1e0(%rbp)
jmp 0x13a3c
movq -0x1e0(%rbp), %rdi
movq -0x1c0(%rbp), %rsi
addq $0x8, %rsi
callq 0x42b0
jmp 0x13a55
leaq -0x1a8(%rbp), %rdi
callq 0x41c0
movq -0x1d0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x4320
jmp 0x13a76
leaq -0x188(%rbp), %rdi
callq 0x4060
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0x13ac4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x41c0
leaq -0x188(%rbp), %rdi
callq 0x4060
movq -0x1b0(%rbp), %rdi
callq 0x4560
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
addq $0x30, %rdi
callq 0xe130
testb $0x1, %al
jne 0x16056
movq -0xc8(%rbp), %rdi
addq $0x30, %rdi
callq 0xf0a0
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xff20
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xdc90
movq -0xc8(%rbp), %rax
movq -0xd8(%rbp), %rsi
addq $0x90, %rax
movq %rax, -0xd0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xdc90
jmp 0x15f41
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x10bd0
movq %rax, -0xe0(%rbp)
jmp 0x15f61
movq -0xe0(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xdd90
leaq -0x48(%rbp), %rdi
callq 0x10f80
movq -0xc8(%rbp), %rdi
movq %rax, -0xe8(%rbp)
addq $0x90, %rdi
callq 0xeff0
movq -0xe8(%rbp), %rdi
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x11440
testb $0x1, %al
jne 0x15fbb
jmp 0x16040
leaq -0x48(%rbp), %rdi
callq 0xff20
movq %rax, %rsi
leaq -0xc0(%rbp), %rdi
callq 0xdc90
jmp 0x15fd5
movq -0xc8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x10c30
jmp 0x15fea
leaq -0xc0(%rbp), %rdi
callq 0xdd90
jmp 0x16040
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x1604b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xdd90
jmp 0x1604b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xdd90
jmp 0x1604b
leaq -0x38(%rbp), %rdi
callq 0xdd90
jmp 0x16056
leaq -0x38(%rbp), %rdi
callq 0xdd90
jmp 0x1606b
movq -0xc8(%rbp), %rdi
callq 0xf450
addq $0xf0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x30, %rdi
callq 0xe130
testb $0x1, %al
jne 0x161c9
movq -0x98(%rbp), %rdi
movq %rdi, %rax
addq $0x90, %rax
movq %rax, -0xb0(%rbp)
addq $0x30, %rdi
callq 0xf0a0
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xff20
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xdc90
movq -0x98(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0x10bd0
movq %rax, -0xa0(%rbp)
jmp 0x1610e
movq -0xa0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xdd90
movq -0x98(%rbp), %rdi
addq $0x90, %rdi
callq 0xf0a0
movq %rax, -0x60(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x11440
testb $0x1, %al
jne 0x1614c
jmp 0x161c7
leaq -0x10(%rbp), %rdi
callq 0x161f0
movq %rax, %rdi
callq 0xff20
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xdc90
movq -0x98(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0x10c30
jmp 0x16188
leaq -0x90(%rbp), %rdi
callq 0xdd90
jmp 0x161c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xdd90
jmp 0x161de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xdd90
jmp 0x161de
jmp 0x161c9
movq -0x98(%rbp), %rdi
callq 0xf450
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4560
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
addq $0x8, %rdi
callq 0x4150
movb %al, %cl
movb $0x0, -0x31(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9d(%rbp)
jne 0x16248
jmp 0x16284
movq -0xa8(%rbp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0xb0(%rbp)
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4470
movq -0xb0(%rbp), %rdi
movb $0x1, -0x31(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x16390
movb %al, -0x9d(%rbp)
movb -0x9d(%rbp), %al
movb %al, -0xb1(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x16298
jmp 0x162a1
leaq -0x30(%rbp), %rdi
callq 0xddb0
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x162b0
jmp 0x16364
movq -0xa8(%rbp), %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
callq 0x45b0
movq -0xa8(%rbp), %rdi
addq $0x8, %rdi
leaq -0x60(%rbp), %rsi
callq 0xf3e0
leaq -0x60(%rbp), %rdi
callq 0xddb0
movq -0xa8(%rbp), %rdi
addq $0x48, %rdi
callq 0xe130
testb $0x1, %al
jne 0x16362
movq -0xa8(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe270
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xdc90
movq -0xa8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x10c30
jmp 0x16334
leaq -0x90(%rbp), %rdi
callq 0xdd90
jmp 0x16362
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xdd90
jmp 0x16379
jmp 0x16364
movq -0xa8(%rbp), %rdi
callq 0xf450
addq $0xc0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3a68
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x3a46
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2210
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3a1a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3a94
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x3aac
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x3a00
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x3ac4
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x3a00
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x3adc
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x3a00
movq -0x8(%rbp), %rax
cmpq $0x0, 0x68(%rax)
je 0x3af4
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x3a00
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/CommandLines.cpp
// Function: ha_opt_reset_to_round(hifiasm_opt_t*, int)
void ha_opt_reset_to_round(hifiasm_opt_t* asm_opt, int round)
{
    asm_opt->num_bases = 0;
    asm_opt->num_corrected_bases = 0;
    asm_opt->num_recorrected_bases = 0;
	asm_opt->mem_buf = 0;
    asm_opt->roundID = round;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x190(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x198(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1a0(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x1a8(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x108(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd 0xb8(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0x37b4b4(%rip), %xmm1   # 0x37f040
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xd0(%rax)
movq -0x8(%rbp), %rax
movl 0xe8(%rax), %eax
cmpl -0x10(%rbp), %eax
jge 0x3bc0
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xe8(%rax)
movq 0x3c0419(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xe8(%rax), %ecx
leaq 0x37cc0a(%rip), %rsi    # 0x3807e5
leaq 0x37cc26(%rip), %rdx    # 0x380808
movb $0x0, %al
callq 0x22a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cvtsi2sdl -0xc(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd 0xb8(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0x37b421(%rip), %xmm1   # 0x37f040
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xd0(%rax)
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xe8(%rax)
movq -0x8(%rbp), %rax
movl 0xe8(%rax), %eax
cmpl -0x10(%rbp), %eax
jge 0x3c60
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xe8(%rax)
movq 0x3c0379(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xe8(%rax), %ecx
leaq 0x37cb6a(%rip), %rsi    # 0x3807e5
leaq 0x37cb98(%rip), %rdx    # 0x38081a
movb $0x0, %al
callq 0x22a0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x48dc
movq 0x3bf722(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x37c842(%rip), %rsi    # 0x38110e
movb $0x0, %al
callq 0x22a0
movl $0x0, -0x4(%rbp)
jmp 0x4938
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x38bae7(%rip), %rsi    # 0x3903d6
callq 0x2200
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4928
movq 0x3bf6da(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x37c819(%rip), %rsi    # 0x381131
movb $0x0, %al
callq 0x22a0
movl $0x0, -0x4(%rbp)
jmp 0x4938
movq -0x20(%rbp), %rdi
callq 0x21a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x49a7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x48a0
cmpl $0x0, %eax
jne 0x499a
movl $0x0, -0x4(%rbp)
jmp 0x49ae
jmp 0x499c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4967
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: chhylp123[P]hifiasm/CommandLines.cpp
// Function: check_fq_files(enzyme*, char const*, int)
static int check_fq_files(enzyme* f, const char* opt, int32_t is_fq)
{
    int32_t i, ret; gzFile dfp; kseq_t *ks = NULL;
    for (i = 0; i < f->n; i++) {
        if(!(f->a[i])) {
            fprintf(stderr, "[ERROR] input file does not exist (%s)\n", opt);
            return 0;
        }

        dfp = gzopen(f->a[i], "r");
        if (dfp == 0) {
            fprintf(stderr, "[ERROR] Cannot find the input file: %s (%s)\n", f->a[i], opt);
            return 0;
        } else if(is_fq){
            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 (%s)\n", f->a[i], opt);
                    fprintf(stderr, "[ERROR] set --ul-m 0 for fasta files\n");
                    return 0;
                }
                break;
            }
            kseq_destroy(ks); ks = NULL;
        }
        gzclose(dfp);
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x4b43
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x4a2d
movq 0x3bf5d4(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x37c738(%rip), %rsi    # 0x381152
movb $0x0, %al
callq 0x22a0
movl $0x0, -0x4(%rbp)
jmp 0x4b4a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x38b992(%rip), %rsi    # 0x3903d6
callq 0x22c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x4a8c
movq 0x3bf585(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rcx
leaq 0x37c701(%rip), %rsi    # 0x38117a
movb $0x0, %al
callq 0x22a0
movl $0x0, -0x4(%rbp)
jmp 0x4b4a
cmpl $0x0, -0x1c(%rbp)
je 0x4b2a
movq -0x30(%rbp), %rdi
callq 0x4d10
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x4d50
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jl 0x4b19
movq -0x38(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x4aca
movq -0x38(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x4b17
movq 0x3bf50f(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rcx
leaq 0x37c6b8(%rip), %rsi    # 0x3811a7
movb $0x0, %al
callq 0x22a0
movq 0x3bf4e3(%rip), %rax    # 0x3c3fe0
movq (%rax), %rdi
leaq 0x37c6dd(%rip), %rsi    # 0x3811e4
movb $0x0, %al
callq 0x22a0
movl $0x0, -0x4(%rbp)
jmp 0x4b4a
jmp 0x4b19
movq -0x38(%rbp), %rdi
callq 0x5140
movq $0x0, -0x38(%rbp)
jmp 0x4b2c
movq -0x30(%rbp), %rdi
callq 0x2380
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x49e2
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20a0
movq %rax, -0x18(%rbp)
cmpq $0x1, -0x18(%rbp)
jg 0x559d
movq $-0x2, -0x8(%rbp)
jmp 0x56c3
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0x6b, %eax
je 0x55f2
movsbl -0x21(%rbp), %eax
cmpl $0x4b, %eax
je 0x55f2
movsbl -0x21(%rbp), %eax
cmpl $0x6d, %eax
je 0x55f2
movsbl -0x21(%rbp), %eax
cmpl $0x4d, %eax
je 0x55f2
movsbl -0x21(%rbp), %eax
cmpl $0x67, %eax
je 0x55f2
movsbl -0x21(%rbp), %eax
cmpl $0x47, %eax
je 0x55f2
movq $-0x2, -0x8(%rbp)
jmp 0x56c3
movq -0x18(%rbp), %rdi
callq 0x2270
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq $0x1, %rdx
callq 0x2180
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rdi
callq 0x2250
movsd %xmm0, -0x20(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2210
movsbl -0x21(%rbp), %eax
cmpl $0x6b, %eax
je 0x564d
movsbl -0x21(%rbp), %eax
cmpl $0x4b, %eax
jne 0x5665
movsd 0x379a03(%rip), %xmm0   # 0x37f058
mulsd -0x20(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x8(%rbp)
jmp 0x56c3
movsbl -0x21(%rbp), %eax
cmpl $0x6d, %eax
je 0x5677
movsbl -0x21(%rbp), %eax
cmpl $0x4d, %eax
jne 0x568f
movsd 0x379989(%rip), %xmm0   # 0x37f008
mulsd -0x20(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x8(%rbp)
jmp 0x56c3
movsbl -0x21(%rbp), %eax
cmpl $0x67, %eax
je 0x56a1
movsbl -0x21(%rbp), %eax
cmpl $0x47, %eax
jne 0x56b9
movsd 0x3799a7(%rip), %xmm0   # 0x37f050
mulsd -0x20(%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x8(%rbp)
jmp 0x56c3
cvttsd2si -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x733d
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7305
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x88, %edx
callq 0x2100
movq -0x8(%rbp), %rax
movq $0x3e8, 0x38(%rax)      # imm = 0x3E8
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
shlq $0x3, %rdi
callq 0x2270
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x3e8, 0x48(%rax)      # imm = 0x3E8
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
shlq $0x3, %rdi
callq 0x2270
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x752d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x7444
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x746c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x74a5
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x74a5
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x74e7
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x74e7
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x751a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x751a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2210
jmp 0x751c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x740c
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2210
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x910b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x9014
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x903c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x906a
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x909a
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x90c8
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x90f8
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2210
jmp 0x90fa
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8fdc
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2210
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x58(%rax), %rcx
movq %rcx, 0x58(%rax)
movslq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x60(%rax), %rcx
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jae 0x9261
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
shlq %rcx
addq $0x2, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rcx
shlq %rcx
addq $0x2, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movslq -0xc(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rdx
movslq -0x10(%rbp), %rax
addq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movsbl 0x3bb435(%rip), %eax    # 0x3c4ad0
cmpl $0x0, %eax
jne 0x9842
movq $0x0, -0x8(%rbp)
movq $0x0, -0x8(%rbp)
cmpq $0x100, -0x8(%rbp)      # imm = 0x100
jae 0x9840
movq -0x8(%rbp), %rcx
shrq $0x6, %rcx
andq $0x3, %rcx
leaq 0x3bb07b(%rip), %rax    # 0x3c4750
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rcx
leaq 0x3bb3ed(%rip), %rax    # 0x3c4ad0
movb %dl, (%rax,%rcx,4)
movq -0x8(%rbp), %rcx
shrq $0x4, %rcx
andq $0x3, %rcx
leaq 0x3bb057(%rip), %rax    # 0x3c4750
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rcx
leaq 0x3bb3c9(%rip), %rax    # 0x3c4ad0
movb %dl, 0x1(%rax,%rcx,4)
movq -0x8(%rbp), %rcx
shrq $0x2, %rcx
andq $0x3, %rcx
leaq 0x3bb032(%rip), %rax    # 0x3c4750
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rcx
leaq 0x3bb3a4(%rip), %rax    # 0x3c4ad0
movb %dl, 0x2(%rax,%rcx,4)
movq -0x8(%rbp), %rcx
andq $0x3, %rcx
leaq 0x3bb011(%rip), %rax    # 0x3c4750
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rcx
leaq 0x3bb383(%rip), %rax    # 0x3c4ad0
movb %dl, 0x3(%rax,%rcx,4)
movq -0x8(%rbp), %rcx
leaq 0x3bb374(%rip), %rax    # 0x3c4ad0
movzbl 0x3(%rax,%rcx,4), %eax
movl %eax, %ecx
leaq 0x3baee6(%rip), %rax    # 0x3c4650
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3bafde(%rip), %rax    # 0x3c4755
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rcx
leaq 0x3bb74b(%rip), %rax    # 0x3c4ed0
movb %dl, (%rax,%rcx,4)
movq -0x8(%rbp), %rcx
leaq 0x3bb33d(%rip), %rax    # 0x3c4ad0
movzbl 0x2(%rax,%rcx,4), %eax
movl %eax, %ecx
leaq 0x3baeaf(%rip), %rax    # 0x3c4650
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3bafa7(%rip), %rax    # 0x3c4755
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rcx
leaq 0x3bb714(%rip), %rax    # 0x3c4ed0
movb %dl, 0x1(%rax,%rcx,4)
movq -0x8(%rbp), %rcx
leaq 0x3bb305(%rip), %rax    # 0x3c4ad0
movzbl 0x1(%rax,%rcx,4), %eax
movl %eax, %ecx
leaq 0x3bae77(%rip), %rax    # 0x3c4650
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3baf6f(%rip), %rax    # 0x3c4755
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rcx
leaq 0x3bb6dc(%rip), %rax    # 0x3c4ed0
movb %dl, 0x2(%rax,%rcx,4)
movq -0x8(%rbp), %rcx
leaq 0x3bb2cd(%rip), %rax    # 0x3c4ad0
movzbl (%rax,%rcx,4), %eax
movl %eax, %ecx
leaq 0x3bae40(%rip), %rax    # 0x3c4650
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x3baf38(%rip), %rax    # 0x3c4755
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rcx
leaq 0x3bb6a5(%rip), %rax    # 0x3c4ed0
movb %dl, 0x3(%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x96b4
jmp 0x9842
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x4, %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jle 0xa40c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
shlq $0x0, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xa4cd
jmp 0xa421
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0xa467
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rsi
shrq $0x2, %rsi
movzbl (%rdx,%rsi), %edx
movl %edx, %esi
leaq 0x3ba67d(%rip), %rdx    # 0x3c4ad0
movl (%rdx,%rsi,4), %edx
movl %edx, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0xa421
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xa4cb
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq (%rcx), %rax
ja 0xa4c9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movb $0x4e, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xa481
jmp 0xa4cb
jmp 0xa4e6
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x4e, %esi
callq 0x2100
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0xab0c
movb $0x0, -0x39(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
subq -0x30(%rbp), %rax
movb %al, -0x3a(%rbp)
movzbl -0x39(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x3b(%rbp)
jae 0xaa94
movzbl -0x39(%rbp), %eax
movl %eax, %ecx
leaq 0x376e7d(%rip), %rax    # 0x381900
movq (%rax,%rcx,8), %rax
movzbl -0x3a(%rbp), %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
testb $0x1, %al
jne 0xaa9d
jmp 0xaaa9
jmp 0xaa9f
movb -0x39(%rbp), %al
addb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0xaa65
movzbl -0x39(%rbp), %eax
cmpq -0x20(%rbp), %rax
jb 0xaabe
movq -0x20(%rbp), %rax
subq $0x1, %rax
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
movb %al, -0x49(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xaae5
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0xaaed
movq -0x38(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x48(%rbp), %rax
movb -0x49(%rbp), %dl
movq -0x58(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xaa40
popq %rbp
retq
nop