LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Run(unsigned int)
void mos6502::Run(uint32_t n)
{
	uint32_t start = cycles;
	uint8_t opcode;
	Instr instr;

	//while(start + n > cycles && !illegalOpcode)
	while(start + 1000000 > cycles && !illegalOpcode)
	{

		// fetch
		if (!DebuggingFirst) {
		  DebugCommandline(pc);
		  DebuggingFirst = true;
		}

		DebugPC = pc;

		for (auto bp : bps) {
		  if (bp == DebugPC) {
			DebugCommandline(DebugPC);
		  }
		}


		opcode = Read(pc++);
		
		// decode
		instr = InstrTable[opcode];
		
		// execute
		Exec(instr);
		
		cycles++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x14(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x80(%rbp), %rdx
movl -0x10(%rbp), %ecx
addl $0xf4240, %ecx          # imm = 0xF4240
xorl %eax, %eax
cmpl 0x14(%rdx), %ecx
movb %al, -0x81(%rbp)
jbe 0x940c
movq -0x80(%rbp), %rax
movb 0x2018(%rax), %al
xorb $-0x1, %al
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x941b
jmp 0x957e
movq -0x80(%rbp), %rax
testb $0x1, 0x2032(%rax)
jne 0x9443
movq -0x80(%rbp), %rax
movq %rax, %rdi
movzwl 0x10(%rax), %esi
callq 0x2cd0
movq -0x80(%rbp), %rax
movb $0x1, 0x2032(%rax)
movq -0x80(%rbp), %rax
movw 0x10(%rax), %cx
movw %cx, 0x2030(%rax)
addq $0x2038, %rax           # imm = 0x2038
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9990
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x99c0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x99f0
testb $0x1, %al
jne 0x9489
jmp 0x94cc
leaq -0x48(%rbp), %rdi
callq 0x9a30
movq -0x80(%rbp), %rcx
movw (%rax), %ax
movw %ax, -0x52(%rbp)
movzwl -0x52(%rbp), %eax
movzwl 0x2030(%rcx), %ecx
cmpl %ecx, %eax
jne 0x94bf
movq -0x80(%rbp), %rax
movq %rax, %rdi
movzwl 0x2030(%rax), %esi
callq 0x2cd0
jmp 0x94c1
leaq -0x48(%rbp), %rdi
callq 0x9a50
jmp 0x9476
movq -0x80(%rbp), %rdi
movw 0x10(%rdi), %ax
movw %ax, %cx
addw $0x1, %cx
movw %cx, 0x10(%rdi)
movzwl %ax, %eax
movl %eax, %esi
callq 0x34e0
movq -0x80(%rbp), %rdi
movb %al, -0x11(%rbp)
movq %rdi, %rax
addq $0x18, %rax
movzbl -0x11(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x78(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x9590
movq -0x80(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x93e0
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ivanoleinik[P]archiver/src/huffman.cpp
// Function: HuffTree::_fill_codes(std::shared_ptr<TreeNode>, std::vector<bool, std::allocator<bool>>)
void HuffTree::_fill_codes(std::shared_ptr<TreeNode> root, std::vector<bool> code) {
    if (!root)
        return;
    if (root->is_leaf())
        _codes[root->data] = code;

    auto push = [](std::vector<bool> v, bool x) { v.push_back(x); return v; };
    _fill_codes(root->left, push(code, 1));
    _fill_codes(root->right, push(code, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rsi, -0x110(%rbp)
movq %rdi, %rax
movq -0x110(%rbp), %rdi
movq %rdi, -0x108(%rbp)
movq %rdx, -0x100(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
callq 0x4bf0
testb $0x1, %al
jne 0x379f
jmp 0x38fd
movq -0x108(%rbp), %rdi
callq 0x4c10
movq %rax, %rdi
callq 0x36b0
testb $0x1, %al
jne 0x37b9
jmp 0x37f7
movq -0x108(%rbp), %rdi
movq -0xf8(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x118(%rbp)
callq 0x4c10
movq -0x118(%rbp), %rdi
movzbl (%rax), %eax
movl %eax, %esi
callq 0x4c30
movq -0x100(%rbp), %rsi
movq %rax, %rdi
callq 0x4c50
movq -0x108(%rbp), %rdi
callq 0x4c10
movq %rax, %rsi
addq $0x10, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4db0
movq -0x100(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x4de0
jmp 0x3825
leaq -0x58(%rbp), %rdi
leaq -0x19(%rbp), %rsi
leaq -0x80(%rbp), %rdx
movl $0x1, %ecx
callq 0x39d0
jmp 0x383d
movq -0xf8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x3750
jmp 0x3853
leaq -0x58(%rbp), %rdi
callq 0x4f70
leaq -0x80(%rbp), %rdi
callq 0x4f70
leaq -0x30(%rbp), %rdi
callq 0x4bd0
movq -0x108(%rbp), %rdi
callq 0x4c10
movq %rax, %rsi
addq $0x20, %rsi
leaq -0xa0(%rbp), %rdi
callq 0x4db0
movq -0x100(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
callq 0x4de0
jmp 0x38a2
leaq -0xc8(%rbp), %rdi
leaq -0x19(%rbp), %rsi
leaq -0xf0(%rbp), %rdx
xorl %ecx, %ecx
callq 0x39d0
jmp 0x38bd
movq -0xf8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0xc8(%rbp), %rdx
callq 0x3750
jmp 0x38d9
leaq -0xc8(%rbp), %rdi
callq 0x4f70
leaq -0xf0(%rbp), %rdi
callq 0x4f70
leaq -0xa0(%rbp), %rdi
callq 0x4bd0
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x3952
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x3949
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4f70
leaq -0x80(%rbp), %rdi
callq 0x4f70
leaq -0x30(%rbp), %rdi
callq 0x4bd0
jmp 0x39bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x39af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x39a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x4f70
leaq -0xf0(%rbp), %rdi
callq 0x4f70
leaq -0xa0(%rbp), %rdi
callq 0x4bd0
movq -0x88(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)
// File: ivanoleinik[P]archiver/src/huffman.cpp
// Function: HuffEncode::_serialize(std::ostream&, bool)
void HuffEncode::_serialize(std::ostream &out, bool bit) {
    _buff ^= bit * (1 << _buff_fill);
    _buff_fill++;
    if (_buff_fill == 8) {
        out.write(reinterpret_cast<char*>(&_buff), sizeof(int8_t));
        _encoded_data_size++;
        _buff_fill = 0;
        _buff = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %edx
movq 0x50(%rax), %rcx
movl $0x1, %esi
shll %cl, %esi
movl %esi, %ecx
imull %ecx, %edx
movsbl 0x58(%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x58(%rax)
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
cmpq $0x8, 0x50(%rax)
jne 0x3f66
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x58, %rsi
movl $0x1, %edx
callq 0x32d0
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq $0x0, 0x50(%rax)
movb $0x0, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ivanoleinik[P]archiver/src/huffman.cpp
// Function: HuffEncode::_clear_buff(std::ostream&)
void HuffEncode::_clear_buff(std::ostream &out) {
    if (_buff_fill) {
        out.write(reinterpret_cast<char*>(&_buff), sizeof(int8_t));
        _encoded_data_size++;
        _buff_fill = 0;
        _buff = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x50(%rax)
je 0x3fc1
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x58, %rsi
movl $0x1, %edx
callq 0x32d0
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq $0x0, 0x50(%rax)
movb $0x0, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ivanoleinik[P]archiver/src/huffman.cpp
// Function: HuffEncode::write(std::ostream&)
void HuffEncode::write(std::ostream &out) {
    for (size_t freq : _tree->get_frequencies())
        out.write(reinterpret_cast<char*>(&freq), sizeof(size_t));

    for (unsigned char c : _data) {
        for (bool bit : _codes[c]) {
            _serialize(out, bit);
        }
    }
    _clear_buff(out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
addq $0x20, %rdi
callq 0x57c0
movq %rax, %rdi
callq 0x3e70
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5a30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5a60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5a90
testb $0x1, %al
jne 0x4310
jmp 0x433d
leaq -0x20(%rbp), %rdi
callq 0x5ad0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x8, %edx
callq 0x32d0
leaq -0x20(%rbp), %rdi
callq 0x5af0
jmp 0x42fd
movq -0xb8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x31f0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3140
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5680
testb $0x1, %al
jne 0x4378
jmp 0x4462
leaq -0x40(%rbp), %rdi
callq 0x56c0
movq -0xb8(%rbp), %rdi
movb (%rax), %al
movb %al, -0x49(%rbp)
addq $0x30, %rdi
movzbl -0x49(%rbp), %eax
movl %eax, %esi
callq 0x4c30
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5b10
movl %edx, -0x70(%rbp)
movq %rax, -0x78(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0x60(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5b50
movl %edx, -0x90(%rbp)
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x90(%rbp), %eax
movl %eax, -0x80(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5b70
testb $0x1, %al
jne 0x4401
jmp 0x4452
leaq -0x68(%rbp), %rdi
callq 0x5ba0
movq %rax, -0xb0(%rbp)
movq %rdx, -0xa8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x5be0
movq -0xb8(%rbp), %rdi
andb $0x1, %al
movb %al, -0x99(%rbp)
movq -0x10(%rbp), %rsi
movb -0x99(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x3ee0
leaq -0x68(%rbp), %rdi
callq 0x5c10
jmp 0x43eb
jmp 0x4454
leaq -0x40(%rbp), %rdi
callq 0x56e0
jmp 0x4362
movq -0xb8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3f70
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ruankotovich[P]B-Tree/src/findrec.cpp
// Function: main
int main(int argc, char* argv[])
{
  FILE* blockFile = fopen("files/data.block", "rb+");
  if (blockFile != NULL) {

    fseek(blockFile, sizeof(Block_t), SEEK_END);
    int numberOfArticles = ftell(blockFile) / sizeof(Block_t) - 1;
    rewind(blockFile);
    
    
    int id;

    if(argc > 1){
      id = atoi(argv[1]);
    }else{
      std::cin >> id;
    }

    Article_t article;

    if (getArticleFromHash(id, &article, blockFile)) { // recover an article from the hash
      std::cout << article.toString();
      std::cout << "\n\n> Number of records: " << numberOfArticles << "\n" << "> Number of blocks read: 1 \n"; // since it's a perfect hash
    } else {
      std::cout << "Record not found\n";
    }

  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x9b0, %rsp            # imm = 0x9B0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x1711(%rip), %rdi      # 0x3021
leaq 0x171b(%rip), %rsi      # 0x3032
callq 0x10f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1a59
movq -0x18(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
movl $0x2, %edx
callq 0x10e0
movq -0x18(%rbp), %rdi
callq 0x1030
shrq $0xc, %rax
subq $0x1, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1040
cmpl $0x1, -0x8(%rbp)
jle 0x1973
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1120
movl %eax, -0x20(%rbp)
jmp 0x1983
movq 0x3666(%rip), %rdi      # 0x4fe0
leaq -0x20(%rbp), %rsi
callq 0x1050
leaq -0x96c(%rbp), %rdi
callq 0x1a80
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rdx
leaq -0x96c(%rbp), %rsi
callq 0x2060
testb $0x1, %al
jne 0x19ab
jmp 0x1a44
leaq -0x990(%rbp), %rdi
movq %rdi, -0x9a8(%rbp)
leaq -0x96c(%rbp), %rsi
callq 0x1b50
movq -0x9a8(%rbp), %rsi
movq 0x35fd(%rip), %rdi      # 0x4fd0
callq 0x10b0
jmp 0x19da
leaq -0x990(%rbp), %rdi
callq 0x1060
movq 0x35e3(%rip), %rdi      # 0x4fd0
leaq 0x1642(%rip), %rsi      # 0x3036
callq 0x10d0
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x1140
movq %rax, %rdi
leaq 0x1677(%rip), %rsi      # 0x3085
callq 0x10d0
movq %rax, %rdi
leaq 0x1631(%rip), %rsi      # 0x304e
callq 0x10d0
jmp 0x1a57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x998(%rbp)
movl %eax, -0x99c(%rbp)
leaq -0x990(%rbp), %rdi
callq 0x1060
jmp 0x1a65
movq 0x3585(%rip), %rdi      # 0x4fd0
leaq 0x1619(%rip), %rsi      # 0x306b
callq 0x10d0
jmp 0x1a59
movl -0x4(%rbp), %eax
addq $0x9b0, %rsp            # imm = 0x9B0
popq %rbp
retq
movq -0x998(%rbp), %rdi
callq 0x1150
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ticky[P]ps2iconsys/src/ps2icon_to_obj.cpp
// Function: main
int main(int argc, char* argv[])
{
	ParseCommandLine(argc, argv);

	if(!ps2_input_file) {
		std::cout << "No input file specified.\n" << std::endl;
		PrintHelp(argv[0]);
		exit(1);
	}
	std::cout << "PS2Icon to OBJ Converter  V-1.0\n by Ghulbus Inc.  (http://www.ghulbus-inc.de/)\n" << std::endl;
	if(!obj_output_file)     { obj_output_file = "default.obj"; }
	if(!texture_output_file) { texture_output_file = "default.tga"; }

	PS2Icon* ps2_icon = LoadPS2Icon();

	WriteOBJFile(ps2_icon);

	WriteTextureFile(ps2_icon);
	
	std::cout << "Success :)" << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xf600
cmpq $0x0, 0x80ce(%rip)      # 0x18268
jne 0x101d4
movq 0x7e35(%rip), %rdi      # 0x17fd8
leaq 0x19bf(%rip), %rsi      # 0x11b69
callq 0x21b0
movq %rax, %rdi
movq 0x7e07(%rip), %rsi      # 0x17fc0
callq 0x21e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xf330
movl $0x1, %edi
callq 0x2210
movq 0x7dfd(%rip), %rdi      # 0x17fd8
leaq 0x19a1(%rip), %rsi      # 0x11b83
callq 0x21b0
movq %rax, %rdi
movq 0x7dcf(%rip), %rsi      # 0x17fc0
callq 0x21e0
cmpq $0x0, 0x8072(%rip)      # 0x18270
jne 0x1020e
leaq 0x19cc(%rip), %rax      # 0x11bd3
movq %rax, 0x8062(%rip)      # 0x18270
cmpq $0x0, 0x8062(%rip)      # 0x18278
jne 0x10226
leaq 0x19c0(%rip), %rax      # 0x11bdf
movq %rax, 0x8052(%rip)      # 0x18278
callq 0xf870
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xfae0
movq -0x18(%rbp), %rdi
callq 0xfde0
movq 0x7d90(%rip), %rdi      # 0x17fd8
leaq 0x199c(%rip), %rsi      # 0x11beb
callq 0x21b0
movq %rax, %rdi
movq 0x7d62(%rip), %rsi      # 0x17fc0
callq 0x21e0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: suyash[P]chan/examples/read_chan.cc
// Function: main
int main() {
	chan::unbuffered_chan<int> c;

	std::thread t(read, std::ref(c));

	printf("writing: %d\n", 2);
	c << 2;

	t.join();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
leaq -0x100(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x2660
movq -0x128(%rbp), %rdi
callq 0x26d0
movq %rax, -0x110(%rbp)
leaq -0x78(%rip), %rsi       # 0x2340
leaq -0x108(%rbp), %rdi
leaq -0x110(%rbp), %rdx
callq 0x2700
jmp 0x23cd
leaq 0x1c3a(%rip), %rdi      # 0x400e
xorl %eax, %eax
movl $0x2, %esi
callq 0x2030
jmp 0x23e2
leaq -0xf8(%rbp), %rdi
movl $0x2, -0x120(%rbp)
leaq -0x120(%rbp), %rsi
callq 0x27c0
jmp 0x2401
leaq -0x108(%rbp), %rdi
callq 0x2140
jmp 0x240f
leaq -0x108(%rbp), %rdi
callq 0x27f0
leaq -0x100(%rbp), %rdi
callq 0x2820
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x2464
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x27f0
leaq -0x100(%rbp), %rdi
callq 0x2820
movq -0x118(%rbp), %rdi
callq 0x2160
nopl (%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: template_generator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
fnames_t
template_generator(const fname_t& tmpl, const suint_t imin, const suint_t imax) {
  fnames_t names;
  char *filepath;
  for (size_t i = imin; i < imax; ++i) {
    asprintf(&filepath, tmpl.c_str(), i);
    names.emplace_back(filepath);
    free(filepath);
  }
  return names;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x7df0
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl -0x18(%rbp), %ecx
cmpq %rcx, %rax
jae 0x36e9
movq -0x10(%rbp), %rdi
callq 0x30e0
movq %rax, %rsi
movq -0x30(%rbp), %rdx
xorl %eax, %eax
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3090
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x7e10
jmp 0x36bb
movq -0x28(%rbp), %rdi
callq 0x3350
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3681
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x7e90
jmp 0x3706
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x36fc
movq -0x50(%rbp), %rdi
callq 0x7e90
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3480
nop
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: copy_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void copy_file(const fname_t& from, const fname_t& to) {
  const std::size_t buf_sz = 32768;
  char* buf = new char[buf_sz];

  int infile = ::open(from.c_str(), O_RDONLY, 0);
  int outfile = ::open(to.c_str(), O_CREAT | O_WRONLY | O_TRUNC, 0666);

  ssize_t sz, sz_read=1, sz_write;
  while ((sz_read > 0) &&
         (sz_read = ::read(infile, buf, buf_sz)) > 0) {
    sz_write = 0;
    do {
      if ((sz = ::write(outfile, buf + sz_write,
                        static_cast<size_t>(sz_read - sz_write))) < 0) {
        sz_read = sz; // cause read loop termination
        break;        //  and error reported after closes
      }
      sz_write += sz;
    } while (sz_write < sz_read);
  }

  delete [] buf;
  ::close(infile);
  ::close(outfile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x8000, -0x18(%rbp)    # imm = 0x8000
movl $0x8000, %edi           # imm = 0x8000
callq 0x3030
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
xorl %edx, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x31e0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x31e0
movl %eax, -0x28(%rbp)
movq $0x1, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x41(%rbp)
jle 0x37a3
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0x33c0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
setg %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x37ac
jmp 0x37f8
movq $0x0, -0x40(%rbp)
movl -0x28(%rbp), %edi
movq -0x20(%rbp), %rsi
addq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq -0x40(%rbp), %rdx
callq 0x30a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jge 0x37e0
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x37f6
movq -0x30(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jl 0x37b4
jmp 0x3778
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x380f
movq -0x50(%rbp), %rdi
callq 0x3370
movl -0x24(%rbp), %edi
callq 0x34f0
movl -0x28(%rbp), %edi
callq 0x34f0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AlgoLab[P]bwt-lcp-parallel/bwt_lcp.cpp
// Function: update_LCP(mmap_swriter_t<unsigned char, 4194304ul>&, unsigned char, unsigned long, unsigned long const*)
void update_LCP(
  lcp_writer_t& LCP,
  const strlen_t p,
  const luint_t base_pos,
  const luint_t* Lcount
) {
  LCP.seek(base_pos);
  for (enc_nucl_t sigma = 1; sigma<ALPHSIZE; ++sigma) {
    if (Lcount[sigma]==0) continue;
    LCP.skip();
    for (luint_t rh = 1; rh < Lcount[sigma]; ++rh) {
      LCP.write(p);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8620
movb $0x1, -0x21(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0x6, %eax
jge 0x403f
movq -0x20(%rbp), %rax
movzbl -0x21(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3ff5
jmp 0x4035
movq -0x8(%rbp), %rdi
callq 0x8730
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl -0x21(%rbp), %edx
cmpq (%rcx,%rdx,8), %rax
jae 0x4033
movq -0x8(%rbp), %rdi
movzbl -0x9(%rbp), %esi
callq 0x8780
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4006
jmp 0x4035
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x3fdb
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AlgoLab[P]bwt-lcp-parallel/bwt_lcp.cpp
// Function: compute_Q1_l(unsigned char, std::vector<std::array<unsigned long, 6ul>, std::allocator<std::array<unsigned long, 6ul>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void compute_Q1_l(
    const strlen_t k,
    const occ_countv_t& occv,
    const fnames_t& Q_tpls
) {
  for (strlen_t l = 1; l <= k; ++l) {
    plain_fasta_writer_t Ql(Q_tpls[l]);
    for (enc_nucl_t sigma = 0; sigma < ALPHSIZE; ++sigma) {
      for (luint_t i = 0; i < occv[l][sigma]; ++i) {
        Ql.write(sigma);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movzbl -0x1(%rbp), %ecx
cmpl %ecx, %eax
jg 0x413d
movq -0x18(%rbp), %rdi
movzbl -0x19(%rbp), %eax
movl %eax, %esi
callq 0x8080
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
leaq 0x14fad(%rip), %rdx     # 0x19044
callq 0x8850
movb $0x0, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x6, %eax
jge 0x4127
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x19(%rbp), %eax
movl %eax, %esi
callq 0x88a0
movq %rax, %rdi
movzbl -0x29(%rbp), %eax
movl %eax, %esi
callq 0x88c0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq (%rcx), %rax
jae 0x4118
movzbl -0x29(%rbp), %esi
leaq -0x28(%rbp), %rdi
callq 0x88f0
jmp 0x40f1
jmp 0x40f3
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x40b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8920
jmp 0x4143
jmp 0x411a
movb -0x29(%rbp), %al
addb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x40a0
leaq -0x28(%rbp), %rdi
callq 0x8920
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x406a
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3480
nopl (%rax)
// File: AlgoLab[P]bwt-lcp-parallel/bwt_lcp.cpp
// Function: worker_IX(unsigned int, base_env_t&, bfv_env_t&, std::vector<unsigned long, std::allocator<unsigned long>> const&, std::vector<std::vector<unsigned int, std::allocator<unsigned int>>, std::allocator<std::vector<unsigned int, std::allocator<unsigned int>>>> const&)
void worker_IX(const unsigned idx,
               base_env_t& base_env,
               bfv_env_t& bfv_env,
               const std::vector<luint_t>& this_end_pos,
               const std::vector<std::vector<strnum_t>>& this_end_pos_Qp
               ) {
  const luint_t segm_b = this_end_pos[idx-1];
  const luint_t segm_e = this_end_pos[idx];
  compute_interleave_LCP_segment(base_env, bfv_env, segm_b, segm_e, base_env.p,
                                 this_end_pos_Qp[idx-1], idx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x9660
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %eax
movl %eax, %esi
callq 0x9660
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movb 0x30(%rax), %al
movb %al, -0x39(%rbp)
movq -0x28(%rbp), %rdi
movl -0x4(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x9680
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0x48(%rbp), %rcx
movb -0x39(%rbp), %r8b
movq %rax, %r9
movl -0x4(%rbp), %eax
movzbl %r8b, %r8d
movl %eax, (%rsp)
callq 0x4150
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: optifasta_rnd_reader_t<unsigned char, 2u>::read(unsigned long) const
enc_nucl_t read(const luint_t pos) const {
    const luint_t index = pos / NEL;
    const luint_t offset = pos % 2;
    // printf("r %d %d %d %x\n", pos, index, offset, fpl[index]);
    // printf("c %d %x %d\n", SHIFT, MASK, SHIFT*(NEL-1-offset));
    return (fpl[index] >> (SHIFT*(NEL-1-offset))) & MASK;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
andq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl $0x1, %ecx
subq -0x20(%rbp), %rcx
shlq $0x2, %rcx
sarl %cl, %eax
andl $0xf, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: optifasta_writer_t<unsigned char, 2u>::write(unsigned char const&)
void write(const enc_nucl_t& el) {
    to_write = static_cast<io_nucl_t>((to_write << SHIFT) | (el & MASK));
    ++nel;
    if (nel == NEL) {
      writer.write(to_write);
      nel = 0;
      to_write = static_cast<io_nucl_t>(0);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzbl 0xc(%rax), %ecx
shll $0x4, %ecx
movq -0x10(%rbp), %rdx
movzbl (%rdx), %edx
andl $0xf, %edx
orl %edx, %ecx
movb %cl, 0xc(%rax)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
cmpl $0x2, 0x8(%rax)
jne 0x855c
movq -0x18(%rbp), %rax
movq %rax, %rdi
movzbl 0xc(%rax), %esi
callq 0x88f0
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movb $0x0, 0xc(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: optifasta_writer_t<unsigned char, 2u>::~optifasta_writer_t()
~optifasta_writer_t() {
    if (nel > 0) {
      while (nel < NEL) {
        to_write = static_cast<io_nucl_t>((to_write << SHIFT) | MASK);
        ++nel;
      }
      writer.write(to_write);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x8(%rax)
jbe 0x85c3
jmp 0x858c
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jae 0x85b2
movq -0x10(%rbp), %rax
movzbl 0xc(%rax), %ecx
shll $0x4, %ecx
orl $0xf, %ecx
movb %cl, 0xc(%rax)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x858c
movq -0x10(%rbp), %rdi
movzbl 0xc(%rdi), %esi
callq 0x88f0
jmp 0x85c1
jmp 0x85c3
movq -0x10(%rbp), %rdi
callq 0x8920
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xaf10
nopw (%rax,%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: mmap_swriter_t<unsigned char, 4194304ul>::seek(unsigned long)
void seek(const luint_t new_pos) {
    if ((base == nullptr) | (new_pos < pos) | (new_pos >= pos+L)) {
      if (base != nullptr) munmap(base, L);
      pos = new_pos - (new_pos % L);
      base = static_cast<T*>(
          mmap(nullptr, sizeof(T)*L, PROT_READ | PROT_WRITE, MAP_SHARED, fno,
               static_cast<__off_t>(pos))
      );
      assert(base != MAP_FAILED);
    }
    off = new_pos - pos;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x18(%rdx)
sete %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rdx), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movq 0x8(%rdx), %rdx
addq $0x400000, %rdx         # imm = 0x400000
cmpq %rdx, %rcx
setae %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
cmpl $0x0, %eax
je 0x870f
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x869b
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x3140
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
andq $0x3fffff, %rdx         # imm = 0x3FFFFF
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl (%rax), %r8d
movq 0x8(%rax), %r9
xorl %eax, %eax
movl %eax, %edi
movl $0x400000, %esi         # imm = 0x400000
movl $0x3, %edx
movl $0x1, %ecx
callq 0x34a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq $-0x1, %rcx
cmpq %rcx, 0x18(%rax)
je 0x86ee
jmp 0x870d
leaq 0x10cc8(%rip), %rdi     # 0x193bd
leaq 0x10c5d(%rip), %rsi     # 0x19359
movl $0xd8, %edx
leaq 0x10cc8(%rip), %rcx     # 0x193d0
callq 0x3180
jmp 0x870f
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: mmap_swriter_t<unsigned char, 4194304ul>::write(unsigned char)
void write(const T el) {
    assert(base != nullptr);
    assert(off < L);
    if (base[off] != el) base[off] = el;
    ++off;
    if (off>=L) seek(pos+off);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x87a3
jmp 0x87c2
leaq 0x10c7f(%rip), %rdi     # 0x19429
leaq 0x10ba8(%rip), %rsi     # 0x19359
movl $0xde, %edx
leaq 0x10c7c(%rip), %rcx     # 0x19439
callq 0x3180
movq -0x18(%rbp), %rax
cmpq $0x400000, 0x10(%rax)   # imm = 0x400000
jae 0x87d2
jmp 0x87f1
leaq 0x10cb4(%rip), %rdi     # 0x1948d
leaq 0x10b79(%rip), %rsi     # 0x19359
movl $0xdf, %edx
leaq 0x10c4d(%rip), %rcx     # 0x19439
callq 0x3180
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x10(%rcx), %rcx
movzbl (%rax,%rcx), %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
je 0x881b
movq -0x18(%rbp), %rcx
movb -0x9(%rbp), %dl
movq 0x18(%rcx), %rax
movq 0x10(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
cmpq $0x400000, 0x10(%rax)   # imm = 0x400000
jb 0x8846
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rsi
addq 0x10(%rdi), %rsi
callq 0x8620
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: mmap_writer_t<unsigned char, 6u, 4194304ul>::mmap_writer_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long const*)
mmap_writer_t(const fname_t& fname, const luint_t* new_pos = nullptr) {
    fno = open(fname.c_str(), O_RDWR, 0);
    std::fill_n(pos, N, 0);
    std::fill_n(off, N, 0);
    std::fill_n(bases, N, nullptr);
    seek(new_pos != nullptr ? new_pos : pos);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
movl $0x2, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x31e0
movq -0x30(%rbp), %rdi
movl %eax, (%rdi)
addq $0x8, %rdi
movl $0x0, -0x1c(%rbp)
movl $0x6, %esi
leaq -0x1c(%rbp), %rdx
callq 0xf0a0
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movl $0x0, -0x20(%rbp)
movl $0x6, %esi
leaq -0x20(%rbp), %rdx
callq 0xf0a0
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
movq $0x0, -0x28(%rbp)
movl $0x6, %esi
leaq -0x28(%rbp), %rdx
callq 0xf0f0
cmpq $0x0, -0x18(%rbp)
je 0x8b71
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x8b7d
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x94c0
addq $0x40, %rsp
popq %rbp
retq
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: mmap_reader_t<unsigned char, 4194304ul>::seek(unsigned long)
void seek(const luint_t new_pos) {
    if (base == nullptr || new_pos < pos || new_pos >= pos+L) {
      if (base != nullptr) {
        munmap(base, L);
      }
      pos = new_pos - (new_pos % L);
      base = static_cast<t*>(
        mmap(nullptr, sizeof(t)*L, PROT_READ, MAP_PRIVATE, fno, static_cast<__off_t>(pos))
      );
      assert(base != MAP_FAILED);
    }
    off = new_pos - pos;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x8e19
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jb 0x8e19
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
addq $0x400000, %rcx         # imm = 0x400000
cmpq %rcx, %rax
jb 0x8eaa
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x8e36
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x3140
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
andq $0x3fffff, %rdx         # imm = 0x3FFFFF
subq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl (%rax), %r8d
movq 0x8(%rax), %r9
xorl %eax, %eax
movl %eax, %edi
movl $0x400000, %esi         # imm = 0x400000
movl $0x1, %edx
movl $0x2, %ecx
callq 0x34a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq $-0x1, %rcx
cmpq %rcx, 0x18(%rax)
je 0x8e89
jmp 0x8ea8
leaq 0x1052d(%rip), %rdi     # 0x193bd
leaq 0x104c2(%rip), %rsi     # 0x19359
movl $0x133, %edx            # imm = 0x133
leaq 0x106cd(%rip), %rcx     # 0x19570
callq 0x3180
jmp 0x8eaa
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq 0x8(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: mmap_writer_t<unsigned char, 6u, 4194304ul>::seek(unsigned int, unsigned long)
void seek(const suint_t i, const luint_t new_pos) {
    if (bases[i] == nullptr || new_pos < pos[i] || new_pos >= pos[i]+L) {
      if (bases[i] != nullptr) {
        munmap(bases[i], L);
      }
      pos[i] = new_pos - (new_pos % L);
      bases[i] = static_cast<t*>(
          mmap(nullptr, sizeof(t)*L, PROT_READ | PROT_WRITE, MAP_SHARED, fno,
               static_cast<__off_t>(pos[i]))
      );
      assert(bases[i] != MAP_FAILED);
    }
    off[i] = new_pos - pos[i];
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
cmpq $0x0, 0x68(%rax,%rcx,8)
je 0x8f18
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
cmpq 0x8(%rcx,%rdx,8), %rax
jb 0x8f18
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movq 0x8(%rcx,%rdx,8), %rcx
addq $0x400000, %rcx         # imm = 0x400000
cmpq %rcx, %rax
jb 0x8fc1
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq $0x0, 0x68(%rax,%rcx,8)
je 0x8f3d
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movq 0x68(%rax,%rcx,8), %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x3140
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rcx
andq $0x3fffff, %rcx         # imm = 0x3FFFFF
subq %rcx, %rdx
movl -0xc(%rbp), %ecx
movq %rdx, 0x8(%rax,%rcx,8)
movl (%rax), %r8d
movl -0xc(%rbp), %ecx
movq 0x8(%rax,%rcx,8), %r9
xorl %eax, %eax
movl %eax, %edi
movl $0x400000, %esi         # imm = 0x400000
movl $0x3, %edx
movl $0x1, %ecx
callq 0x34a0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movq %rdx, 0x68(%rax,%rcx,8)
movl -0xc(%rbp), %ecx
movq $-0x1, %rdx
cmpq %rdx, 0x68(%rax,%rcx,8)
je 0x8fa0
jmp 0x8fbf
leaq 0x10621(%rip), %rdi     # 0x195c8
leaq 0x103ab(%rip), %rsi     # 0x19359
movl $0x93, %edx
leaq 0x10625(%rip), %rcx     # 0x195df
callq 0x3180
jmp 0x8fc1
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdx
movl -0xc(%rbp), %ecx
subq 0x8(%rax,%rcx,8), %rdx
movl -0xc(%rbp), %ecx
movq %rdx, 0x38(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: mmap_reader_t<unsigned char, 4194304ul>::read()
T read() {
    assert(base != nullptr);
    assert(off < L);
    const T res = base[off];
    ++off;
    if (off>=L) seek(pos+off);
    return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x8ffd
jmp 0x901c
leaq 0x10425(%rip), %rdi     # 0x19429
leaq 0x1034e(%rip), %rsi     # 0x19359
movl $0x11d, %edx            # imm = 0x11D
leaq 0x10639(%rip), %rcx     # 0x19650
callq 0x3180
movq -0x18(%rbp), %rax
cmpq $0x400000, 0x10(%rax)   # imm = 0x400000
jae 0x902c
jmp 0x904b
leaq 0x1045a(%rip), %rdi     # 0x1948d
leaq 0x1031f(%rip), %rsi     # 0x19359
movl $0x11e, %edx            # imm = 0x11E
leaq 0x1060a(%rip), %rcx     # 0x19650
callq 0x3180
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rax), %rdx
movb (%rcx,%rdx), %cl
movb %cl, -0x9(%rbp)
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
cmpq $0x400000, 0x10(%rax)   # imm = 0x400000
jb 0x9084
movq -0x18(%rbp), %rdi
movq 0x8(%rdi), %rsi
addq 0x10(%rdi), %rsi
callq 0x8dd0
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: mmap_writer_t<unsigned char, 6u, 4194304ul>::write(unsigned int, unsigned char)
void write(const suint_t i, const T el) {
    assert(i<N);
    assert(bases[i] != nullptr);
    assert(off[i] < L);
    if (bases[i][off[i]] != el) bases[i][off[i]] = el;
    ++off[i];
    if (off[i]>=L) seek(i, pos[i]+off[i]);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x6, -0xc(%rbp)
jae 0x9254
jmp 0x9273
leaq 0x1043d(%rip), %rdi     # 0x19698
leaq 0x100f7(%rip), %rsi     # 0x19359
movl $0x9f, %edx
leaq 0x1042e(%rip), %rcx     # 0x1969c
callq 0x3180
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq $0x0, 0x68(%rax,%rcx,8)
je 0x9284
jmp 0x92a3
leaq 0x1047d(%rip), %rdi     # 0x19708
leaq 0x100c7(%rip), %rsi     # 0x19359
movl $0xa0, %edx
leaq 0x103fe(%rip), %rcx     # 0x1969c
callq 0x3180
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq $0x400000, 0x38(%rax,%rcx,8) # imm = 0x400000
jae 0x92b7
jmp 0x92d6
leaq 0x1045e(%rip), %rdi     # 0x1971c
leaq 0x10094(%rip), %rsi     # 0x19359
movl $0xa1, %edx
leaq 0x103cb(%rip), %rcx     # 0x1969c
callq 0x3180
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movq 0x68(%rcx,%rax,8), %rax
movl -0xc(%rbp), %edx
movq 0x38(%rcx,%rdx,8), %rcx
movzbl (%rax,%rcx), %eax
movzbl -0xd(%rbp), %ecx
cmpl %ecx, %eax
je 0x9310
movq -0x18(%rbp), %rcx
movb -0xd(%rbp), %dl
movl -0xc(%rbp), %eax
movq 0x68(%rcx,%rax,8), %rax
movl -0xc(%rbp), %esi
movq 0x38(%rcx,%rsi,8), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq 0x38(%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, 0x38(%rax,%rcx,8)
movl -0xc(%rbp), %ecx
cmpq $0x400000, 0x38(%rax,%rcx,8) # imm = 0x400000
jb 0x934f
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0xc(%rbp), %eax
movq 0x8(%rdi,%rax,8), %rdx
movl -0xc(%rbp), %eax
addq 0x38(%rdi,%rax,8), %rdx
callq 0x8ec0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: AlgoLab[P]bwt-lcp-parallel/bwt_lcp.cpp
// Function: compute_Lpos(unsigned long*, unsigned long, unsigned long const*)
inline
bool compute_Lpos(
  luint_t* const Lpos,
  const luint_t b,
  const luint_t* Lcount
) {
  Lpos[0] = b;
  for (enc_nucl_t sigma = 1; sigma<ALPHSIZE; ++sigma) {
    Lpos[sigma] = Lpos[sigma-1] + Lcount[sigma-1];
  }
  bool this_has_pseg_wider_than_1 = false;
  for (enc_nucl_t sigma = 1; sigma<ALPHSIZE; ++sigma) {
    this_has_pseg_wider_than_1 |= (Lcount[sigma] > 1);
  }
  return this_has_pseg_wider_than_1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x6, %eax
jge 0x93c2
movq -0x8(%rbp), %rax
movzbl -0x19(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movzbl -0x19(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movzbl -0x19(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x937f
movb $0x0, -0x1a(%rbp)
movb $0x1, -0x1b(%rbp)
movzbl -0x1b(%rbp), %eax
cmpl $0x6, %eax
jge 0x9407
movq -0x18(%rbp), %rax
movzbl -0x1b(%rbp), %ecx
cmpq $0x1, (%rax,%rcx,8)
seta %al
andb $0x1, %al
movzbl %al, %ecx
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
movb -0x1b(%rbp), %al
addb $0x1, %al
movb %al, -0x1b(%rbp)
jmp 0x93ca
movb -0x1a(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: mmap_writer_t<unsigned char, 6u, 4194304ul>::~mmap_writer_t()
~mmap_writer_t() {
    for (suint_t i= 0; i < N; ++i) {
      if (bases[i] != nullptr) munmap(bases[i], L);
      bases[i] = nullptr;
    }
    if (fno >= 0) close(fno);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x6, -0xc(%rbp)
jae 0x95d1
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq $0x0, 0x68(%rax,%rcx,8)
je 0x95b6
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq 0x68(%rax,%rcx,8), %rdi
movl $0x400000, %esi         # imm = 0x400000
callq 0x3140
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movq $0x0, 0x68(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x958b
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x95e9
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0x34f0
jmp 0x95e7
jmp 0x95e9
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xaf10
nopw (%rax,%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: seq_reader_t<unsigned char>::seq_reader_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
seq_reader_t(const fname_t& fname, const char* mode = "rb") {
    f = fopen(fname.c_str(), mode);
    assert(f != nullptr);
    int fno = fileno(f);
    posix_fadvise(fno, 0, 0, POSIX_FADV_SEQUENTIAL);
    posix_fadvise(fno, 0, 0, POSIX_FADV_WILLNEED);
    read();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3340
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x96e3
jmp 0x9702
leaq 0xfc62(%rip), %rdi      # 0x1934c
leaq 0xfc68(%rip), %rsi      # 0x19359
movl $0x20, %edx
leaq 0x1002a(%rip), %rcx     # 0x19727
callq 0x3180
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x32f0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x2, %ecx
movq %rdx, %rsi
callq 0x31f0
movl -0x1c(%rbp), %edi
xorl %eax, %eax
movl %eax, %edx
movl $0x3, %ecx
movq %rdx, %rsi
callq 0x31f0
movq -0x28(%rbp), %rdi
callq 0x97a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: void create_empty_file<unsigned char>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
void create_empty_file(const fname_t& fname, const luint_t n) {
  int fno = creat(fname.c_str(), 0666);
#ifdef FALLOC_FL_ZERO_RANGE
  fallocate(fno, FALLOC_FL_ZERO_RANGE, 0, static_cast<__off_t>(n*sizeof(T)));
#else
  fallocate(fno, 0, 0, static_cast<__off_t>(n*sizeof(T)));
#endif
  close(fno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30e0
movq %rax, %rdi
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x31b0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rcx
shlq $0x0, %rcx
movl $0x10, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3220
movl -0x14(%rbp), %edi
callq 0x34f0
addq $0x20, %rsp
popq %rbp
retq
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: seq_reader_t<unsigned char>::read()
T read() {
    T res = el;
    if (sizeof(T) == sizeof(unsigned char)) {
      el = static_cast<T>(getc_unlocked(f));
    } else {
      fread_unlocked(&el, sizeof(T), 1, f);
    }
    return res;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb 0x8(%rax), %cl
movb %cl, -0x9(%rbp)
movq (%rax), %rdi
callq 0x34e0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movb %cl, 0x8(%rax)
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: optifasta_reader_t<unsigned char, 2u>::advance()
void advance() {
    if (nel == 0 && !iseof) {
      if (reader.has_next()) {
        io_el = reader.read();
        nel = NEL;
      } else {
        iseof = true;
      }
    }
    if (!iseof) {
      result = (io_el & MASK) >> ((NEL - 1) * SHIFT);
      io_el <<= SHIFT;
      --nel;
      if (result == EOFEL) {
        nel = 0;
        iseof = true;
      }
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x10(%rax)
jne 0xe628
movq -0x10(%rbp), %rax
testb $0x1, 0x16(%rax)
jne 0xe628
movq -0x10(%rbp), %rdi
callq 0xe5a0
testb $0x1, %al
jne 0xe603
jmp 0xe61e
movq -0x10(%rbp), %rdi
callq 0x97a0
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x14(%rax)
movl $0x2, 0x10(%rax)
jmp 0xe626
movq -0x10(%rbp), %rax
movb $0x1, 0x16(%rax)
jmp 0xe628
movq -0x10(%rbp), %rax
testb $0x1, 0x16(%rax)
jne 0xe673
movq -0x10(%rbp), %rax
movzbl 0x14(%rax), %ecx
andl $0xf0, %ecx
sarl $0x4, %ecx
movb %cl, 0x15(%rax)
movzbl 0x14(%rax), %ecx
shll $0x4, %ecx
movb %cl, 0x14(%rax)
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movzbl 0x15(%rax), %eax
cmpl $0xf, %eax
jne 0xe671
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movb $0x1, 0x16(%rax)
jmp 0xe673
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: AlgoLab[P]bwt-lcp-parallel/./io.hpp
// Function: seq_reader_t<unsigned int>::operator=(seq_reader_t<unsigned int>&&)
my_t& operator=(my_t&& other) {
    if (f != nullptr) fclose(f);
    f = other.f;
    el = other.el;
    other.f = nullptr;
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0xe8aa
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x32a0
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq $0x0, (%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: walker-xian[P]teisye/heapperf/heapperf.cpp
// Function: main
int main(int argc, char **argv)
{
    try
    {
        application app;

        app.parse_args(argc, argv);
        app.run();
    }
    catch (const std::exception& e)
    {
        cerr << e.what() << endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x5b70
movq -0xb8(%rbp), %rdi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x5bd0
jmp 0x5991
leaq -0x98(%rbp), %rdi
callq 0x6350
jmp 0x599f
jmp 0x5a17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5a3d
movq -0xa0(%rbp), %rdi
callq 0x5160
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq 0x515f9(%rip), %rdi     # 0x56fe8
callq 0x53e0
movq %rax, -0xc0(%rbp)
jmp 0x59fd
movq -0xc0(%rbp), %rdi
movq 0x51555(%rip), %rsi     # 0x56f60
callq 0x5420
jmp 0x5a12
callq 0x55c0
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
callq 0x55c0
jmp 0x5a3b
jmp 0x5a3d
movq -0xa0(%rbp), %rdi
callq 0x5680
movq %rax, %rdi
callq 0x7030
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)