LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ShootMe[P]Klondike-Solver/Solitaire.cpp
// Function: Solitaire::GetSolitaire[abi:cxx11]()
string Solitaire::GetSolitaire() {
	stringstream cardSet;
	for (int i = 0; i < 52; i++) {
		Card c = cards[i];
		unsigned char suit = c.Suit;

		if (suit >= 2) {
			suit = (suit == 2) ? 3 : 2;
		}
		suit++;

		if (c.Rank < 10) {
			cardSet << '0' << (char)(c.Rank ^ 0x30) << (char)(suit ^ 0x30);
		} else {
			cardSet << '1' << (char)((c.Rank - 10) ^ 0x30) << (char)(suit ^ 0x30);
		}
	}
	return cardSet.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3170
movl $0x0, -0x19c(%rbp)
cmpl $0x34, -0x19c(%rbp)
jge 0xc2cd
movq -0x1c0(%rbp), %rax
addq $0x173c, %rax           # imm = 0x173C
movslq -0x19c(%rbp), %rcx
imulq $0x6, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %ecx
movl %ecx, -0x1a2(%rbp)
movw 0x4(%rax), %ax
movw %ax, -0x19e(%rbp)
movb -0x1a2(%rbp), %al
movb %al, -0x1a3(%rbp)
movzbl -0x1a3(%rbp), %eax
cmpl $0x2, %eax
jl 0xc1c5
movzbl -0x1a3(%rbp), %edx
movl $0x2, %eax
movl $0x3, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
movb %al, -0x1a3(%rbp)
movb -0x1a3(%rbp), %al
addb $0x1, %al
movb %al, -0x1a3(%rbp)
movzbl -0x1a1(%rbp), %eax
cmpl $0xa, %eax
jge 0xc25b
leaq -0x188(%rbp), %rdi
movl $0x30, %esi
callq 0x32d0
movq %rax, -0x1d8(%rbp)
jmp 0xc1f9
movq -0x1d8(%rbp), %rdi
movzbl -0x1a1(%rbp), %eax
xorl $0x30, %eax
movsbl %al, %esi
callq 0x32d0
movq %rax, -0x1e0(%rbp)
jmp 0xc21b
movq -0x1e0(%rbp), %rdi
movzbl -0x1a3(%rbp), %eax
xorl $0x30, %eax
movsbl %al, %esi
callq 0x32d0
jmp 0xc236
jmp 0xc2b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3190
jmp 0xc2fe
leaq -0x188(%rbp), %rdi
movl $0x31, %esi
callq 0x32d0
movq %rax, -0x1e8(%rbp)
jmp 0xc275
movq -0x1e8(%rbp), %rdi
movzbl -0x1a1(%rbp), %eax
addl $-0xa, %eax
xorl $0x30, %eax
movsbl %al, %esi
callq 0x32d0
movq %rax, -0x1f0(%rbp)
jmp 0xc29a
movq -0x1f0(%rbp), %rdi
movzbl -0x1a3(%rbp), %eax
xorl $0x30, %eax
movsbl %al, %esi
callq 0x32d0
jmp 0xc2b5
jmp 0xc2b7
jmp 0xc2b9
movl -0x19c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x19c(%rbp)
jmp 0xc155
movq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3220
jmp 0xc2e2
leaq -0x198(%rbp), %rdi
callq 0x3190
movq -0x1c8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x33d0
nopw (%rax,%rax)
// File: ShootMe[P]Klondike-Solver/Solitaire.cpp
// Function: Solitaire::MovesAvailable[abi:cxx11]()
string Solitaire::MovesAvailable() {
	//Returns moves available for the current state. Flip moves are combined with the move that caused it in []. See below for move representation.
	stringstream ss;
	for (int i = 0; i < movesAvailableCount; i++) {
		Move m = movesAvailable[i];
		AddMove(ss, m, piles[STOCK].Size(), piles[WASTE].Size(), drawCount, true);
	}
	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3170
movl $0x0, -0x19c(%rbp)
movq -0x1c0(%rbp), %rcx
movl -0x19c(%rbp), %eax
cmpl 0x1910(%rcx), %eax
jge 0xeb5e
movq -0x1c0(%rbp), %rdi
movslq -0x19c(%rbp), %rax
movl 0x1874(%rdi,%rax,4), %eax
movl %eax, -0x1a0(%rbp)
movl -0x1a0(%rbp), %eax
movl %eax, -0x1a4(%rbp)
addq $0x1160, %rdi           # imm = 0x1160
callq 0x6400
movl %eax, -0x1d4(%rbp)
jmp 0xead9
movq -0x1c0(%rbp), %rdi
addq $0x800, %rdi            # imm = 0x800
callq 0x6400
movl %eax, -0x1d8(%rbp)
jmp 0xeaf4
movl -0x1d8(%rbp), %ecx
movl -0x1d4(%rbp), %edx
movq -0x1c0(%rbp), %rax
movl 0x1904(%rax), %r8d
movl -0x1a4(%rbp), %esi
leaq -0x198(%rbp), %rdi
movl $0x1, %r9d
callq 0xe420
jmp 0xeb28
jmp 0xeb2a
movl -0x19c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x19c(%rbp)
jmp 0xea85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3190
jmp 0xeb8f
movq -0x1d0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3220
jmp 0xeb73
leaq -0x198(%rbp), %rdi
callq 0x3190
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0x33d0
nopl (%rax,%rax)
// File: ShootMe[P]Klondike-Solver/Solitaire.cpp
// Function: Solitaire::MovesMade[abi:cxx11]()
string Solitaire::MovesMade() {
	//Returns moves made so far in the current game.
	//DR# is a draw move that is done # number of times. ie) DR2 means draw twice, if draw count > 1 it is still DR2.
	//NEW is to represent the moving of cards from the Waste pile back to the stock pile. A New round.
	//F# means to flip the card on tableau pile #. 
	//XY means to move the top card from pile X to pile Y.
	//X will be 1 through 7, W for Waste, or a foundation suit character. 'C'lubs, 'D'iamonds, 'S'pades, 'H'earts
	//Y will be 1 through 7 or the foundation suit character.
	//XY-# is the same as above except you are moving # number of cards from X to Y.
	stringstream ss;
	int moves = movesMadeCount;
	ResetGame(drawCount);
	for (int i = 0; i < moves; i++) {
		Move m = movesMade[i];
		AddMove(ss, m, piles[STOCK].Size(), piles[WASTE].Size(), drawCount, false);
		MakeMove(m);
	}
	return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3170
movq -0x1c8(%rbp), %rdi
movl 0x1914(%rdi), %eax
movl %eax, -0x19c(%rbp)
movl 0x1904(%rdi), %esi
callq 0x99e0
jmp 0xebfb
movl $0x0, -0x1b0(%rbp)
movl -0x1b0(%rbp), %eax
cmpl -0x19c(%rbp), %eax
jge 0xecf0
movq -0x1c8(%rbp), %rdi
movslq -0x1b0(%rbp), %rax
movl (%rdi,%rax,4), %eax
movl %eax, -0x1b4(%rbp)
movl -0x1b4(%rbp), %eax
movl %eax, -0x1b8(%rbp)
addq $0x1160, %rdi           # imm = 0x1160
callq 0x6400
movl %eax, -0x1dc(%rbp)
jmp 0xec4e
movq -0x1c8(%rbp), %rdi
addq $0x800, %rdi            # imm = 0x800
callq 0x6400
movl %eax, -0x1e0(%rbp)
jmp 0xec69
movl -0x1e0(%rbp), %ecx
movl -0x1dc(%rbp), %edx
movq -0x1c8(%rbp), %rax
movl 0x1904(%rax), %r8d
movl -0x1b8(%rbp), %esi
leaq -0x198(%rbp), %rdi
xorl %r9d, %r9d
callq 0xe420
jmp 0xec9a
movq -0x1c8(%rbp), %rdi
movl -0x1b4(%rbp), %eax
movl %eax, -0x1bc(%rbp)
movl -0x1bc(%rbp), %esi
callq 0x7150
jmp 0xecba
jmp 0xecbc
movl -0x1b0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1b0(%rbp)
jmp 0xec05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3190
jmp 0xed21
movq -0x1d8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x3220
jmp 0xed05
leaq -0x198(%rbp), %rdi
callq 0x3190
movq -0x1d0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1a8(%rbp), %rdi
callq 0x33d0
nopl (%rax)
// File: ShootMe[P]Klondike-Solver/./HashMap.h
// Function: HashMap<int>::HashMap(int)
HashMap<T>::HashMap(int powerOf2) {
	this->powerOf2 = powerOf2;
	size = 0;
	slotsUsed = 0;
	maxLength = 0;
	capacity = (1 << powerOf2) - 1;
	table = new KeyValue<T>[capacity + 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x14(%rax)
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %eax
addl $0x1, %eax
cltq
movq %rax, -0x38(%rbp)
movl $0x28, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x3030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, %rax
je 0xf3b8
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
imulq $0x28, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x12110
jmp 0xf3a3
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rax
addq $0x28, %rax
cmpq %rcx, %rax
movq %rax, -0x50(%rbp)
jne 0xf394
movq -0x48(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rcx
movq %rax, %rsi
movq -0x60(%rbp), %rax
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq %rax, %rcx
movq %rax, -0x68(%rbp)
je 0xf406
movq -0x68(%rbp), %rdi
addq $-0x28, %rdi
movq %rdi, -0x70(%rbp)
callq 0x12140
movq -0x28(%rbp), %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x68(%rbp)
jne 0xf3e4
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x3420
movq -0x18(%rbp), %rdi
callq 0x33d0
nopl (%rax)
// File: ShootMe[P]Klondike-Solver/./HashMap.h
// Function: HashKey::ComputeHash() const
int ComputeHash() const {
		unsigned long hash = 0;
		int i = 0;

		while (i < KEYSIZE) {
			hash = (int)Key[i++] + (hash << 7) + (hash << 16) - hash;
		}

		return hash;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x15, -0x14(%rbp)
jge 0x1185d
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cltq
movq -0x10(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
shlq $0x10, %rcx
addq %rcx, %rax
subq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1181f
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ShootMe[P]Klondike-Solver/./HashMap.h
// Function: KeyValue<int>::KeyValue(int, HashKey const&, int const&, KeyValue<int>*)
KeyValue<T>::KeyValue(int hash, HashKey const& key, T const& value, KeyValue<T> * next) {
	Next = next;
	Key = key;
	Hash = hash;
	Value = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0xf770
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x10(%rax)
movl 0x10(%rcx), %edx
movl %edx, 0x18(%rax)
movb 0x14(%rcx), %cl
movb %cl, 0x1c(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x24(%rax)
movq -0x20(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x20(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ShootMe[P]Klondike-Solver/Random.cpp
// Function: Random::CalculateNext()
void Random::CalculateNext() {
	int y = value ^ twist - mix ^ value;
	y ^= twist ^ value ^ mix;
	mix ^= twist ^ value;
	value ^= twist - mix;
	twist ^= value ^ y;
	value ^= (twist << 7) ^ (mix >> 16) ^ (y << 8);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl 0x8(%rax), %edx
subl 0x4(%rax), %edx
xorl %edx, %ecx
xorl (%rax), %ecx
movl %ecx, -0xc(%rbp)
movl 0x8(%rax), %ecx
xorl (%rax), %ecx
xorl 0x4(%rax), %ecx
xorl -0xc(%rbp), %ecx
movl %ecx, -0xc(%rbp)
movl 0x8(%rax), %ecx
xorl (%rax), %ecx
xorl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl 0x8(%rax), %ecx
subl 0x4(%rax), %ecx
xorl (%rax), %ecx
movl %ecx, (%rax)
movl (%rax), %ecx
xorl -0xc(%rbp), %ecx
xorl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %ecx
shll $0x7, %ecx
movl 0x4(%rax), %edx
sarl $0x10, %edx
xorl %edx, %ecx
movl -0xc(%rbp), %edx
shll $0x8, %edx
xorl %edx, %ecx
xorl (%rax), %ecx
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ShootMe[P]Klondike-Solver/Random.cpp
// Function: Random::SetSeed(int)
void Random::SetSeed(int seed) {
	this->seed = seed;
	mix = 51651237;
	twist = 895213268;
	value = seed;

	for (int i = 0; i < 50; ++i) {
		CalculateNext();
	}

	seed ^= (seed >> 15);
	value = 0x9417B3AF ^ seed;

	for (int i = 0; i < 950; ++i) {
		CalculateNext();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl $0x31422a5, 0x4(%rax)   # imm = 0x31422A5
movl $0x355bded4, 0x8(%rax)  # imm = 0x355BDED4
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, -0x10(%rbp)
cmpl $0x32, -0x10(%rbp)
jge 0x130d1
movq -0x20(%rbp), %rdi
callq 0x12ff0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x130b7
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
sarl $0xf, %ecx
xorl -0xc(%rbp), %ecx
movl %ecx, -0xc(%rbp)
movl -0xc(%rbp), %ecx
xorl $0x9417b3af, %ecx       # imm = 0x9417B3AF
movl %ecx, (%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x3b6, -0x14(%rbp)     # imm = 0x3B6
jge 0x13110
movq -0x20(%rbp), %rdi
callq 0x12ff0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x130f3
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ShootMe[P]Klondike-Solver/Random.cpp
// Function: Random::Next2()
int Random::Next2() {
	if (seed == 0) { seed = 0x12345987; }
	int k = seed / 127773;
	seed = 16807 * (seed - k * 127773) - 2836 * k;
	if ((int)seed < 0) { seed += 2147483647; }
	return seed & 0x7fffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0xc(%rax)
jne 0x131a1
movq -0x18(%rbp), %rax
movl $0x12345987, 0xc(%rax)  # imm = 0x12345987
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x1f31d, %ecx          # imm = 0x1F31D
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl 0xc(%rax), %ecx
imull $0x1f31d, -0xc(%rbp), %edx # imm = 0x1F31D
subl %edx, %ecx
imull $0x41a7, %ecx, %ecx     # imm = 0x41A7
imull $0xb14, -0xc(%rbp), %edx # imm = 0xB14
subl %edx, %ecx
movl %ecx, 0xc(%rax)
cmpl $0x0, 0xc(%rax)
jge 0x131ee
movq -0x18(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
popq %rbp
retq
nopl (%rax)
// File: ShootMe[P]Klondike-Solver/Card.cpp
// Function: Card::Set(unsigned char)
void Card::Set(unsigned char value) {
	Value = value;
	Rank = (value % 13) + 1;
	Suit = value / 13;
	IsRed = Suit & 1;
	IsOdd = Rank & 1;
	Foundation = Suit + 9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb -0x9(%rbp), %cl
movb %cl, 0x5(%rax)
movzbl -0x9(%rbp), %eax
movl $0xd, %ecx
cltd
idivl %ecx
movq -0x18(%rbp), %rax
addl $0x1, %edx
movb %dl, %cl
movb %cl, 0x1(%rax)
movzbl -0x9(%rbp), %eax
movl $0xd, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movzbl (%rax), %ecx
andl $0x1, %ecx
movb %cl, 0x3(%rax)
movzbl 0x1(%rax), %ecx
andl $0x1, %ecx
movb %cl, 0x2(%rax)
movzbl (%rax), %ecx
addl $0x9, %ecx
movb %cl, 0x4(%rax)
popq %rbp
retq
// File: zimpha[P]MiniSQL/API.cc
// Function: API::dropTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Response API::dropTable(const std::string &tableName) {
    if (!cm.hasTable(tableName + ".table")) {
        return Response("Table does not exist");
    }
    cm.dropTable(tableName+".table");

    std::string dbName = tableName + ".db";
    // Record Manager clear database
    // 传入数据库文件名(dbName)
    rm.RecordManagerTableDetete(dbName);
    return Response();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0xf8(%rbp)
movq %rdi, %rax
movq %rax, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x226f7(%rip), %rdx     # 0x27035
leaq -0x38(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x76d0
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x1b550
movb %al, -0xd1(%rbp)
jmp 0x4969
movb -0xd1(%rbp), %al
xorb $-0x1, %al
movb %al, -0xf9(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35b8
movb -0xf9(%rbp), %al
testb $0x1, %al
jne 0x498f
jmp 0x4a2c
leaq -0x69(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x3500
movq -0x108(%rbp), %rdx
leaq 0x2268f(%rip), %rsi     # 0x2703c
leaq -0x68(%rbp), %rdi
callq 0x3400
jmp 0x49b8
movq -0xf8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x24ba0
jmp 0x49ca
leaq -0x68(%rbp), %rdi
callq 0x35b8
leaq -0x69(%rbp), %rdi
callq 0x3320
jmp 0x4b3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35b8
jmp 0x4b4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4a1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35b8
leaq -0x69(%rbp), %rdi
callq 0x3320
jmp 0x4b4b
movq -0x18(%rbp), %rsi
leaq 0x225fe(%rip), %rdx     # 0x27035
leaq -0x90(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x76d0
movq -0xe8(%rbp), %rdi
movq -0x110(%rbp), %rsi
callq 0x1baa0
jmp 0x4a5f
leaq -0x90(%rbp), %rdi
callq 0x35b8
movq -0x18(%rbp), %rsi
leaq 0x2262c(%rip), %rdx     # 0x270a2
leaq -0xb0(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x76d0
movq -0xe8(%rbp), %rax
movq -0x120(%rbp), %rsi
addq $0x30, %rax
movq %rax, -0x118(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x3130
jmp 0x4ab0
movq -0x118(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x22b80
jmp 0x4ac5
leaq -0xd0(%rbp), %rdi
callq 0x35b8
movq -0xf8(%rbp), %rdi
callq 0x24b60
jmp 0x4adf
leaq -0xb0(%rbp), %rdi
callq 0x35b8
jmp 0x4b3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x35b8
jmp 0x4b4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4b2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x35b8
leaq -0xb0(%rbp), %rdi
callq 0x35b8
jmp 0x4b4b
movq -0xf0(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: zimpha[P]MiniSQL/./CatalogManager.h
// Function: IndexTableManager::IndexTableManager()
IndexTableManager()
    {
        std::ifstream fin("index.catalog");
        mp.clear();
        if (!fin) return;
        std::string indexName, tableName;
        int attrIndex;
        while (fin >> indexName >> tableName >> attrIndex) {
            mp[indexName] = make_pair(tableName, attrIndex);
        }
        fin.close();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
movq %rdi, %rax
movq %rax, -0x298(%rbp)
callq 0x8550
leaq 0x1eee8(%rip), %rsi     # 0x271f8
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x3540
jmp 0x8323
movq -0x298(%rbp), %rdi
callq 0x8570
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x3160
movb %al, -0x2a1(%rbp)
jmp 0x834f
movb -0x2a1(%rbp), %al
testb $0x1, %al
jne 0x835b
jmp 0x8398
movl $0x1, -0x220(%rbp)
jmp 0x84f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x852a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x851e
leaq -0x240(%rbp), %rdi
callq 0x3410
leaq -0x260(%rbp), %rdi
callq 0x3410
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x33a0
movq %rax, -0x2b0(%rbp)
jmp 0x83cc
movq -0x2b0(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x33a0
movq %rax, -0x2b8(%rbp)
jmp 0x83e8
movq -0x2b8(%rbp), %rdi
leaq -0x264(%rbp), %rsi
callq 0x31c0
movq %rax, -0x2c0(%rbp)
jmp 0x8404
movq -0x2c0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3390
movb %al, -0x2c1(%rbp)
jmp 0x8422
movb -0x2c1(%rbp), %al
testb $0x1, %al
jne 0x8431
jmp 0x84c1
leaq -0x290(%rbp), %rdi
leaq -0x260(%rbp), %rsi
leaq -0x264(%rbp), %rdx
callq 0x8590
jmp 0x844d
movq -0x298(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x85d0
movq %rax, -0x2d0(%rbp)
jmp 0x8469
movq -0x2d0(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x86b0
leaq -0x290(%rbp), %rdi
callq 0x7a30
jmp 0x83b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x8506
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x290(%rbp), %rdi
callq 0x7a30
jmp 0x8506
leaq -0x210(%rbp), %rdi
callq 0x30a0
jmp 0x84cf
leaq -0x260(%rbp), %rdi
callq 0x35b8
leaq -0x240(%rbp), %rdi
callq 0x35b8
movl $0x0, -0x220(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x30d0
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
leaq -0x260(%rbp), %rdi
callq 0x35b8
leaq -0x240(%rbp), %rdi
callq 0x35b8
leaq -0x210(%rbp), %rdi
callq 0x30d0
movq -0x2a0(%rbp), %rdi
callq 0x86f0
movq -0x218(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: zimpha[P]MiniSQL/./CatalogManager.h
// Function: IndexTableManager::~IndexTableManager()
~IndexTableManager()
    {
        std::ofstream fout("index.catalog");
        for (auto &x : mp) {
            fout << x.first << " " << x.second.first << " " << x.second.second << std::endl;
        }
        fout.close();
        mp.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq 0x1d587(%rip), %rsi     # 0x271f8
leaq -0x208(%rbp), %rdi
movl $0x10, %edx
callq 0x3330
jmp 0x9c84
movq -0x230(%rbp), %rax
movq %rax, -0x210(%rbp)
movq -0x210(%rbp), %rdi
callq 0x9df0
movq %rax, -0x218(%rbp)
movq -0x210(%rbp), %rdi
callq 0x8c00
movq %rax, -0x220(%rbp)
leaq -0x218(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x9e20
testb $0x1, %al
jne 0x9cd4
jmp 0x9da2
leaq -0x218(%rbp), %rdi
callq 0x8c80
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rsi
leaq -0x208(%rbp), %rdi
callq 0x3280
movq %rax, -0x238(%rbp)
jmp 0x9d03
movq -0x238(%rbp), %rdi
leaq 0x1d8d4(%rip), %rsi     # 0x275e5
callq 0x32c0
movq %rax, -0x240(%rbp)
jmp 0x9d1f
movq -0x240(%rbp), %rdi
movq -0x228(%rbp), %rsi
addq $0x20, %rsi
callq 0x3280
movq %rax, -0x248(%rbp)
jmp 0x9d3f
movq -0x248(%rbp), %rdi
leaq 0x1d898(%rip), %rsi     # 0x275e5
callq 0x32c0
movq %rax, -0x250(%rbp)
jmp 0x9d5b
movq -0x250(%rbp), %rdi
movq -0x228(%rbp), %rax
movl 0x40(%rax), %esi
callq 0x34e0
movq %rax, -0x258(%rbp)
jmp 0x9d7a
movq -0x258(%rbp), %rdi
movq 0x2f220(%rip), %rsi     # 0x38fa8
callq 0x3310
jmp 0x9d8f
jmp 0x9d91
leaq -0x218(%rbp), %rdi
callq 0x9ab0
jmp 0x9cb8
leaq -0x208(%rbp), %rdi
callq 0x3420
jmp 0x9db0
movq -0x230(%rbp), %rdi
callq 0x8570
leaq -0x208(%rbp), %rdi
callq 0x3440
movq -0x230(%rbp), %rdi
callq 0x86f0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rdi
callq 0x8810
nopw %cs:(%rax,%rax)
nop
// File: zimpha[P]MiniSQL/bufferManager.cpp
// Function: BFM::BufferManagerFlush()
void BFM::BufferManagerFlush()
{
    for (bufferIter T = buffer.begin(); T!=buffer.end();){
        BufferManagerWrite(*T++);
    }
    buffer.clear();
    table.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x29c65(%rip), %rdi     # 0x39330
callq 0xfdb0
movq %rax, -0x10(%rbp)
leaq 0x29c55(%rip), %rdi     # 0x39330
callq 0xfbc0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xfeb0
testb $0x1, %al
jne 0xf6f7
jmp 0xf71d
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xfe00
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xfa80
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0xf440
jmp 0xf6d4
leaq 0x29c0c(%rip), %rdi     # 0x39330
callq 0xfee0
leaq 0x29bd0(%rip), %rdi     # 0x39300
callq 0xff10
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: zimpha[P]MiniSQL/bufferManager.cpp
// Function: BFM::deleteFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void BFM::deleteFile(const string &fileName)
{
    tableIter tIt = table.lower_bound(make_pair(fileName,0));
    for (; tIt!=table.end() && tIt->first.first==fileName; ){
        BufferManagerWrite(*(tIt++->second));
    }
    cout << remove(fileName.c_str()) << " " <<fileName<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
movl $0x0, -0x6c(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq -0x6c(%rbp), %rdx
callq 0xff60
movq -0x98(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xffa0
jmp 0xf78f
leaq 0x29b6a(%rip), %rdi     # 0x39300
leaq -0x40(%rbp), %rsi
callq 0xff30
movq %rax, -0xa8(%rbp)
jmp 0xf7a8
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xf9e0
leaq -0x68(%rbp), %rdi
callq 0x7a30
leaq 0x29b34(%rip), %rdi     # 0x39300
callq 0xfa30
movq %rax, -0x88(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xfa00
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa9(%rbp)
jne 0xf7f9
jmp 0xf814
leaq -0x18(%rbp), %rdi
callq 0xfa60
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x7780
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0xf820
jmp 0xf88c
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xffe0
movq %rax, -0x90(%rbp)
leaq -0x90(%rbp), %rdi
callq 0xfa60
movq %rax, %rdi
addq $0x28, %rdi
callq 0xfa80
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0xf440
jmp 0xf7c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xf881
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xf9e0
leaq -0x68(%rbp), %rdi
callq 0x7a30
jmp 0xf8de
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, %rdi
callq 0x3520
movl %eax, %esi
movq 0x29722(%rip), %rdi     # 0x38fc8
callq 0x34e0
movq %rax, %rdi
leaq 0x17d30(%rip), %rsi     # 0x275e5
callq 0x32c0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3280
movq %rax, %rdi
movq 0x296d8(%rip), %rsi     # 0x38fa8
callq 0x3310
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x34f0
nopw (%rax,%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: isFileExist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isFileExist(const string &fileName) {
    ifstream f(fileName.c_str());
    if (f.good()) {
        f.close();
        return true;
    } else {
        f.close();
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3120
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x3540
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x34c0
movb %al, -0x229(%rbp)
jmp 0x118fc
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x11908
jmp 0x11946
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x11916
movb $0x1, -0x1(%rbp)
movl $0x1, -0x228(%rbp)
jmp 0x11962
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30d0
jmp 0x1197c
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x11954
movb $0x0, -0x1(%rbp)
movl $0x1, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x30d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: writeContent(_IO_FILE*, long, void const*, int)
void writeContent(FILE *file, long offset, const void *p, int n) {
    if (!fseek(file, offset, SEEK_SET)) {
        if (fwrite((const void *)p, sizeof(char), n, file) != n) {
            throw "bad write -- indexManager.writeContent";
        }
    } else {
        throw "bad seek -- indexManager.writeContent";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3340
cmpl $0x0, %eax
jne 0x11a03
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x3580
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
je 0x11a01
movl $0x8, %edi
callq 0x3170
movq %rax, %rdi
leaq 0x1589e(%rip), %rax     # 0x2728c
movq %rax, (%rdi)
movq 0x275b8(%rip), %rsi     # 0x38fb0
xorl %eax, %eax
movl %eax, %edx
callq 0x34d0
jmp 0x11a2a
movl $0x8, %edi
callq 0x3170
movq %rax, %rdi
leaq 0x1589c(%rip), %rax     # 0x272b3
movq %rax, (%rdi)
movq 0x2758f(%rip), %rsi     # 0x38fb0
xorl %eax, %eax
movl %eax, %edx
callq 0x34d0
addq $0x20, %rsp
popq %rbp
retq
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: badRes(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Response badRes(const string &info) {
    Response res;
    res.succeed = false;
    res.info = info;
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x24b60
movq -0x30(%rbp), %rdi
movb $0x0, (%rdi)
movq -0x10(%rbp), %rsi
addq $0x8, %rdi
callq 0x3050
jmp 0x11c1a
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x11c46
jmp 0x11c3d
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x78f0
jmp 0x11c50
movq -0x30(%rbp), %rdi
callq 0x78f0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34f0
nopl (%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: build(std::vector<std::pair<element, long>, std::allocator<std::pair<element, long>>> const&)
map <element, long> build(const vector < pair <element, long> > &v) {
    map <element, long> mp;
    for (auto o : v) 
        mp[o.first] = o.second;
    return mp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x14ca0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14cc0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x14cf0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x14d20
testb $0x1, %al
jne 0x12132
jmp 0x121b7
leaq -0x28(%rbp), %rdi
callq 0x14d60
movq %rax, %rsi
leaq -0x68(%rbp), %rdi
callq 0x14d80
jmp 0x12149
movq -0x88(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x14dc0
movq %rax, -0x90(%rbp)
jmp 0x1216d
movq -0x90(%rbp), %rax
movq -0x98(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x68(%rbp), %rdi
callq 0x14b60
leaq -0x28(%rbp), %rdi
callq 0x14ea0
jmp 0x1211c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x121da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x14b60
jmp 0x121da
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x121cd
movq -0x88(%rbp), %rdi
callq 0x14ec0
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x14ec0
movq -0x70(%rbp), %rdi
callq 0x34f0
nop
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: BT::newNode()
BTNode newNode() {
        FILE *file = fopen(name.c_str(), "rb");
        fseek(file, 0, SEEK_END);
        long off = ftell(file);
        fclose(file);
        BTNode res;
        res.offset = off;
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x27172(%rip), %rdi     # 0x39380
callq 0x3120
movq %rax, %rdi
leaq 0x15034(%rip), %rsi     # 0x27251
callq 0x3370
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3340
movq -0x10(%rbp), %rdi
callq 0x3030
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32d0
movq -0x28(%rbp), %rdi
movb $0x0, -0x19(%rbp)
callq 0x14c00
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x1227a
movq -0x28(%rbp), %rdi
callq 0x14ee0
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: BT::setRoot(long)
void setRoot(long offset) {
        BFM bfm;
        bfm.BufferManagerFlush();
        FILE *file = fopen(name.c_str(), "r+b");
        writeContent(file, 0, &offset, sizeof(long));
        fclose(file);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x9(%rbp), %rdi
callq 0xf6b0
leaq 0x270d4(%rip), %rdi     # 0x39380
callq 0x3120
movq %rax, %rdi
leaq 0x15029(%rip), %rsi     # 0x272e4
callq 0x3370
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x8(%rbp), %rdx
movl $0x8, %ecx
callq 0x11990
movq -0x18(%rbp), %rdi
callq 0x32d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: BT::build(std::vector<std::pair<element, long>, std::allocator<std::pair<element, long>>> const&)
BTNode *build(const vector < pair <element, long> > &v) {
        C = pool;
        C->n = 0;
        C->isLeaf = C->isRoot = 1;
        return C;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
leaq 0x270a1(%rip), %rax     # 0x393a0
movq %rax, 0xc12d19a(%rip)   # 0xc13f4a0
movq 0xc12d193(%rip), %rax   # 0xc13f4a0
movl $0x0, 0x4(%rax)
movq 0xc12d185(%rip), %rax   # 0xc13f4a0
movb $0x1, 0x1(%rax)
movq 0xc12d17a(%rip), %rax   # 0xc13f4a0
movb $0x1, (%rax)
movq 0xc12d170(%rip), %rax   # 0xc13f4a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: BT::save(BTNode const&)
BTNode save(const BTNode &p) {
        bfm->BufferManagerFlush();
        FILE *file = fopen(name.c_str(), "r+b");
        writeContent(file, p.offset, &p, sizeof(p));
        fclose(file);
        return BTNode();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x27016(%rip), %rdi     # 0x39378
callq 0xf6b0
leaq 0x27012(%rip), %rdi     # 0x39380
callq 0x3120
movq %rax, %rdi
leaq 0x14f67(%rip), %rsi     # 0x272e4
callq 0x3370
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movl $0xfd0, %ecx            # imm = 0xFD0
callq 0x11990
movq -0x18(%rbp), %rdi
callq 0x32d0
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0xfd0, %edx            # imm = 0xFD0
callq 0x3190
movq -0x28(%rbp), %rdi
callq 0x14c00
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::create(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&, Table&, AttrType const&)
Response IndexManager::create(const string &indexName, const string &dbName, Table &table, const AttrType &attr) {
    if (DEBUG) cout << "IndexManagerCreate begin" << endl;
    Response res;
    if (isFileExist(getIndexFileName(indexName))) {
        if (DEBUG) cout << "if" << endl;
        return badRes(info_index_exist);
    } else {
        if (DEBUG) cout << "else" << endl;
        save();
        currentFile = getIndexFileName(indexName);
        mp = build(getRecord(bfm, dbName, table, attr));
        save();
        return goodRes();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x120(%rbp)
movq %rdi, %rax
movq %rax, -0x118(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x110(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x24b60
movq -0x18(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x11a90
jmp 0x1370a
leaq -0x90(%rbp), %rdi
callq 0x118b0
movb %al, -0x121(%rbp)
jmp 0x1371e
leaq -0x90(%rbp), %rdi
callq 0x35b8
movb -0x121(%rbp), %al
testb $0x1, %al
jne 0x13736
jmp 0x13794
movq -0x120(%rbp), %rdi
leaq 0x25c14(%rip), %rsi     # 0x39358
callq 0x11be0
jmp 0x1374b
movl $0x1, -0xa0(%rbp)
jmp 0x13895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x138ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x35b8
jmp 0x138ae
movq -0x110(%rbp), %rdi
callq 0x13450
jmp 0x137a2
movq -0x18(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x11a90
jmp 0x137b4
movq -0x110(%rbp), %rdi
addq $0x38, %rdi
leaq -0xc0(%rbp), %rsi
movq %rsi, -0x130(%rbp)
callq 0x3380
movq -0x130(%rbp), %rdi
callq 0x35b8
movq -0x110(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq -0x108(%rbp), %rdi
callq 0x11ca0
jmp 0x13802
leaq -0xf0(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x120d0
jmp 0x13817
movq -0x110(%rbp), %rdi
addq $0x8, %rdi
leaq -0xf0(%rbp), %rsi
movq %rsi, -0x138(%rbp)
callq 0x15af0
movq -0x138(%rbp), %rdi
callq 0x14ec0
leaq -0x108(%rbp), %rdi
callq 0x14ba0
movq -0x110(%rbp), %rdi
callq 0x13450
jmp 0x1385b
movq -0x120(%rbp), %rdi
callq 0x11b90
jmp 0x13869
movl $0x1, -0xa0(%rbp)
jmp 0x13895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x14ba0
jmp 0x138ae
leaq -0x70(%rbp), %rdi
callq 0x78f0
movq -0x118(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
leaq -0x70(%rbp), %rdi
callq 0x78f0
movq -0x98(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::drop(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Response IndexManager::drop(const std::string &indexName) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) {
        return badRes("No such index. -- IndexManager::drop");
    } else {
        bfm.deleteFile(name);
        currentFile = "";
        return goodRes();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x11a90
movq -0x80(%rbp), %rdi
callq 0x118b0
movb %al, -0x71(%rbp)
jmp 0x13922
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x139c7
jmp 0x1392f
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3500
movq -0xa0(%rbp), %rdx
leaq 0x1399b(%rip), %rsi     # 0x272e8
leaq -0x68(%rbp), %rdi
callq 0x3400
jmp 0x13958
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x11be0
jmp 0x1396a
leaq -0x68(%rbp), %rdi
callq 0x35b8
leaq -0x69(%rbp), %rdi
callq 0x3320
movl $0x1, -0x70(%rbp)
jmp 0x13a0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x13a23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x139bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x35b8
leaq -0x69(%rbp), %rdi
callq 0x3320
jmp 0x13a23
movq -0x88(%rbp), %rax
movq (%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0xf740
jmp 0x139dc
movq -0x88(%rbp), %rdi
addq $0x38, %rdi
leaq 0x13881(%rip), %rsi     # 0x2726f
callq 0x33e0
jmp 0x139f5
movq -0x98(%rbp), %rdi
callq 0x11b90
jmp 0x13a03
movl $0x1, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x35b8
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x35b8
movq -0x40(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::erase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&)
Response IndexManager::erase(const string &indexName, const element &e) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return badRes("No such Index. -- IndexManager::erase");
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    if (!mp.count(e)) return badRes("No such element. -- IndexManager::erase");
    mp.erase(e);
    return goodRes();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x11a90
movq -0xa8(%rbp), %rdi
callq 0x118b0
movb %al, -0x9a(%rbp)
jmp 0x1403f
movb -0x9a(%rbp), %al
testb $0x1, %al
jne 0x140ea
jmp 0x1404f
leaq -0x71(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3500
movq -0xc8(%rbp), %rdx
leaq 0x132ee(%rip), %rsi     # 0x2735b
leaq -0x70(%rbp), %rdi
callq 0x3400
jmp 0x14078
movq -0xc0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x11be0
jmp 0x1408a
leaq -0x70(%rbp), %rdi
callq 0x35b8
leaq -0x71(%rbp), %rdi
callq 0x3320
movl $0x1, -0x78(%rbp)
jmp 0x1422a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x14243
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x140dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x35b8
leaq -0x71(%rbp), %rdi
callq 0x3320
jmp 0x14243
movq -0xb0(%rbp), %rsi
addq $0x38, %rsi
leaq -0x40(%rbp), %rdi
callq 0x15b20
testb $0x1, %al
jne 0x14104
jmp 0x14138
movq -0xb0(%rbp), %rdi
callq 0x13450
jmp 0x14112
movq -0xb0(%rbp), %rdi
addq $0x38, %rdi
leaq -0x40(%rbp), %rsi
callq 0x3050
jmp 0x14128
movq -0xb0(%rbp), %rdi
callq 0x13ce0
jmp 0x14136
jmp 0x14138
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x15b50
movq %rax, -0xd0(%rbp)
jmp 0x14155
movq -0xd0(%rbp), %rax
cmpq $0x0, %rax
jne 0x141ff
leaq -0x99(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3500
movq -0xd8(%rbp), %rdx
leaq 0x131fa(%rip), %rsi     # 0x27381
leaq -0x98(%rbp), %rdi
callq 0x3400
jmp 0x14195
movq -0xc0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x11be0
jmp 0x141aa
leaq -0x98(%rbp), %rdi
callq 0x35b8
leaq -0x99(%rbp), %rdi
callq 0x3320
movl $0x1, -0x78(%rbp)
jmp 0x1422a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x141f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x35b8
leaq -0x99(%rbp), %rdi
callq 0x3320
jmp 0x14243
movq -0xb0(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x15bb0
jmp 0x14215
movq -0xc0(%rbp), %rdi
callq 0x11b90
jmp 0x14223
movl $0x1, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35b8
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x35b8
movq -0x48(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&)
long IndexManager::find(const std::string &indexName, const element &e) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return -1;
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    if (!mp.count(e)) return -1;
    return mp[e];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x11a90
movq -0x60(%rbp), %rdi
callq 0x118b0
movb %al, -0x51(%rbp)
jmp 0x1429e
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x142d5
jmp 0x142a7
movq $-0x1, -0x8(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x14372
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35b8
jmp 0x14388
movq -0x68(%rbp), %rsi
addq $0x38, %rsi
leaq -0x40(%rbp), %rdi
callq 0x15b20
testb $0x1, %al
jne 0x142ec
jmp 0x14317
movq -0x68(%rbp), %rdi
callq 0x13450
jmp 0x142f7
movq -0x68(%rbp), %rdi
addq $0x38, %rdi
leaq -0x40(%rbp), %rsi
callq 0x3050
jmp 0x1430a
movq -0x68(%rbp), %rdi
callq 0x13ce0
jmp 0x14315
jmp 0x14317
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x15b50
movq %rax, -0x70(%rbp)
jmp 0x1432e
movq -0x70(%rbp), %rax
cmpq $0x0, %rax
jne 0x14349
movq $-0x1, -0x8(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x14372
movq -0x68(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x14dc0
movq %rax, -0x78(%rbp)
jmp 0x14360
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35b8
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: zimpha[P]MiniSQL/indexManager.cc
// Function: IndexManager::greater(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, element const&)
set <long> IndexManager::greater(const std::string &indexName, const element &e) {
    string name = getIndexFileName(indexName);
    if (!isFileExist(name)) return set <long> ();
    if (name != currentFile) {
        save();
        currentFile = name;
        load();
    }
    set <long> res;
    for (auto it = mp.upper_bound(e); it != mp.end(); it++) {
        res.insert(it->second);
    }
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x11a90
movq -0x90(%rbp), %rdi
callq 0x118b0
movb %al, -0x81(%rbp)
jmp 0x143ff
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x14447
jmp 0x1440b
movq -0xa8(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x3190
movq -0xa8(%rbp), %rdi
callq 0x7b90
movl $0x1, -0x50(%rbp)
jmp 0x1457d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x14596
movq -0x98(%rbp), %rsi
addq $0x38, %rsi
leaq -0x40(%rbp), %rdi
callq 0x15b20
testb $0x1, %al
jne 0x14461
jmp 0x14495
movq -0x98(%rbp), %rdi
callq 0x13450
jmp 0x1446f
movq -0x98(%rbp), %rdi
addq $0x38, %rdi
leaq -0x40(%rbp), %rsi
callq 0x3050
jmp 0x14485
movq -0x98(%rbp), %rdi
callq 0x13ce0
jmp 0x14493
jmp 0x14495
movq -0xa8(%rbp), %rdi
movb $0x0, -0x51(%rbp)
callq 0x7b90
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
movq -0x20(%rbp), %rsi
callq 0x15be0
movq %rax, -0xb0(%rbp)
jmp 0x144c2
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x15c40
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x15c10
testb $0x1, %al
jne 0x144f4
jmp 0x1455e
leaq -0x60(%rbp), %rdi
callq 0x15c70
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
addq $0x30, %rsi
callq 0x7c40
movb %dl, -0xb9(%rbp)
movq %rax, -0xb8(%rbp)
jmp 0x1451f
movb -0xb9(%rbp), %al
movq -0xb8(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movb %al, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x15c90
movq %rax, -0x80(%rbp)
jmp 0x144cd
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x7be0
jmp 0x14596
movb $0x1, -0x51(%rbp)
movl $0x1, -0x50(%rbp)
testb $0x1, -0x51(%rbp)
jne 0x1457b
movq -0xa8(%rbp), %rdi
callq 0x7be0
jmp 0x1457d
leaq -0x40(%rbp), %rdi
callq 0x35b8
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x35b8
movq -0x48(%rbp), %rdi
callq 0x34f0
nopl (%rax,%rax)