LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: neubig[P]egret/Egret/src/Bijection.h
// Function: Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>::clone(Bijection<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int>&) const
void Bijection<TypeX,TypeY>::
clone(Bijection<TypeX,TypeY>& sun)const
{
	typename map<TypeX,TypeY>::const_iterator iter;
	iter=X2YMap.begin();
	for(;iter!=X2YMap.end();iter++)
	{
		sun.add(iter->first,iter->second);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x34230
movq -0x38(%rbp), %rdi
callq 0x34250
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
callq 0xab80
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xab20
testb $0x1, %al
jne 0x2f146
jmp 0x2f189
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xabb0
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xabb0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
addq $0x20, %rdx
callq 0x1c850
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x34280
movq %rax, -0x30(%rbp)
jmp 0x2f126
addq $0x50, %rsp
popq %rbp
retq
nop
// File: neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::UniqueHeap()
UniqueHeap(){
		dataSet.clear();
		vector<_type> tempVec;
		tempVec=data;
		data.clear();
		for(size_t i=0;i<tempVec.size();i++)
		{
			if(dataSet.count(tempVec[i])==0)
			{
				data.push_back(tempVec[i]);
				dataSet.insert(tempVec[i]);
			}
		}
        make_heap(data.begin(), data.end());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x4bce0
movq -0x68(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x70(%rbp)
callq 0x4c060
movq -0x68(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x60(%rbp)
callq 0x4c080
jmp 0x4bd47
movq -0x78(%rbp), %rdi
addq $0x18, %rdi
callq 0x4c0d0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4bce0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x4c0f0
jmp 0x4bd70
movq -0x78(%rbp), %rdi
callq 0x4bf10
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4c340
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x4be99
movq -0x78(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x98(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4c3d0
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x4c370
movq %rax, -0x90(%rbp)
jmp 0x4bddc
movq -0x90(%rbp), %rax
cmpq $0x0, %rax
jne 0x4be86
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4c3d0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x4c3f0
jmp 0x4be08
movq -0x78(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xb0(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x4c3d0
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x4c460
movb %dl, -0xa1(%rbp)
movq %rax, -0xa0(%rbp)
jmp 0x4be42
movb -0xa1(%rbp), %al
movq -0xa0(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movb %al, -0x40(%rbp)
jmp 0x4be86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x4bed4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x46ca0
movq -0x60(%rbp), %rdi
callq 0x47130
jmp 0x4bed4
jmp 0x4be88
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x4bd81
movq -0x78(%rbp), %rdi
callq 0x4c4f0
movq -0x78(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x4c520
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x4c4b0
jmp 0x4bec2
leaq -0x30(%rbp), %rdi
callq 0x46ca0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x47150
movq -0x68(%rbp), %rdi
callq 0x46ca0
movq -0x10(%rbp), %rdi
callq 0x4650
nop
// File: neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::clear()
bool clear(){
        data.clear();
        make_heap(data.begin(), data.end());
		dataSet.clear();
		return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4bf10
movq -0x20(%rbp), %rdi
callq 0x4c4f0
movq -0x20(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x4c520
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4c4b0
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x4c0d0
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: neubig[P]egret/Egret/src/ScoreInfo.h
// Function: ScoreInfo::operator<(ScoreInfo const&) const
bool operator < (const ScoreInfo& si)const
	{
/*		if(_score==si.score()&&!((*this)==si))
		{
			cout<<"compare:"<<endl;
			print(cout);
			si.print(cout);
		}
*/		if(_score<si.score())
		{
			//cout<<"<"<<endl;
			return true;
		}
		else if(_score>si.score())
			return false;
		else if(_childPairID<si.childPairID())
		{
			return true;
		}
		else if(_childPairID>si.childPairID())
			return false;
		else if(_posInChs<si.posInChs())
		{
			return true;
		}
		else return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movsd (%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4de70
movsd -0x20(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x4ddae
movb $0x1, -0x1(%rbp)
jmp 0x4de57
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4de70
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4ddd8
movb $0x0, -0x1(%rbp)
jmp 0x4de57
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4de90
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x4ddff
movb $0x1, -0x1(%rbp)
jmp 0x4de57
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4de90
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jbe 0x4de26
movb $0x0, -0x1(%rbp)
jmp 0x4de57
movq -0x28(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4df20
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4deb0
testb $0x1, %al
jne 0x4de4d
jmp 0x4de53
movb $0x1, -0x1(%rbp)
jmp 0x4de57
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::pop()
_type pop(){
        _type ret;
		if(empty())
		{
			return nullData;
		}
		else
		{
			ret = top();
			dataSet.erase(ret);
			pop_heap(data.begin(), data.end());
			data.pop_back();
			return ret;
		}
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4c080
movq -0x90(%rbp), %rdi
callq 0x6b620
movb %al, -0x81(%rbp)
jmp 0x6b69c
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x6b6a8
jmp 0x6b6e7
movq -0xa0(%rbp), %rdi
movq -0x90(%rbp), %rsi
addq $0x48, %rsi
callq 0x4cbf0
jmp 0x6b6c1
movl $0x1, -0x48(%rbp)
jmp 0x6b78b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x47130
jmp 0x6b7a4
movq -0x90(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x6de00
jmp 0x6b6f9
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
leaq -0x70(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x4f4b0
movq -0xb0(%rbp), %rdi
callq 0x47130
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x18, %rdi
callq 0x6de70
jmp 0x6b739
movq -0x90(%rbp), %rdi
callq 0x4c4f0
movq -0x90(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0x4c520
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x6dea0
jmp 0x6b768
movq -0x90(%rbp), %rdi
callq 0x6df00
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4e930
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x47130
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4650
nopl (%rax)
// File: neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::push(ScoreInfo)
void push(_type entry){
		if(dataSet.count(entry)==0)
		{
			data.push_back(entry);
			push_heap(data.begin(), data.end());
			dataSet.insert(entry);
		}
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0x4c370
cmpq $0x0, %rax
jne 0x6b847
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x4c3f0
movq -0x38(%rbp), %rdi
callq 0x4c4f0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x4c520
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6e580
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x18, %rdi
callq 0x4c460
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: neubig[P]egret/Egret/src/ScoreInfo.h
// Function: IntArray::shoulders(std::vector<IntArray, std::allocator<IntArray>>&) const
vector<IntArray>& shoulders(vector<IntArray>& m_ia)const
	{
		m_ia.clear();
		for(size_t i=0;i<size();i++)
		{
			m_ia.push_back((*this));
			m_ia[i][i]++;
		}
		return m_ia;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6ccd0
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x16990
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x6be61
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x6ccf0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6bea0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x55d00
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6be09
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: neubig[P]egret/Egret/src/UniqueHeap.h
// Function: UniqueHeap<ScoreInfo>::top()
_type top(){
		if(empty())
			return nullData;
		else
			return *(data.begin());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6b620
testb $0x1, %al
jne 0x6de2e
jmp 0x6de41
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x48, %rsi
callq 0x4cbf0
jmp 0x6de63
movq -0x20(%rbp), %rdi
callq 0x4c4f0
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x4cd50
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x4cbf0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: neubig[P]egret/Egret/src/Main.cpp
// Function: string2oft(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
ObjectFunctionType string2oft(string str)
{
	if(str=="variational")
		return VARIATIONAL;
	else if(str=="max_rule_sum")
		return MAX_RULE_SUM;
	else if(str=="max_rule_product")
		return MAX_RULE_PRODUCT;
	else if(str=="max_prob")
		return MAX_PROB;
	else if(str=="viterbi")
		return NONE;
	return MAX_RULE_PRODUCT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x1f4ec(%rip), %rsi     # 0x90be3
callq 0xa020
testb $0x1, %al
jne 0x71702
jmp 0x7170e
movl $0x0, -0x4(%rbp)
jmp 0x71799
movq -0x18(%rbp), %rdi
leaq 0x1f4d6(%rip), %rsi     # 0x90bef
callq 0xa020
testb $0x1, %al
jne 0x71724
jmp 0x7172d
movl $0x1, -0x4(%rbp)
jmp 0x71799
movq -0x18(%rbp), %rdi
leaq 0x1efcd(%rip), %rsi     # 0x90705
callq 0xa020
testb $0x1, %al
jne 0x71743
jmp 0x7174c
movl $0x2, -0x4(%rbp)
jmp 0x71799
movq -0x18(%rbp), %rdi
leaq 0x1f4a5(%rip), %rsi     # 0x90bfc
callq 0xa020
testb $0x1, %al
jne 0x71762
jmp 0x7176b
movl $0x4, -0x4(%rbp)
jmp 0x71799
movq -0x18(%rbp), %rdi
leaq 0x1f48f(%rip), %rsi     # 0x90c05
callq 0xa020
testb $0x1, %al
jne 0x71781
jmp 0x7178a
movl $0x3, -0x4(%rbp)
jmp 0x71799
jmp 0x7178c
jmp 0x7178e
jmp 0x71790
jmp 0x71792
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: neubig[P]egret/Egret/src/Node.cpp
// Function: Node::reset_scorePool_initLevel(int)
void 
Node::reset_scorePool_initLevel(int numOfState)
{
	_allowState.clear();
	_iScore.clear();
	_oScore.clear();
	_iScore.reserve(numOfState);
	_oScore.reserve(numOfState);
	for(int i=0;i<numOfState;i++)
	{
		_iScore.push_back(-1E10);
		_oScore.push_back(-1E10);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x100, %rdi            # imm = 0x100
callq 0x9200
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
callq 0x218a0
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
callq 0x218a0
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
movslq -0xc(%rbp), %rsi
callq 0x21930
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x21930
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x79f67
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
movsd 0x1618b(%rip), %xmm0    # 0x900b8
movsd %xmm0, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x21a30
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
movsd 0x1616a(%rip), %xmm0    # 0x900b8
movsd %xmm0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x21a30
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x79f12
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: neubig[P]egret/Egret/src/RuleSet.cpp
// Function: ListRuleSet::ListRuleSet(std::istream&)
ListRuleSet::ListRuleSet(istream &is)
{
	string curline;
	InterNodes interNodes;
	while(!is.eof())
	{
		getline(is,curline);
		if(is.eof())break;
		if(curline.find("-->")==string::npos)continue;
		Rule rule;
		string2rule(curline,rule);
		//rule.print(jout);
		//add(rule);
		binarize(rule, interNodes, rule.left, PERMUTE , *this);
	}
	normalize();
	//cerr<<"finished loading!"<<endl;
	//print(cout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x898e0
movq -0xe8(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0xe0(%rbp)
callq 0x89900
leaq -0x30(%rbp), %rdi
callq 0x4510
leaq -0x60(%rbp), %rdi
callq 0x89920
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x46a0
movb %al, -0xe9(%rbp)
jmp 0x890d7
movb -0xe9(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x890e8
jmp 0x89203
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x40a0
jmp 0x890f7
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x46a0
movb %al, -0xea(%rbp)
jmp 0x89112
movb -0xea(%rbp), %al
testb $0x1, %al
jne 0x8911e
jmp 0x89134
jmp 0x89203
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x8922c
leaq -0x30(%rbp), %rdi
leaq 0x7d18(%rip), %rsi      # 0x90e57
xorl %eax, %eax
movl %eax, %edx
callq 0x46f0
cmpq $-0x1, %rax
jne 0x89153
jmp 0x890bc
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x37280
movq -0xf8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x88b80
jmp 0x89178
leaq -0xd8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x4160
jmp 0x8918d
movq -0xe8(%rbp), %r8
leaq -0xb8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xd8(%rbp), %rdx
movl $0x2, %ecx
callq 0x36460
jmp 0x891b2
leaq -0xd8(%rbp), %rdi
callq 0x4728
leaq -0xb8(%rbp), %rdi
callq 0x372b0
jmp 0x890bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x891f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x4728
leaq -0xb8(%rbp), %rdi
callq 0x372b0
jmp 0x8922c
movq -0xe8(%rbp), %rdi
callq 0x89260
jmp 0x89211
leaq -0x60(%rbp), %rdi
callq 0x89940
leaq -0x30(%rbp), %rdi
callq 0x4728
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x89940
leaq -0x30(%rbp), %rdi
callq 0x4728
movq -0xe0(%rbp), %rdi
callq 0x3d700
movq -0xe8(%rbp), %rdi
callq 0x761f0
movq -0x68(%rbp), %rdi
callq 0x4650
nop
// File: neubig[P]egret/Egret/src/Tree.cpp
// Function: getUPennTerm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
string getUPennTerm(string& str)
{
	string result;
	size_t pos=0;
	
	result=str;
	pos=str.find("_");
	if(pos!=string::npos)
		result=str.substr(0,pos);
	
	pos=str.find("^g");
	if(pos!=string::npos)
	{
		result=str.substr(0,pos);
	}
	pos=result.find("u*");
	if(pos!=string::npos)
	{
		result=result.substr(pos+2);
	}
	return result;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x4510
movq -0x98(%rbp), %rdi
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4050
jmp 0x8d327
movq -0x10(%rbp), %rdi
leaq 0x2e59(%rip), %rsi      # 0x9018b
xorl %eax, %eax
movl %eax, %edx
callq 0x46f0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x8d395
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x50(%rbp), %rdi
callq 0x43b0
jmp 0x8d35d
movq -0x98(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4470
leaq -0x50(%rbp), %rdi
callq 0x4728
jmp 0x8d395
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4728
jmp 0x8d46f
movq -0x10(%rbp), %rdi
leaq 0x3ad3(%rip), %rsi      # 0x90e73
xorl %eax, %eax
movl %eax, %edx
callq 0x46f0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x8d3e4
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
callq 0x43b0
jmp 0x8d3cb
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4470
leaq -0x70(%rbp), %rdi
callq 0x4728
movq -0x98(%rbp), %rdi
leaq 0x2f68(%rip), %rsi      # 0x9035a
xorl %eax, %eax
movl %eax, %edx
callq 0x46f0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x8d449
movq -0x98(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x2, %rdx
leaq -0x90(%rbp), %rdi
movq $-0x1, %rcx
callq 0x43b0
jmp 0x8d42a
movq -0x98(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x4470
leaq -0x90(%rbp), %rdi
callq 0x4728
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x8d45f
movq -0x98(%rbp), %rdi
callq 0x4728
movq -0xa0(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4650
nopl (%rax,%rax)
// File: neubig[P]egret/Egret/src/utils.cpp
// Function: intToString[abi:cxx11](int)
string
intToString(int i)
{
  stringstream ss;
  ss<<i;
  string ans;
  ss>>ans;
  return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4290
leaq -0x188(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x4630
jmp 0x8fb20
movq -0x1b8(%rbp), %rdi
movb $0x0, -0x1a5(%rbp)
callq 0x4510
movq -0x1b8(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x44a0
jmp 0x8fb48
movb $0x1, -0x1a5(%rbp)
testb $0x1, -0x1a5(%rbp)
jne 0x8fb9a
jmp 0x8fb8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x8fbb6
movq -0x1b8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
callq 0x4728
jmp 0x8fbb6
movq -0x1b8(%rbp), %rdi
callq 0x4728
leaq -0x198(%rbp), %rdi
callq 0x42d0
movq -0x1b0(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
leaq -0x198(%rbp), %rdi
callq 0x42d0
movq -0x1a0(%rbp), %rdi
callq 0x4650
nop
// File: neubig[P]egret/Egret/src/utils.cpp
// Function: doubleToString[abi:cxx11](double)
string doubleToString(double i)
{
  stringstream ss;
  ss.precision(20);
  if(i==0)
	  return "0.0";
  ss<<i;
  string ans;
  ss>>ans;
  return ans;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x4290
movq -0x198(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x198(%rbp,%rax), %rdi
movl $0x14, %esi
callq 0x6c480
jmp 0x8fc20
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8fcbc
jp 0x8fcbc
leaq -0x1a5(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x4660
movq -0x1c0(%rbp), %rdi
movq -0x1c8(%rbp), %rdx
leaq 0x1216(%rip), %rsi      # 0x90e76
callq 0x1c730
jmp 0x8fc67
leaq -0x1a5(%rbp), %rdi
callq 0x43f0
movl $0x1, -0x1ac(%rbp)
jmp 0x8fd41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
jmp 0x8fd5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x1a5(%rbp), %rdi
callq 0x43f0
jmp 0x8fd5d
leaq -0x188(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x46b0
jmp 0x8fccf
movq -0x1c0(%rbp), %rdi
movb $0x0, -0x1ad(%rbp)
callq 0x4510
movq -0x1c0(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x44a0
jmp 0x8fcf7
movb $0x1, -0x1ad(%rbp)
movl $0x1, -0x1ac(%rbp)
testb $0x1, -0x1ad(%rbp)
jne 0x8fd3f
jmp 0x8fd33
movq -0x1c0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
callq 0x4728
jmp 0x8fd5d
movq -0x1c0(%rbp), %rdi
callq 0x4728
jmp 0x8fd41
leaq -0x198(%rbp), %rdi
callq 0x42d0
movq -0x1b8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
leaq -0x198(%rbp), %rdi
callq 0x42d0
movq -0x1a0(%rbp), %rdi
callq 0x4650
nopw %cs:(%rax,%rax)
// File: neubig[P]egret/Egret/src/utils.cpp
// Function: replaceSubStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string& replaceSubStr(string& in, string oldSub, string newSub)
{
	size_t pos=0;
	while(true)
	{
		pos=in.find(oldSub,pos);
		if(pos!=string::npos)
		{
			in.replace(pos,oldSub.length(),newSub);
			pos+=newSub.length();
		}
		else break;
	}
	return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rsi
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
callq 0x4710
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x8fe00
movq -0x30(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x4570
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq %rax, %rdx
callq 0x4120
movq -0x28(%rbp), %rdi
callq 0x4570
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8fe02
jmp 0x8fe04
jmp 0x8fda4
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: ruankotovich[P]B-Tree/src/iohandler.cpp
// Function: IOHandler::getBiggestId()
int IOHandler::getBiggestId(){

  int idBuffer;
  int bigger = 0;
  unsigned long backupPosition = ftell(this->file);
  fseek(this->file, 0, SEEK_SET);
  while (fscanf(this->file, "\"%d\";", &idBuffer) == 1) {
    // READ TITLE
    readNIgnoreColumn(this->file, ';');
    // READ YEAR
    fscanf(this->file, "\"%*d\";");

    // READ AUTHOR
    readNIgnoreColumn(this->file,  ';');

    // READ CITATION
    fscanf(this->file, "\"%*d\";");

    // READ DATE
    readNIgnoreColumn(this->file, ';');

    // READ SNIPPET
    readNIgnoreColumn(this->file, ';');

    if(idBuffer > bigger){
      bigger = idBuffer;
    }
  }

  fseek(this->file, backupPosition, SEEK_SET);

  return bigger;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movq (%rax), %rdi
callq 0x1030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x4c4a(%rip), %rsi      # 0x6004
leaq -0xc(%rbp), %rdx
movb $0x0, %al
callq 0x1150
cmpl $0x1, %eax
jne 0x144f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0x3b, %esi
callq 0x1470
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x4c1d(%rip), %rsi      # 0x600a
movb $0x0, %al
callq 0x1150
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0x3b, %esi
callq 0x1470
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x4bf7(%rip), %rsi      # 0x600a
movb $0x0, %al
callq 0x1150
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0x3b, %esi
callq 0x1470
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl $0x3b, %esi
callq 0x1470
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jle 0x144a
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x13ac
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x10d0
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ruankotovich[P]B-Tree/src/iohandler.cpp
// Function: readNIgnoreColumn(_IO_FILE*, char)
static inline void readNIgnoreColumn(FILE* file, char previous)
{
  char current = fgetc(file);
  char type;
  type = pairClass(previous, current);
  if (type != R_SON) {
    current = fgetc(file);
    do {
      previous = current;
      current = fgetc(file);
    } while ((type = after_pairClass(previous, current)) < R_EOC);
  } else {
    fscanf(file, "ULL\n");
    fscanf(file, "ULL\r\n");
    fscanf(file, "ULL;");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1120
movb %al, -0xa(%rbp)
movb -0x9(%rbp), %al
movsbl %al, %edi
movsbl -0xa(%rbp), %esi
callq 0x18c0
movb %al, -0xb(%rbp)
movsbl -0xb(%rbp), %eax
cmpl $0x3, %eax
je 0x14e3
movq -0x8(%rbp), %rdi
callq 0x1120
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1120
movb %al, -0xa(%rbp)
movb -0x9(%rbp), %al
movsbl %al, %edi
movsbl -0xa(%rbp), %esi
callq 0x1920
movb %al, -0xb(%rbp)
movsbl %al, %eax
cmpl $0x2, %eax
jl 0x14b5
jmp 0x1519
movq -0x8(%rbp), %rdi
leaq 0x4b23(%rip), %rsi      # 0x6011
movb $0x0, %al
callq 0x1150
movq -0x8(%rbp), %rdi
leaq 0x4b16(%rip), %rsi      # 0x6016
movb $0x0, %al
callq 0x1150
movq -0x8(%rbp), %rdi
leaq 0x4b0a(%rip), %rsi      # 0x601c
movb $0x0, %al
callq 0x1150
addq $0x10, %rsp
popq %rbp
retq
nop
// File: ruankotovich[P]B-Tree/src/iohandler.cpp
// Function: IOHandler::parseNext()
void IOHandler::parseNext()
{
  if (fscanf(this->file, "\"%d\";", &this->idBuffer) == 1) {
    // READ TITLE
    readColumn(this->file, this->readBuffer, ';');

    std::memcpy(this->titleBuffer, this->readBuffer, FIELD_TITLE_MAX_SIZE);
    this->titleBuffer[FIELD_TITLE_MAX_SIZE - 1] = '\0';
    // READ YEAR
    fscanf(this->file, "\"%d\";", &this->yearBuffer);

    // READ AUTHOR
    readColumn(this->file, this->readBuffer, ';');
    std::memcpy(this->authorsBuffer, this->readBuffer, FIELD_AUTHORS_MAX_SIZE);
    this->authorsBuffer[FIELD_AUTHORS_MAX_SIZE - 1] = '\0';
    // READ CITATION
    fscanf(this->file, "\"%d\";", &this->citationsBuffer);

    // READ DATE
    readColumn(this->file, this->readBuffer, ';');
    std::memcpy(this->dateBuffer, this->readBuffer, FIELD_DATE_MAX_SIZE);
    this->dateBuffer[FIELD_DATE_MAX_SIZE - 1] = '\0';
    // READ SNIPPET
    readColumn(this->file, readBuffer, ';');
    std::memcpy(this->snippetBuffer, this->readBuffer, FIELD_SNIPPET_MAX_SIZE);
    this->snippetBuffer[FIELD_SNIPPET_MAX_SIZE - 1] = '\0';
    this->state = IOHANDLER_READY;
  } else {
    this->state = IOHANDLER_END;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x10(%rbp)
movq (%rdx), %rdi
addq $0xc, %rdx
leaq 0x4ac2(%rip), %rsi      # 0x6004
movb $0x0, %al
callq 0x1150
cmpl $0x1, %eax
jne 0x1692
movq -0x10(%rbp), %rsi
movq (%rsi), %rdi
addq $0x958, %rsi            # imm = 0x958
movl $0x3b, %edx
callq 0x16a0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x10, %rdi
addq $0x958, %rsi            # imm = 0x958
movl $0x12c, %edx            # imm = 0x12C
callq 0x1070
movq -0x10(%rbp), %rdx
movb $0x0, 0x13b(%rdx)
movq (%rdx), %rdi
addq $0x13c, %rdx            # imm = 0x13C
leaq 0x4a62(%rip), %rsi      # 0x6004
movb $0x0, %al
callq 0x1150
movq -0x10(%rbp), %rsi
movq (%rsi), %rdi
addq $0x958, %rsi            # imm = 0x958
movl $0x3b, %edx
callq 0x16a0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x140, %rdi            # imm = 0x140
addq $0x958, %rsi            # imm = 0x958
movl $0x400, %edx            # imm = 0x400
callq 0x1070
movq -0x10(%rbp), %rdx
movb $0x0, 0x53f(%rdx)
movq (%rdx), %rdi
addq $0x540, %rdx            # imm = 0x540
leaq 0x4a08(%rip), %rsi      # 0x6004
movb $0x0, %al
callq 0x1150
movq -0x10(%rbp), %rsi
movq (%rsi), %rdi
addq $0x958, %rsi            # imm = 0x958
movl $0x3b, %edx
callq 0x16a0
movq -0x10(%rbp), %rsi
movq 0x958(%rsi), %rax
movq %rax, 0x544(%rsi)
movq 0x960(%rsi), %rax
movq %rax, 0x54c(%rsi)
movl 0x968(%rsi), %eax
movl %eax, 0x554(%rsi)
movb $0x0, 0x557(%rsi)
movq (%rsi), %rdi
addq $0x958, %rsi            # imm = 0x958
movl $0x3b, %edx
callq 0x16a0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x558, %rdi            # imm = 0x558
addq $0x958, %rsi            # imm = 0x958
movl $0x400, %edx            # imm = 0x400
callq 0x1070
movq -0x10(%rbp), %rax
movb $0x0, 0x957(%rax)
movb $0x0, 0x8(%rax)
jmp 0x169a
movq -0x10(%rbp), %rax
movb $0x2, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: ruankotovich[P]B-Tree/src/iohandler.cpp
// Function: readColumn(_IO_FILE*, char*, char)
static inline void readColumn(FILE* file, char* buffer, char previous)
{
  char current = fgetc(file);
  int pointer = 0;
  char type;
  type = pairClass(previous, current);
  if (type != R_SON) {
    current = fgetc(file);
    do {
      previous = current;
      current = fgetc(file);
      if (type < R_SOR) {
        buffer[pointer++] = previous;
      }
    } while ((type = after_pairClass(previous, current)) < R_EOC);
  } else {
    fscanf(file, "ULL\n");
    fscanf(file, "ULL\r\n");
    fscanf(file, "ULL;");
    pointer = 1;
  }
  buffer[pointer - 1] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1120
movb %al, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
movb -0x11(%rbp), %al
movsbl %al, %edi
movsbl -0x12(%rbp), %esi
callq 0x18c0
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x3, %eax
je 0x1740
movq -0x8(%rbp), %rdi
callq 0x1120
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1120
movb %al, -0x12(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x1, %eax
jge 0x1722
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x1724
movb -0x11(%rbp), %al
movsbl %al, %edi
movsbl -0x12(%rbp), %esi
callq 0x1920
movb %al, -0x19(%rbp)
movsbl %al, %eax
cmpl $0x2, %eax
jl 0x16ef
jmp 0x177d
movq -0x8(%rbp), %rdi
leaq 0x48c6(%rip), %rsi      # 0x6011
movb $0x0, %al
callq 0x1150
movq -0x8(%rbp), %rdi
leaq 0x48b9(%rip), %rsi      # 0x6016
movb $0x0, %al
callq 0x1150
movq -0x8(%rbp), %rdi
leaq 0x48ad(%rip), %rsi      # 0x601c
movb $0x0, %al
callq 0x1150
movl $0x1, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ruankotovich[P]B-Tree/src/iohandler.cpp
// Function: IOHandler::operator>>(Article_t&)
void IOHandler::operator>>(Article_t& article)
{
  article.id = idBuffer;
  article.year = yearBuffer;
  article.citations = citationsBuffer;
  std::memcpy(article.title, this->titleBuffer, FIELD_TITLE_MAX_SIZE);
  std::memcpy(article.authors, this->authorsBuffer, FIELD_AUTHORS_MAX_SIZE);
  std::memcpy(article.date, this->dateBuffer, FIELD_DATE_MAX_SIZE);
  std::memcpy(article.snippet, this->snippetBuffer, FIELD_SNIPPET_MAX_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movl 0xc(%rsi), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl 0x13c(%rsi), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x130(%rax)
movl 0x540(%rsi), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x534(%rax)
movq -0x10(%rbp), %rdi
addq $0x4, %rdi
addq $0x10, %rsi
movl $0x12c, %edx            # imm = 0x12C
callq 0x1070
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x134, %rdi            # imm = 0x134
addq $0x140, %rsi            # imm = 0x140
movl $0x400, %edx            # imm = 0x400
callq 0x1070
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x544(%rsi), %rcx
movq %rcx, 0x538(%rax)
movq 0x54c(%rsi), %rcx
movq %rcx, 0x540(%rax)
movl 0x554(%rsi), %ecx
movl %ecx, 0x548(%rax)
movq -0x10(%rbp), %rdi
addq $0x54c, %rdi            # imm = 0x54C
addq $0x558, %rsi            # imm = 0x558
movl $0x400, %edx            # imm = 0x400
callq 0x1070
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ruankotovich[P]B-Tree/src/iohandler.cpp
// Function: pairClass(char, char)
static inline char pairClass(char previous, char current)
{

  switch (previous) {
    case '\"': {

      return R_EOC;
    } break;

    case ';': {
      if (current == ';') {
        return R_EOC;
      }
      if (current == 'N') {
        return R_SON;
      }

    } break;
  }
  return R_NOTHING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movsbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0x22, %eax
je 0x18e8
jmp 0x18de
movl -0x8(%rbp), %eax
subl $0x3b, %eax
je 0x18ee
jmp 0x190e
movb $0x2, -0x1(%rbp)
jmp 0x1912
movsbl -0x3(%rbp), %eax
cmpl $0x3b, %eax
jne 0x18fd
movb $0x2, -0x1(%rbp)
jmp 0x1912
movsbl -0x3(%rbp), %eax
cmpl $0x4e, %eax
jne 0x190c
movb $0x3, -0x1(%rbp)
jmp 0x1912
jmp 0x190e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw (%rax,%rax)
// File: ruankotovich[P]B-Tree/src/iohandler.cpp
// Function: after_pairClass(char, char)
static inline char after_pairClass(char previous, char current)
{
  switch (previous) {
    case '\"': {

      if (current == ';' || current == '\n' || current == EOF) {
        return R_EOC;
      }

    } break;

    case ';': {

      if (current == '\"') {
        return R_SOR;
      }

    } break;

    case '\r': {
      if (current == '\n' || current == EOF) {
        return R_EOC;
      }
    }
  }
  return R_NOTHING;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rbp)
movb %al, -0x3(%rbp)
movsbl -0x2(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $0xd, %eax
je 0x1986
jmp 0x193e
movl -0x8(%rbp), %eax
subl $0x22, %eax
je 0x1952
jmp 0x1948
movl -0x8(%rbp), %eax
subl $0x3b, %eax
je 0x1975
jmp 0x19a0
movsbl -0x3(%rbp), %eax
cmpl $0x3b, %eax
je 0x196d
movsbl -0x3(%rbp), %eax
cmpl $0xa, %eax
je 0x196d
movsbl -0x3(%rbp), %eax
cmpl $-0x1, %eax
jne 0x1973
movb $0x2, -0x1(%rbp)
jmp 0x19a4
jmp 0x19a0
movsbl -0x3(%rbp), %eax
cmpl $0x22, %eax
jne 0x1984
movb $0x1, -0x1(%rbp)
jmp 0x19a4
jmp 0x19a0
movsbl -0x3(%rbp), %eax
cmpl $0xa, %eax
je 0x1998
movsbl -0x3(%rbp), %eax
cmpl $-0x1, %eax
jne 0x199e
movb $0x2, -0x1(%rbp)
jmp 0x19a4
jmp 0x19a0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: ruankotovich[P]B-Tree/src/secondarybtree.cpp
// Function: SecondaryBTreeNode::insert(SecondaryBTreeDataMap&)
int SecondaryBTreeNode::insert(SecondaryBTreeDataMap& key)
{ // [TROCAR]

    int i;

    for (i = count; i >= 1; i--) {
        if (key > keys[i - 1]) {
            keys[i] = key;
            break;
        } else {
            keys[i] = keys[i - 1];
        }
    }
    if (i == 0) {
        keys[0] = key;
    }

    count++;

    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movzwl (%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x1c66
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x4, %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x130, %rax, %rax      # imm = 0x130
addq %rax, %rsi
callq 0x1b40
testb $0x1, %al
jne 0x1c01
jmp 0x1c22
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rdi
movslq -0x14(%rbp), %rax
imulq $0x130, %rax, %rax      # imm = 0x130
addq %rax, %rdi
callq 0x1a60
jmp 0x1c66
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x4, %rsi
movl -0x14(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0x130, %rax, %rax      # imm = 0x130
addq %rax, %rsi
addq $0x4, %rdi
movslq -0x14(%rbp), %rax
imulq $0x130, %rax, %rax      # imm = 0x130
addq %rax, %rdi
callq 0x1a60
jmp 0x1c58
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1bce
cmpl $0x0, -0x14(%rbp)
jne 0x1c7d
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rdi
callq 0x1a60
movq -0x20(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ruankotovich[P]B-Tree/src/secondarybtree.cpp
// Function: SecondaryBTree::buildIndex(_IO_FILE*)
void SecondaryBTree::buildIndex(FILE* indexFile)
{
    rewind(indexFile);
    fwrite(&rootOffset, sizeof(AbstractBlock_t), 1, indexFile);

    fseek(indexFile, sizeof(AbstractBlock_t), SEEK_SET);
    fwrite(root, sizeof(AbstractBlock_t), 1, indexFile);
}

// 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)
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x18(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq -0x10(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1160
movq -0x10(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
xorl %edx, %edx
callq 0x10d0
movq -0x18(%rbp), %rax
movq 0x138(%rax), %rdi
movq -0x10(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1160
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ruankotovich[P]B-Tree/src/secondarybtree.cpp
// Function: SecondaryBTree::readRoot(_IO_FILE*)
void SecondaryBTree::readRoot(FILE* indexFile)
{
    rewind(indexFile);
    fread(&rootOffset, sizeof(int), 1, indexFile);

    SecondaryBTreeNodeReinterpret* reinterpretation = (SecondaryBTreeNodeReinterpret*)this->root;

    fseek(indexFile, sizeof(AbstractBlock_t) * rootOffset, SEEK_SET);
    fread(&reinterpretation->block, sizeof(AbstractBlock_t), 1, indexFile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x20(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq -0x10(%rbp), %rcx
movl $0x4, %esi
movl $0x1, %edx
callq 0x1100
movq -0x20(%rbp), %rax
movq 0x138(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq 0x140(%rax), %rsi
shlq $0xc, %rsi
xorl %edx, %edx
callq 0x10d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ruankotovich[P]B-Tree/src/secondarybtree.cpp
// Function: SecondaryBTree::insert(SecondaryBTreeDataMap&, _IO_FILE*)
void SecondaryBTree::insert(SecondaryBTreeDataMap& key, FILE* indexFile)
{ // [TROCAR]
    auto result = insertRecursive(key, root, rootOffset, indexFile);

    if (result.hasBeenSplit) { // se tiver um promovido vindo de um split abaixo
        SecondaryBTreeNodeReinterpret* newRoot = new SecondaryBTreeNodeReinterpret();
        newRoot->node.insert(result.promotedKey); // insere a key promovida do nível abaixo
        newRoot->node.blockPointers[0] = rootOffset; //apontador esquerdo -> antiga raíz

        // considerando que o block splittado já foi salvo no arquivo na função insertRecursive
        newRoot->node.blockPointers[1] = result.newBlockOffset;
        newRoot->node.countPointers = 2;

        // salvar o newRoot no arquivo da SecondaryBTree
        rootOffset = writeNewNode(&newRoot->node, indexFile);

        // atualizar o header
        fseek(indexFile, 0, SEEK_SET);

        fwrite(&rootOffset, sizeof(AbstractBlock_t), 1, indexFile);

        delete (root);
        root = newRoot;

        fseek(indexFile, 0, SEEK_END);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x170(%rbp)
movq -0x10(%rbp), %rdx
movq 0x138(%rsi), %rcx
movl 0x140(%rsi), %r8d
movq -0x18(%rbp), %r9
leaq -0x150(%rbp), %rdi
callq 0x1e30
testb $0x1, -0x150(%rbp)
je 0x2c94
movl $0x1000, %edi           # imm = 0x1000
callq 0x10b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x178(%rbp)
callq 0x30b0
jmp 0x2b6f
movq -0x178(%rbp), %rax
movq %rax, -0x158(%rbp)
movq -0x158(%rbp), %rdi
leaq -0x150(%rbp), %rsi
addq $0x4, %rsi
callq 0x1bb0
movq -0x170(%rbp), %rax
movl 0x140(%rax), %ecx
movq -0x158(%rbp), %rax
movl %ecx, 0xe44(%rax)
movl -0x1c(%rbp), %ecx
movq -0x158(%rbp), %rax
movl %ecx, 0xe48(%rax)
movq -0x158(%rbp), %rax
movw $0x2, 0x2(%rax)
movq -0x158(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3180
movl %eax, %ecx
movq -0x170(%rbp), %rax
movl %ecx, 0x140(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x10d0
movq -0x170(%rbp), %rdi
addq $0x140, %rdi            # imm = 0x140
movq -0x18(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1160
movq -0x170(%rbp), %rax
movq 0x138(%rax), %rax
movq %rax, -0x180(%rbp)
cmpq $0x0, %rax
je 0x2c46
movq -0x180(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x10c0
movq -0x170(%rbp), %rax
movq -0x158(%rbp), %rcx
movq %rcx, 0x138(%rax)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x10d0
jmp 0x2c94
movq -0x178(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
movl $0x1000, %esi           # imm = 0x1000
callq 0x10c0
jmp 0x2c9d
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x160(%rbp), %rdi
callq 0x1140
nopl (%rax)
// File: ruankotovich[P]B-Tree/src/arrayoperations.hpp
// Function: std::pair<bool, int> binarySearch<SecondaryBTreeDataMap, SecondaryBTreeDataMap>(SecondaryBTreeDataMap*, int, SecondaryBTreeDataMap)
static inline std::pair<bool, int> binarySearch(T* array, int length, K value)
{
    int position = lowerBound(array, length, value);

    if (array[position] == value) {
        return { true, position };
    }

    return { false, position };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movl %esi, %eax
leaq 0x10(%rbp), %rsi
movq %rsi, -0x158(%rbp)
movq %rdi, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x160(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x164(%rbp)
leaq -0x148(%rbp), %rdi
movl $0x130, %edx            # imm = 0x130
callq 0x1070
movq %rsp, %rdi
movl $0x26, %ecx
leaq -0x148(%rbp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movl -0x164(%rbp), %esi
movq -0x160(%rbp), %rdi
callq 0x3060
movq -0x158(%rbp), %rsi
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
imulq $0x130, %rax, %rax      # imm = 0x130
addq %rax, %rdi
callq 0x1ae0
testb $0x1, %al
jne 0x300f
jmp 0x302c
movb $0x1, -0x149(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x149(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x3230
jmp 0x3047
movb $0x0, -0x14a(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x14a(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x3230
movq -0x8(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ruankotovich[P]B-Tree/src/secondarybtree.cpp
// Function: relativeKeyPosition(SecondaryBTreeDataMap&, SecondaryBTreeDataMap&, SecondaryBTreeDataMap&)
char inline relativeKeyPosition(SecondaryBTreeDataMap& key, SecondaryBTreeDataMap& leftMiddle, SecondaryBTreeDataMap& rightMiddle)
{
    if (key < leftMiddle) {
        return RELATIVE_LEFT;
    } else if (key > rightMiddle) {
        return RELATIVE_RIGHT;
    }

    return RELATIVE_MIDDLE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1b10
testb $0x1, %al
jne 0x3147
jmp 0x314d
movb $-0x1, -0x1(%rbp)
jmp 0x316c
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1b40
testb $0x1, %al
jne 0x3160
jmp 0x3166
movb $0x1, -0x1(%rbp)
jmp 0x316c
jmp 0x3168
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ruankotovich[P]B-Tree/src/primarybtree.cpp
// Function: PrimaryBTreeNode::insert(int)
unsigned short PrimaryBTreeNode::insert(int key)
{ // [TROCAR]

    unsigned short i;

    for (i = count; i >= 1; i--) {
        if (key > keys[i - 1]) {
            keys[i] = key;
            break;
        } else {
            keys[i] = keys[i - 1];
        }
    }
    if (i == 0) {
        keys[0] = key;
    }

    count++;

    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw (%rax), %ax
movw %ax, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
cmpl $0x1, %eax
jl 0x36d5
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
movzwl -0xe(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl 0x4(%rcx,%rdx,4), %eax
jle 0x36ab
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %edx
movzwl -0xe(%rbp), %ecx
movl %edx, 0x4(%rax,%rcx,4)
jmp 0x36d5
movq -0x18(%rbp), %rax
movzwl -0xe(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x4(%rax,%rcx,4), %edx
movzwl -0xe(%rbp), %ecx
movl %edx, 0x4(%rax,%rcx,4)
jmp 0x36c7
movw -0xe(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0xe(%rbp)
jmp 0x367a
movzwl -0xe(%rbp), %eax
cmpl $0x0, %eax
jne 0x36e8
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movw -0xe(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: ruankotovich[P]B-Tree/src/primarybtree.cpp
// Function: PrimaryBTree::buildIndex(_IO_FILE*)
void PrimaryBTree::buildIndex(FILE* indexFile)
{
    rewind(indexFile);
    fwrite(&rootOffset, sizeof(AbstractBlock_t), 1, indexFile);

    fseek(indexFile, sizeof(AbstractBlock_t), SEEK_SET);
    fwrite(root, sizeof(AbstractBlock_t), 1, indexFile);
}

// 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)
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1160
movq -0x10(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
xorl %edx, %edx
callq 0x10d0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1160
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ruankotovich[P]B-Tree/src/primarybtree.cpp
// Function: PrimaryBTree::readRoot(_IO_FILE*)
void PrimaryBTree::readRoot(FILE* indexFile)
{
    rewind(indexFile);
    fread(&rootOffset, sizeof(unsigned short), 1, indexFile);

    PrimaryBTreeNodeReinterpret* reinterpretation = (PrimaryBTreeNodeReinterpret*)this->root;

    fseek(indexFile, sizeof(AbstractBlock_t) * rootOffset, SEEK_SET);
    fread(&reinterpretation->block, sizeof(AbstractBlock_t), 1, indexFile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1040
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rcx
movl $0x2, %esi
movl $0x1, %edx
callq 0x1100
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movzwl 0x18(%rax), %eax
movl %eax, %esi
shlq $0xc, %rsi
xorl %edx, %edx
callq 0x10d0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
movl $0x1, %edx
callq 0x1100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)