LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_ORA(unsigned short)
void mos6502::Op_ORA(uint16_t src)
{
	uint8_t m = Read(src);
	m = A | m;
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    A = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %esi
callq 0x2abc
orb (%rbx), %al
movb 0x12(%rbx), %cl
js 0x4dfd
andb $0x7f, %cl
testb %al, %al
jne 0x4e00
orb $0x2, %cl
jmp 0x4e03
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rbx)
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_PLA(unsigned short)
void mos6502::Op_PLA(uint16_t src)
{
	A = StackPop();
	SET_NEGATIVE(A & 0x80);
    SET_ZERO(!A);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5526
movb %al, (%rbx)
movb 0x12(%rbx), %cl
testb %al, %al
js 0x4e53
andb $0x7f, %cl
testb %al, %al
jne 0x4e56
orb $0x2, %cl
jmp 0x4e59
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_ROL(unsigned short)
void mos6502::Op_ROL(uint16_t src)
{
	uint16_t m = Read(src);
    m <<= 1;
    if (IF_CARRY()) m |= 0x01;
    SET_CARRY(m > 0xFF);
    m &= 0xFF;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    Write(src, m);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, %r14d
movq %r14, %rsi
callq 0x2abc
leal (%rax,%rax), %ecx
movb 0x12(%rbx), %dl
movl %edx, %esi
andb $0x1, %sil
andb $0x7c, %dl
shrb $0x7, %al
orb %dl, %al
orb %cl, %sil
andb $-0x80, %cl
orb %al, %cl
testb %sil, %sil
sete %al
addb %al, %al
orb %cl, %al
movb %al, 0x12(%rbx)
movzbl %sil, %edx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x2ed0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_RTI(unsigned short)
void mos6502::Op_RTI(uint16_t src)
{
	uint8_t lo, hi;
	
	status = StackPop();
	
	lo = StackPop();
	hi = StackPop();
	
	pc = (hi << 8) | lo;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5526
movb %al, 0x12(%rbx)
movq %rbx, %rdi
callq 0x5526
movl %eax, %r14d
movq %rbx, %rdi
callq 0x5526
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %ecx
orl %eax, %ecx
movw %cx, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_SBC(unsigned short)
void mos6502::Op_SBC(uint16_t src)
{
	uint8_t m = Read(src);
	unsigned int tmp = A - m - (IF_CARRY() ? 0 : 1);
	SET_NEGATIVE(tmp & 0x80);
	SET_ZERO(!(tmp & 0xFF));
    SET_OVERFLOW(((A ^ tmp) & 0x80) && ((A ^ m) & 0x80));
	
    if (IF_DECIMAL())
    {
    	if ( ((A & 0x0F) - (IF_CARRY() ? 0 : 1)) < (m & 0x0F)) tmp -= 6;
        if (tmp > 0x99)
        {
        	tmp -= 0x60;
        }
    }
    SET_CARRY(tmp < 0x100);
    A = (tmp & 0xFF);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %esi
callq 0x2abc
movzbl (%rbx), %ecx
movzbl %al, %edx
movzbl 0x12(%rbx), %esi
movl %esi, %edi
notl %edi
andl $0x1, %edi
addl %edx, %edi
movl %ecx, %eax
subl %edi, %eax
andb $0x3d, %sil
movl %eax, %edi
andb $-0x80, %dil
orb %sil, %dil
testb %al, %al
sete %r8b
addb %r8b, %r8b
orb %dil, %r8b
movl %eax, %esi
xorl %ecx, %esi
movl %ecx, %edi
xorl %edx, %edi
shrb %sil
andb $0x40, %sil
xorl %r9d, %r9d
cmpl $0x80, %edi
movzbl %sil, %esi
cmovbl %r9d, %esi
orb %r8b, %sil
testb $0x8, %sil
je 0x5092
movzbl %sil, %edi
andl $0xf, %ecx
notl %edi
andl $0x1, %edi
subl %edi, %ecx
andl $0xf, %edx
leal -0x6(%rax), %edi
cmpl %edx, %ecx
cmovgel %eax, %edi
leal -0x60(%rdi), %eax
cmpl $0x9a, %edi
cmovbl %edi, %eax
cmpl $0x100, %eax            # imm = 0x100
setb %cl
andb $-0x2, %sil
orb %cl, %sil
movb %sil, 0x12(%rbx)
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_TAX(unsigned short)
void mos6502::Op_TAX(uint16_t src)
{
	uint8_t m = A;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	X = m;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
movb 0x12(%rdi), %cl
testb %al, %al
js 0x5115
andb $0x7f, %cl
testb %al, %al
jne 0x5118
orb $0x2, %cl
jmp 0x511b
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, 0x1(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_TAY(unsigned short)
void mos6502::Op_TAY(uint16_t src)
{
	uint8_t m = A;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	Y = m;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
movb 0x12(%rdi), %cl
testb %al, %al
js 0x513d
andb $0x7f, %cl
testb %al, %al
jne 0x5140
orb $0x2, %cl
jmp 0x5143
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, 0x2(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_TXA(unsigned short)
void mos6502::Op_TXA(uint16_t src)
{
	uint8_t m = X;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	A = m;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x1(%rdi), %al
movb 0x12(%rdi), %cl
testb %al, %al
js 0x518c
andb $0x7f, %cl
testb %al, %al
jne 0x518f
orb $0x2, %cl
jmp 0x5192
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_TYA(unsigned short)
void mos6502::Op_TYA(uint16_t src)
{
	uint8_t m = Y;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	A = m;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x2(%rdi), %al
movb 0x12(%rdi), %cl
testb %al, %al
js 0x51c2
andb $0x7f, %cl
testb %al, %al
jne 0x51c5
orb $0x2, %cl
jmp 0x51c8
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Reset()
void mos6502::Reset()
{
	A = 0x00;
	Y = 0x00;
	X = 0x00;
	
	pc = (Read(rstVectorH) << 8) + Read(rstVectorL); // load PC from reset vector
		
    sp = 0xFD;
    
    status |= CONSTANT;
    
	cycles = 6; // according to the datasheet, the reset routine takes 6 clock cycles

	illegalOpcode = false;
	
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andw $0x0, (%rdi)
xorl %r14d, %r14d
movb %r14b, 0x2(%rdi)
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x2abc
movzbl %al, %r15d
shll $0x8, %r15d
movl $0xfffc, %esi           # imm = 0xFFFC
movq %rbx, %rdi
callq 0x2abc
movzbl %al, %eax
orl %r15d, %eax
movw %ax, 0x10(%rbx)
movq $0xfd, 0x8(%rbx)
orb $0x20, 0x12(%rbx)
movl $0x6, 0x14(%rbx)
movb %r14b, 0x2018(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::IRQ()
void mos6502::IRQ()
{
	if(!IF_INTERRUPT())
	{
		SET_BREAK(0);
		StackPush((pc >> 8) & 0xFF);
		StackPush(pc & 0xFF);
		StackPush(status);
		SET_INTERRUPT(1);
		pc = (Read(irqVectorH) << 8) + Read(irqVectorL);
	}
	return;
}

// Assembly:
movb 0x12(%rdi), %al
testb $0x4, %al
jne 0x52a1
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andb $-0x15, %al
movb %al, 0x12(%rdi)
movzbl 0x11(%rdi), %esi
callq 0x54ee
movzbl 0x10(%rbx), %esi
movq %rbx, %rdi
callq 0x54ee
movzbl 0x12(%rbx), %esi
movq %rbx, %rdi
callq 0x54ee
orb $0x4, 0x12(%rbx)
movl $0xffff, %esi           # imm = 0xFFFF
movq %rbx, %rdi
callq 0x2abc
movzbl %al, %r14d
shll $0x8, %r14d
movl $0xfffe, %esi           # imm = 0xFFFE
movq %rbx, %rdi
callq 0x2abc
movzbl %al, %eax
orl %r14d, %eax
movw %ax, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::NMI()
void mos6502::NMI()
{
	SET_BREAK(0);
	StackPush((pc >> 8) & 0xFF);
	StackPush(pc & 0xFF);
	StackPush(status);
	SET_INTERRUPT(1);
	pc = (Read(nmiVectorH) << 8) + Read(nmiVectorL);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andb $-0x11, 0x12(%rdi)
movzbl 0x11(%rdi), %esi
callq 0x54ee
movzbl 0x10(%rbx), %esi
movq %rbx, %rdi
callq 0x54ee
movzbl 0x12(%rbx), %esi
movq %rbx, %rdi
callq 0x54ee
orb $0x4, 0x12(%rbx)
movl $0xfffb, %esi           # imm = 0xFFFB
movq %rbx, %rdi
callq 0x2abc
movzbl %al, %r14d
shll $0x8, %r14d
movl $0xfffa, %esi           # imm = 0xFFFA
movq %rbx, %rdi
callq 0x2abc
movzbl %al, %eax
orl %r14d, %eax
movw %ax, 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %eax
leal 0xf4240(%rax), %r15d
leaq 0x18(%rdi), %r12
cmpl %eax, %r15d
jbe 0x53f7
cmpb $0x0, 0x2018(%rbx)
jne 0x53f7
cmpb $0x0, 0x2032(%rbx)
jne 0x5357
movzwl 0x10(%rbx), %esi
movq %rbx, %rdi
callq 0x264c
movb $0x1, 0x2032(%rbx)
movzwl 0x10(%rbx), %eax
movw %ax, 0x2030(%rbx)
movq 0x2038(%rbx), %r14
movq 0x2040(%rbx), %r13
cmpq %r13, %r14
je 0x5393
movzwl (%r14), %eax
cmpw 0x2030(%rbx), %ax
jne 0x538d
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x264c
addq $0x2, %r14
jmp 0x5370
movzwl 0x10(%rbx), %esi
leal 0x1(%rsi), %eax
movw %ax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x2abc
movzbl %al, %ecx
shll $0x5, %ecx
movq (%r12,%rcx), %rax
movq 0x10(%r12,%rcx), %r13
movq 0x18(%r12,%rcx), %r14
movq 0x8(%r12,%rcx), %rdi
addq %rbx, %rdi
testb $0x1, %al
je 0x53ce
movq (%rdi), %rcx
movq -0x1(%rcx,%rax), %rax
callq *%rax
addq %rbx, %r14
testb $0x1, %r13b
je 0x53e1
movq (%r14), %rcx
movq -0x1(%rcx,%r13), %r13
movzwl %ax, %esi
movq %r14, %rdi
callq *%r13
movl 0x14(%rbx), %eax
incl %eax
movl %eax, 0x14(%rbx)
jmp 0x5325
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r12
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x2604
movq %rdx, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rax
orq 0x10(%rsi), %rax
jne 0x2534
movzbl (%rsi), %eax
imulq $0x28, %rax, %rdi
addq 0x38(%r14), %rdi
movq %r15, %rsi
callq 0x2f1a
movq (%r12), %rsi
leaq 0x20(%rsp), %rbx
addq $0x10, %rsi
leaq 0x18(%rsp), %rdi
callq 0x33a6
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0x2fb0
leaq 0xa0(%rsp), %rdi
leaq 0x78(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x2662
leaq 0x18(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
movq %r14, %rdi
callq 0x24f0
leaq 0x10(%rsp), %rbx
leaq 0xa0(%rsp), %rdi
callq 0x302c
leaq 0x78(%rsp), %rdi
callq 0x302c
leaq 0x20(%rsp), %rdi
callq 0x3398
movq (%r12), %rsi
addq $0x20, %rsi
leaq 0x8(%rsp), %rdi
callq 0x33a6
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x2fb0
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x2662
leaq 0x8(%rsp), %rsi
leaq 0x50(%rsp), %rdx
movq %r14, %rdi
callq 0x24f0
leaq 0x50(%rsp), %rdi
callq 0x302c
leaq 0x28(%rsp), %rdi
callq 0x302c
leaq 0x10(%rsp), %rdi
callq 0x3398
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x302c
jmp 0x2625
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x2648
jmp 0x264f
movq %rax, %r14
leaq 0xa0(%rsp), %rdi
callq 0x302c
jmp 0x2643
movq %rax, %r14
leaq 0x78(%rsp), %rdi
callq 0x302c
jmp 0x2652
movq %rax, %r14
movq %rbx, %rdi
callq 0x3398
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x50(%rdi), %rcx
shll %cl, %edx
xorb %dl, 0x58(%rdi)
incq %rcx
movq %rcx, 0x50(%rdi)
cmpq $0x8, %rcx
jne 0x297c
pushq %rbx
movq %rdi, %rbx
leaq 0x58(%rdi), %rax
pushq $0x1
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21d0
incq 0x48(%rbx)
andq $0x0, 0x50(%rbx)
movb $0x0, 0x58(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x0, 0x50(%rdi)
je 0x29a9
pushq %rbx
movq %rdi, %rbx
leaq 0x58(%rdi), %rax
pushq $0x1
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x21d0
incq 0x48(%rbx)
andq $0x0, 0x50(%rbx)
movb $0x0, 0x58(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ivanoleinik[P]archiver/src/huffman.cpp
// Function: HuffEncode::HuffEncode(std::istream&)
HuffEncode::HuffEncode(std::istream &in) {
    in.seekg(0, std::ios::end);
    _data.reserve(in.tellg());
    in.seekg(0, std::ios::beg);
    _data.assign((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());

    std::vector<std::size_t> frequencies(256, 0);
    for (unsigned char c : _data)
        frequencies[c]++;
    _tree = std::make_shared<HuffTree>(frequencies);
    _codes = _tree->get_codes();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x30(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x49(%rdi)
pushq $0x2
popq %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x21e0
movq %r15, %rdi
callq 0x22a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2250
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21e0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq 0xe8(%r15,%rax), %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x3132
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x100, %esi            # imm = 0x100
callq 0x3168
leaq 0x20(%rbx), %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x18(%rsp), %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
je 0x2a6c
movzbl (%rax,%rsi), %edi
incq (%rdx,%rdi,8)
incq %rsi
jmp 0x2a5a
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x31be
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x4a8e
leaq 0x10(%rsp), %rdi
callq 0x3398
movq (%r15), %rsi
addq $0x38, %rsi
movq %r14, %rdi
callq 0x31dc
leaq 0x18(%rsp), %rdi
callq 0x39fc
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2ab7
movq %rax, %r15
leaq 0x18(%rsp), %rdi
callq 0x39fc
jmp 0x2acd
jmp 0x2aca
jmp 0x2aca
movq %rax, %r15
movq %r14, %rdi
callq 0x3110
leaq 0x28(%rbx), %rdi
callq 0x3398
movq %rbx, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbp
leaq 0x10(%rsp), %r15
pushq $0x8
popq %r12
cmpq %rbp, %r13
je 0x2b38
movq (%r13), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x21d0
addq $0x8, %r13
jmp 0x2b16
movq (%r14), %rax
movq 0x8(%r14), %rcx
addq %rax, %rcx
movq %rcx, (%rsp)
cmpq (%rsp), %rax
je 0x2bb4
movq %rax, 0x8(%rsp)
movzbl (%rax), %eax
movq 0x30(%r14), %rcx
imulq $0x28, %rax, %rax
movq (%rcx,%rax), %r13
movq 0x10(%rcx,%rax), %r12
movl 0x18(%rcx,%rax), %r15d
xorl %ebp, %ebp
jmp 0x2ba0
movq (%r13), %rax
xorl %edx, %edx
btq %rbp, %rax
setb %dl
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2942
xorl %eax, %eax
cmpl $0x3f, %ebp
leal 0x1(%rbp), %ecx
sete %al
leaq (%r13,%rax,8), %r13
movl $0x0, %eax
cmovel %eax, %ecx
movl %ecx, %ebp
cmpq %r12, %r13
jne 0x2b6e
cmpl %r15d, %ebp
jne 0x2b6e
movq 0x8(%rsp), %rax
incq %rax
jmp 0x2b46
movq %r14, %rdi
movq %rbx, %rsi
callq 0x297e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x978, %rsp            # imm = 0x978
movq %rsi, %r15
movl %edi, %ebp
leaq 0x998(%rip), %rdi       # 0x2021
leaq 0x9a2(%rip), %rsi       # 0x2032
callq 0x10e0
testq %rax, %rax
je 0x1785
movq %rax, %r14
pushq $0x2
popq %rdx
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
callq 0x10d0
movq %r14, %rdi
callq 0x1030
movq %rax, %rbx
movq %r14, %rdi
callq 0x1040
cmpl $0x2, %ebp
jl 0x16d8
movq 0x8(%r15), %rdi
callq 0x1110
movl %eax, 0x4(%rsp)
jmp 0x16e9
movq 0x2901(%rip), %rdi      # 0x3fe0
leaq 0x4(%rsp), %rsi
callq 0x1060
leaq 0x2c(%rsp), %r15
movq %r15, %rdi
callq 0x17ac
movl 0x4(%rsp), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a94
testb %al, %al
je 0x1772
leaq 0x8(%rsp), %r14
leaq 0x2c(%rsp), %rsi
movq %r14, %rdi
callq 0x1838
movq 0x28ae(%rip), %rdi      # 0x3fd0
movq %r14, %rsi
callq 0x10b0
shrq $0xc, %rbx
decl %ebx
leaq 0x8(%rsp), %rdi
callq 0x1050
movq 0x288f(%rip), %rdi      # 0x3fd0
leaq 0x8ee(%rip), %rsi       # 0x2036
callq 0x10c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x1140
leaq 0x927(%rip), %rsi       # 0x2085
movq %rax, %rdi
callq 0x10c0
leaq 0x8e1(%rip), %rsi       # 0x204e
movq %rax, %rdi
jmp 0x1780
movq 0x2857(%rip), %rdi      # 0x3fd0
leaq 0x8eb(%rip), %rsi       # 0x206b
callq 0x10c0
xorl %eax, %eax
addq $0x978, %rsp            # imm = 0x978
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1150
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/equal.cc
// Function: main
int main()
{
	list<const char *> roster1;
	vector<string> roster2;
	roster2 = {"hello", "so long", "tata"};
	roster1 = {"hello", "so long"};

	auto b = 
	// roster2 should have at least as many elements as roster1
	equal(roster1.cbegin(), roster1.cend(), roster2.cbegin());

	(b) ? cout << "true" : cout << "false";
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
leaq -0x58(%rbp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
leaq 0xd03(%rip), %rbx       # 0x2004
leaq -0xb8(%rbp), %r14
leaq -0x23(%rbp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1070
leaq -0x98(%rbp), %r12
leaq 0xce5(%rip), %r15       # 0x200a
leaq -0x22(%rbp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1070
leaq -0x78(%rbp), %r12
leaq 0xcd3(%rip), %rsi       # 0x2012
leaq -0x21(%rbp), %rdx
movq %r12, %rdi
callq 0x1070
leaq -0x58(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x152a
pushq $0x40
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0xb8, %rdi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x1363
leaq -0xa8(%rbp), %rdx
movq %rbx, -0x10(%rdx)
movq %r15, -0x8(%rdx)
leaq -0x58(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x17d0
leaq -0x58(%rbp), %rsi
movq (%rsi), %rdi
movq -0x40(%rbp), %rdx
callq 0x1a64
leaq 0xc64(%rip), %rcx       # 0x2017
leaq 0xc62(%rip), %rsi       # 0x201c
testb %al, %al
cmovneq %rcx, %rsi
movq 0x2c11(%rip), %rdi      # 0x3fd8
callq 0x1100
movq 0x2c05(%rip), %rdi      # 0x3fd8
callq 0x10a0
leaq -0x40(%rbp), %rdi
callq 0x1458
leaq -0x58(%rbp), %rdi
callq 0x1484
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x143b
movq %rax, %rbx
pushq $0x40
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0xb8, %rdi
callq 0x1090
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x1405
jmp 0x143e
jmp 0x1423
movq %rax, %rbx
addq $-0x20, %r12
movq %r12, %rdi
callq 0x1090
cmpq %r14, %r12
jne 0x1426
jmp 0x143e
jmp 0x143b
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x1458
leaq -0x58(%rbp), %rdi
callq 0x1484
movq %rbx, %rdi
callq 0x1180
// File: /workspace/github_cpp_makefile_star2_O2/ticky[P]ps2iconsys/src/ps2icon_to_obj.cpp
// Function: ParseCommandLine(int, char**)
void ParseCommandLine(int argc, char* argv[])
{
	for(int i=1; i<argc; i++) {
		//Flag parameters:
		if( (strcmp( argv[i], "-h" ) == 0) || (strcmp( argv[i], "--help" ) == 0) ) {
			PrintHelp(argv[0]);
			exit(0);
		} else if( (strcmp( argv[i], "-v" ) == 0) || (strcmp( argv[i], "--verbose" ) == 0) ) {
			verbose_output = true;
		} else if(i < argc-1) {
		//Parameters with 1 argument
			if( (strcmp( argv[i], "-f" ) == 0) || (strcmp( argv[i], "--input-file" ) == 0) ) {
				ps2_input_file = argv[++i];
			} else if( (strcmp( argv[i], "-o" ) == 0) || (strcmp( argv[i], "--output-file" ) == 0) ) {
				obj_output_file = argv[++i];
			} else if( (strcmp( argv[i], "-ot" ) == 0) || (strcmp( argv[i], "--output-texture" ) == 0) ) {
				texture_output_file = argv[++i];
			} else {
				std::cout << "Invalid argument.\n" << std::endl;
				PrintHelp(argv[0]);
				exit(1);
			}
		} else {
			std::cout << "Invalid argument.\n" << std::endl;
			PrintHelp(argv[0]);
			exit(1);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
leal -0x1(%r14), %eax
movl %eax, 0x4(%rsp)
pushq $0x1
popq %r12
cmpl %r14d, %r12d
jge 0x7a8d
movslq %r12d, %r15
movq (%rbx,%r15,8), %rbp
movb (%rbp), %r13b
cmpb $0x2d, %r13b
jne 0x798c
cmpb $0x68, 0x1(%rbp)
jne 0x798c
cmpb $0x0, 0x2(%rbp)
je 0x7a9c
movq %rbp, %rdi
leaq 0x202f(%rip), %rsi      # 0x99c5
callq 0x2240
testl %eax, %eax
je 0x7a9c
cmpb $0x2d, %r13b
jne 0x79b9
cmpb $0x76, 0x1(%rbp)
jne 0x79b9
cmpb $0x0, 0x2(%rbp)
je 0x7a5c
movq %rbp, %rdi
leaq 0x2009(%rip), %rsi      # 0x99cc
callq 0x2240
testl %eax, %eax
je 0x7a5c
cmpl 0x4(%rsp), %r12d
jge 0x7aab
cmpb $0x2d, %r13b
jne 0x79ed
cmpb $0x66, 0x1(%rbp)
jne 0x79ed
cmpb $0x0, 0x2(%rbp)
je 0x7a65
movq %rbp, %rdi
leaq 0x1fdf(%rip), %rsi      # 0x99d6
callq 0x2240
testl %eax, %eax
je 0x7a65
cmpb $0x2d, %r13b
jne 0x7a12
cmpb $0x6f, 0x1(%rbp)
jne 0x7a12
cmpb $0x0, 0x2(%rbp)
je 0x7a76
movq %rbp, %rdi
leaq 0x1fc7(%rip), %rsi      # 0x99e3
callq 0x2240
testl %eax, %eax
je 0x7a76
movq %rbp, %rdi
leaq 0x1fc2(%rip), %rsi      # 0x99f1
callq 0x2240
testl %eax, %eax
je 0x7a4b
movq %rbp, %rdi
leaq 0x1fb3(%rip), %rsi      # 0x99f5
callq 0x2240
testl %eax, %eax
jne 0x7aab
incl %r12d
movq 0x8(%rbx,%r15,8), %rax
movq %rax, 0x67e6(%rip)      # 0xe240
jmp 0x7a85
movb $0x1, 0x67e5(%rip)      # 0xe248
jmp 0x7a85
incl %r12d
movq 0x8(%rbx,%r15,8), %rax
movq %rax, 0x67bc(%rip)      # 0xe230
jmp 0x7a85
incl %r12d
movq 0x8(%rbx,%r15,8), %rax
movq %rax, 0x67b3(%rip)      # 0xe238
incl %r12d
jmp 0x7962
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
callq 0x76d8
xorl %edi, %edi
callq 0x21e0
movq 0x6526(%rip), %rdi      # 0xdfd8
leaq 0x1f4d(%rip), %rsi      # 0x9a06
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rdi
callq 0x76d8
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/ticky[P]ps2iconsys/src/ps2icon_to_obj.cpp
// Function: LoadPS2Icon()
PS2Icon* LoadPS2Icon()
{
	PS2Icon* ret = NULL;
	if(verbose_output)
		std::cout << " * Reading PS2Icon file \"" << ps2_input_file << "\"...\n";
	try {
		ret = new PS2Icon(ps2_input_file);
	} catch( std::exception e ) {
		std::cout << "File read error: \"" << ps2_input_file << "\"" << std::endl;
		exit(1);
	}
	if(verbose_output)
		std::cout << " **  Found geometry - " << ret->GetNVertices() << " vertices, " 
			<< ret->GetNShapes() << " shapes." << std::endl;
	if(ret->GetNFrames() > 1) {
		std::cout << " **  Found animation - " << ret->GetNFrames() << " frames." << std::endl;
	}
	if(verbose_output)
		std::cout << " *  done." << std::endl;
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpb $0x1, 0x6762(%rip)      # 0xe248
jne 0x7b19
movq 0x64e9(%rip), %rdi      # 0xdfd8
leaq 0x1f23(%rip), %rsi      # 0x9a19
callq 0x2180
movq 0x672e(%rip), %rsi      # 0xe230
movq %rax, %rdi
callq 0x2180
leaq 0x1f22(%rip), %rsi      # 0x9a33
movq %rax, %rdi
callq 0x2180
movl $0x10068, %edi          # imm = 0x10068
callq 0x2190
movq %rax, %rbx
movq 0x6703(%rip), %rsi      # 0xe230
movq %rax, %rdi
callq 0x501c
cmpb $0x0, 0x670c(%rip)      # 0xe248
je 0x7ba1
movq 0x6493(%rip), %rdi      # 0xdfd8
leaq 0x1f00(%rip), %rsi      # 0x9a4c
callq 0x2180
movq %rax, %r14
movq %rbx, %rdi
callq 0x5dc8
movq %r14, %rdi
movl %eax, %esi
callq 0x22d0
leaq 0x1ef6(%rip), %rsi      # 0x9a63
movq %rax, %rdi
callq 0x2180
movq %rax, %r14
movq %rbx, %rdi
callq 0x5dfe
movq %r14, %rdi
movl %eax, %esi
callq 0x22d0
leaq 0x1ede(%rip), %rsi      # 0x9a6f
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x5e34
cmpl $0x2, %eax
jl 0x7bed
movq 0x6423(%rip), %rdi      # 0xdfd8
leaq 0x1ebc(%rip), %rsi      # 0x9a78
callq 0x2180
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e34
movq %r14, %rdi
movl %eax, %esi
callq 0x22d0
leaq 0x1eb3(%rip), %rsi      # 0x9a90
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
cmpb $0x1, 0x6654(%rip)      # 0xe248
jne 0x7c11
movq 0x63db(%rip), %rdi      # 0xdfd8
leaq 0x1e95(%rip), %rsi      # 0x9a99
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %r14
movl $0x10068, %esi          # imm = 0x10068
movq %rbx, %rdi
callq 0x21a0
jmp 0x7c39
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x7cb2
movq %r14, %rdi
callq 0x21f0
movq 0x6382(%rip), %rax      # 0xdfd0
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x20a0
movq 0x6372(%rip), %rdi      # 0xdfd8
leaq 0x1dcc(%rip), %rsi      # 0x9a39
callq 0x2180
movq 0x65b7(%rip), %rsi      # 0xe230
movq %rax, %rdi
callq 0x2180
leaq 0x1dc2(%rip), %rsi      # 0x9a4a
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x21e0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2330
callq 0x22b0
movq %r14, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x395a
// File: /workspace/github_cpp_makefile_star2_O2/ticky[P]ps2iconsys/src/ps2icon_to_obj.cpp
// Function: WriteOBJFile(PS2Icon*)
void WriteOBJFile(PS2Icon* ps2_icon)
{
	OBJ_FileLoader obj_file;
	OBJ_Mesh obj_mesh(ps2_input_file);
	if(verbose_output)
		std::cout << " * Convert geometry data from \"" << ps2_input_file << "\"...";
	ps2_icon->BuildMesh(&obj_mesh);
	if(verbose_output)
		std::cout << "done." << std::endl;

	if(verbose_output)
		std::cout << " * Writing geometry output to file \"" << obj_output_file << "\"...";
	obj_file.AddMesh(obj_mesh);
	try {
		obj_file.WriteFile(obj_output_file);
	} catch( Ghulbus::gbException e ) {
		std::cout << "\nError while writing to \"" << obj_output_file << "\"" << std::endl;
		exit(1);
	}
	if(verbose_output)
		std::cout << "done." << std::endl;
}

// Assembly:
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x257c
movq 0x6552(%rip), %rsi      # 0xe230
leaq 0x38(%rsp), %rdi
callq 0x3634
cmpb $0x1, 0x6559(%rip)      # 0xe248
jne 0x7d22
movq 0x62e0(%rip), %rdi      # 0xdfd8
leaq 0x1da4(%rip), %rsi      # 0x9aa3
callq 0x2180
movq 0x6525(%rip), %rsi      # 0xe230
movq %rax, %rdi
callq 0x2180
leaq 0x1da9(%rip), %rsi      # 0x9ac3
movq %rax, %rdi
callq 0x2180
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x5a72
movb 0x6513(%rip), %al       # 0xe248
cmpb $0x1, %al
jne 0x7d5a
movq 0x6298(%rip), %rdi      # 0xdfd8
leaq 0x1d56(%rip), %rsi      # 0x9a9d
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movb 0x64ee(%rip), %al       # 0xe248
testb $0x1, %al
je 0x7d8f
movq 0x6273(%rip), %rdi      # 0xdfd8
leaq 0x1d5c(%rip), %rsi      # 0x9ac8
callq 0x2180
movq 0x64c0(%rip), %rsi      # 0xe238
movq %rax, %rdi
callq 0x2180
leaq 0x1d3c(%rip), %rsi      # 0x9ac3
movq %rax, %rdi
callq 0x2180
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2aa8
movq 0x6493(%rip), %rsi      # 0xe238
leaq 0x8(%rsp), %rdi
callq 0x2afe
cmpb $0x1, 0x6492(%rip)      # 0xe248
jne 0x7dd3
movq 0x6219(%rip), %rdi      # 0xdfd8
leaq 0x1cd7(%rip), %rsi      # 0x9a9d
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x38(%rsp), %rdi
callq 0x36a4
leaq 0x8(%rsp), %rdi
callq 0x2a36
addq $0xa0, %rsp
popq %rbx
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x7e7e
movq %rbx, %rdi
callq 0x21f0
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x760a
movq %rbx, %rdi
callq 0x20a0
movq 0x61b8(%rip), %rdi      # 0xdfd8
leaq 0x1cc6(%rip), %rsi      # 0x9aed
callq 0x2180
movq 0x6405(%rip), %rsi      # 0xe238
movq %rax, %rdi
callq 0x2180
leaq 0x1c08(%rip), %rsi      # 0x9a4a
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x21e0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x7624
callq 0x22b0
jmp 0x7e7e
movq %rax, %rdi
callq 0x395a
movq %rax, %rbx
jmp 0x7e88
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x36a4
leaq 0x8(%rsp), %rdi
callq 0x2a36
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
callq 0x7945
cmpq $0x0, 0x61b8(%rip)      # 0xe230
je 0x8100
movq 0x5f53(%rip), %rdi      # 0xdfd8
leaq 0x1ad1(%rip), %rsi      # 0x9b5d
callq 0x2180
movq %rax, %rdi
callq 0x20d0
cmpq $0x0, 0x6197(%rip)      # 0xe238
jne 0x80b1
leaq 0x1b03(%rip), %rax      # 0x9bad
movq %rax, 0x6187(%rip)      # 0xe238
cmpq $0x0, 0x6187(%rip)      # 0xe240
jne 0x80c9
leaq 0x1af7(%rip), %rax      # 0x9bb9
movq %rax, 0x6177(%rip)      # 0xe240
callq 0x7ad6
movq %rax, %rbx
movq %rax, %rdi
callq 0x7cc2
movq %rbx, %rdi
callq 0x7e9a
movq 0x5ef0(%rip), %rdi      # 0xdfd8
leaq 0x1ad6(%rip), %rsi      # 0x9bc5
callq 0x2180
movq %rax, %rdi
callq 0x20d0
xorl %eax, %eax
popq %rbx
retq
movq 0x5ed1(%rip), %rdi      # 0xdfd8
leaq 0x1a35(%rip), %rsi      # 0x9b43
callq 0x2180
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rdi
callq 0x76d8
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl %edx, %r15d
movl %ecx, %r13d
leaq 0x8(%rsp), %r12
cmpq %r13, %r15
jae 0x25c4
movq (%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2070
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4a78
movq 0x8(%rsp), %rdi
callq 0x22a0
incq %r15
jmp 0x2595
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4ab2
movq %r14, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x8000, %edi           # imm = 0x8000
callq 0x2030
movq %rax, %rbx
movq (%r15), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x21a0
movl %eax, %ebp
movq (%r14), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x21a0
movl %eax, %r14d
pushq $0x1
popq %r15
testq %r15, %r15
jle 0x2673
movl $0x8000, %edx           # imm = 0x8000
movl %ebp, %edi
movq %rbx, %rsi
callq 0x2310
testq %rax, %rax
jle 0x2673
movq %rax, %r15
xorl %r12d, %r12d
leaq (%rbx,%r12), %rsi
movq %r15, %rdx
subq %r12, %rdx
movl %r14d, %edi
callq 0x2080
testq %rax, %rax
js 0x266e
addq %rax, %r12
cmpq %r15, %r12
jl 0x264d
jmp 0x262e
movq %rax, %r15
jmp 0x262e
movq %rbx, %rdi
callq 0x22b0
movl %ebp, %edi
callq 0x2430
movl %r14d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2430
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movq %rdx, %rsi
callq 0x4d36
pushq $0x1
popq %r15
movzbl %bpl, %ebp
movq %r15, %r12
cmpq $0x6, %r12
je 0x2ae7
cmpq $0x0, (%rbx,%r12,8)
je 0x2ae2
movq %r14, %rdi
callq 0x4dcc
movq %r15, %r13
cmpq (%rbx,%r12,8), %r13
jae 0x2ae2
movq %r14, %rdi
movl %ebp, %esi
callq 0x4dea
incq %r13
jmp 0x2acd
incq %r12
jmp 0x2ab5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movl %edi, 0x4(%rsp)
movb $0x1, %al
leaq 0x8(%rsp), %r12
cmpb 0x4(%rsp), %al
ja 0x2b8a
movb %al, 0x3(%rsp)
movzbl %al, %ebx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl %ebx, %ecx
shll $0x5, %ecx
movq (%rax,%rcx), %rdi
leaq 0x6510(%rip), %rsi      # 0x904c
callq 0x2290
movq %rax, 0x8(%rsp)
imulq $0x30, %rbx, %rbx
xorl %ebp, %ebp
cmpq $0x6, %rbp
je 0x2b7a
movzbl %bpl, %r13d
xorl %r15d, %r15d
movq (%r14), %rax
addq %rbx, %rax
cmpq (%rax,%rbp,8), %r15
jae 0x2b75
movq %r12, %rdi
movl %r13d, %esi
callq 0x4e7e
incq %r15
jmp 0x2b59
incq %rbp
jmp 0x2b4c
movq %r12, %rdi
callq 0x4e8a
movb 0x3(%rsp), %al
incb %al
jmp 0x2b17
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4e8a
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
leal -0x1(%rdi), %r9d
movq (%rcx), %rcx
movq (%rcx,%r9,8), %rax
movl %edi, %r10d
movq (%rcx,%r10,8), %rcx
movzbl 0x30(%rsi), %r10d
imulq $0x18, %r9, %r9
addq (%r8), %r9
movl %edi, (%rsp)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
movl %r10d, %r8d
callq 0x2bae
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/AlgoLab[P]bwt-lcp-parallel/bwt_lcp.cpp
// Function: compute_BWT(unsigned char, unsigned int, 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void compute_BWT(
    const strlen_t k, const strnum_t m,
    const fnames_t& B_tpl,
    const fname_t& IXk_name
) {
  const strlen_t k1 = k+1;
  const luint_t tot = static_cast<luint_t>(m)*k1;
  strlen_reader_t IXk(IXk_name);
  std::vector<enc_fasta_reader_t> Bl;
  for (const fname_t& fname: B_tpl) {
    Bl.emplace_back(fname);
  }
  enc_fasta_writer_t B("outfile-BWT.bin");

  for (luint_t i = 0; i < tot; ++i) {
    const strlen_t l = IXk.read();
    const enc_nucl_t c = Bl[(l+1)%k1].read();
    B.write(c);
  }
  remove_files(B_tpl);
  remove_file(IXk_name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
incb %dil
movl %esi, %eax
movzbl %dil, %ebx
movq %rbx, %r13
imulq %rax, %r13
leaq 0x51d3(%rip), %rdx      # 0x904f
leaq 0x8(%rsp), %rdi
movq %rcx, 0x18(%rsp)
movq %rcx, %rsi
callq 0x53f6
leaq 0x30(%rsp), %r15
andq $0x0, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, (%r15)
movq (%r14), %r12
movq 0x8(%r14), %rbp
cmpq %rbp, %r12
je 0x3ebc
movq %r15, %rdi
movq %r12, %rsi
callq 0x5aca
addq $0x20, %r12
jmp 0x3ea6
leaq 0x523a(%rip), %rsi      # 0x90fd
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x4ad4
leaq 0x5173(%rip), %rdx      # 0x904c
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x4c8e
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x20d0
leaq 0x20(%rsp), %r12
subq $0x1, %r13
jb 0x3f3e
movzbl 0x10(%rsp), %ebp
movq 0x8(%rsp), %rdi
callq 0x2420
movb %al, 0x10(%rsp)
incl %ebp
movl %ebp, %eax
xorl %edx, %edx
divw %bx
movzwl %dx, %eax
imulq $0x18, %rax, %rdi
addq 0x30(%rsp), %rdi
callq 0x4c0c
movb %al, 0x48(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4ca2
jmp 0x3efa
movq %r14, %rdi
callq 0x269a
movq 0x18(%rsp), %rdi
callq 0x2692
leaq 0x20(%rsp), %rdi
callq 0x4cd4
leaq 0x30(%rsp), %rdi
callq 0x5b10
leaq 0x8(%rsp), %rdi
callq 0x54b0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20d0
jmp 0x3fa0
jmp 0x3f8e
movq %rax, %rbx
jmp 0x3fa0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4cd4
leaq 0x30(%rsp), %rdi
callq 0x5b10
leaq 0x8(%rsp), %rdi
callq 0x54b0
movq %rbx, %rdi
callq 0x23d0
// File: /workspace/github_cpp_makefile_star2_O2/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:
movb 0xc(%rdi), %cl
shlb $0x4, %cl
movb (%rsi), %al
andb $0xf, %al
orb %cl, %al
movb %al, 0xc(%rdi)
movl 0x8(%rdi), %ecx
incl %ecx
movl %ecx, 0x8(%rdi)
cmpl $0x2, %ecx
jne 0x4cd3
pushq %rbx
movq %rdi, %rbx
movzbl %al, %esi
callq 0x4e7e
andl $0x0, 0x8(%rbx)
movb $0x0, 0xc(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0x4d02
movb 0xc(%rbx), %cl
cmpl $0x1, %eax
ja 0x4cf7
shlb $0x4, %cl
orb $0xf, %cl
movb %cl, 0xc(%rbx)
incl %eax
movl %eax, 0x8(%rbx)
jmp 0x4ce2
movzbl %cl, %esi
movq %rbx, %rdi
callq 0x4e7e
movq %rbx, %rdi
popq %rbx
jmp 0x4e8a
movq %rax, %rdi
callq 0x5c29
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x4d5e
movq 0x8(%r14), %rax
cmpq %rbx, %rax
ja 0x4d5e
leaq 0x400000(%rax), %rcx
cmpq %rbx, %rcx
ja 0x4d9e
testq %rdi, %rdi
je 0x4d6d
movl $0x400000, %esi         # imm = 0x400000
callq 0x2120
movq %rbx, %r9
andq $-0x400000, %r9         # imm = 0xFFC00000
movq %r9, 0x8(%r14)
movl (%r14), %r8d
pushq $0x3
popq %rdx
pushq $0x1
popq %rcx
movl $0x400000, %esi         # imm = 0x400000
xorl %edi, %edi
callq 0x23e0
movq %rax, 0x18(%r14)
cmpq $-0x1, %rax
je 0x4dad
movq 0x8(%r14), %rax
subq %rax, %rbx
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x456b(%rip), %rdi      # 0x931f
leaq 0x4500(%rip), %rsi      # 0x92bb
leaq 0x4570(%rip), %rcx      # 0x9332
movl $0xd8, %edx
callq 0x2140
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x4e2b
movl %esi, %eax
movq 0x10(%rdi), %rsi
cmpq $0x400000, %rsi         # imm = 0x400000
jae 0x4e4a
cmpb %al, (%rcx,%rsi)
je 0x4e0f
movb %al, (%rcx,%rsi)
movq 0x10(%rdi), %rsi
incq %rsi
movq %rsi, 0x10(%rdi)
cmpq $0x400000, %rsi         # imm = 0x400000
jb 0x4e29
addq 0x8(%rdi), %rsi
popq %rax
jmp 0x4d36
popq %rax
retq
leaq 0x4559(%rip), %rdi      # 0x938b
leaq 0x4482(%rip), %rsi      # 0x92bb
leaq 0x455b(%rip), %rcx      # 0x939b
movl $0xde, %edx
callq 0x2140
leaq 0x459e(%rip), %rdi      # 0x93ef
leaq 0x4463(%rip), %rsi      # 0x92bb
leaq 0x453c(%rip), %rcx      # 0x939b
movl $0xdf, %edx
callq 0x2140
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
pushq $0x2
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x21a0
movl %eax, (%r14)
pushq $0x8
popq %rax
cmpq $0x38, %rax
je 0x4f5a
andq $0x0, (%r14,%rax)
addq $0x8, %rax
jmp 0x4f49
pushq $0x38
popq %rax
cmpq $0x68, %rax
je 0x4f6e
andq $0x0, (%r14,%rax)
addq $0x8, %rax
jmp 0x4f5d
pushq $0x68
popq %rax
cmpq $0x98, %rax
je 0x4f84
andq $0x0, (%r14,%rax)
addq $0x8, %rax
jmp 0x4f71
leaq 0x8(%r14), %rsi
testq %rbx, %rbx
cmovneq %rbx, %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x535c
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x5094
movq 0x8(%r14), %rax
cmpq %rbx, %rax
setbe %cl
leaq 0x400000(%rax), %rdx
cmpq %rbx, %rdx
seta %dl
testb %dl, %cl
jne 0x50c5
movl $0x400000, %esi         # imm = 0x400000
callq 0x2120
movq %rbx, %r9
andq $-0x400000, %r9         # imm = 0xFFC00000
movq %r9, 0x8(%r14)
movl (%r14), %r8d
pushq $0x1
popq %rdx
pushq $0x2
popq %rcx
movl $0x400000, %esi         # imm = 0x400000
xorl %edi, %edi
callq 0x23e0
movq %rax, 0x18(%r14)
cmpq $-0x1, %rax
je 0x50d4
movq 0x8(%r14), %rax
subq %rax, %rbx
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4244(%rip), %rdi      # 0x931f
leaq 0x41d9(%rip), %rsi      # 0x92bb
leaq 0x43e9(%rip), %rcx      # 0x94d2
movl $0x133, %edx            # imm = 0x133
callq 0x2140
nop