LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: scattana[P]Crossword-Anagram-CPP/board.cpp
// Function: Board::Board()
Board::Board(){
	// make a 15x15 blank board, with blanks shown as underscores
	for(int i=0; i<15; i++){
		for(int j=0; j<15; j++){
			data[i][j] = '_';
		}
	}
	// make all locations (0,0) to begin with
	for(int row=0; row<20; row++){
		for(int col=0; col<2; col++){
			locations[row][col] = 0;
		}
	}
	// "place" keeps track of which word in list goes to which location
	// start at 1 because first (longest) word will be placed before the
	// method is called that places the next word on the board
	place = 1;

	// direction keeps track of the orientation of the words placed
	for(int i=0; i<20; i++){
		direction[i] = " ";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x188, %rax            # imm = 0x188
movq %rax, -0x48(%rbp)
movq %rax, %rcx
addq $0x280, %rcx            # imm = 0x280
movq %rcx, -0x40(%rbp)
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x2220
movq -0x58(%rbp), %rax
movq -0x40(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x38(%rbp)
jne 0x4b70
movl $0x0, -0xc(%rbp)
cmpl $0xf, -0xc(%rbp)
jge 0x4bdb
movl $0x0, -0x10(%rbp)
cmpl $0xf, -0x10(%rbp)
jge 0x4bce
movq -0x50(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xf, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb $0x5f, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4ba6
jmp 0x4bd0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4b99
movl $0x0, -0x14(%rbp)
cmpl $0x14, -0x14(%rbp)
jge 0x4c2d
movl $0x0, -0x18(%rbp)
cmpl $0x2, -0x18(%rbp)
jge 0x4c20
movq -0x50(%rbp), %rax
addq $0xe4, %rax
movslq -0x14(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4bef
jmp 0x4c22
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4be2
movq -0x50(%rbp), %rax
movl $0x1, 0x408(%rax)
movl $0x0, -0x1c(%rbp)
cmpl $0x14, -0x1c(%rbp)
jge 0x4c94
movq -0x50(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x5, %rcx
leaq 0x188(%rax,%rcx), %rdi
leaq 0x1780(%rip), %rsi      # 0x63e3
callq 0x2200
jmp 0x4c6a
jmp 0x4c6c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4c42
movq %rdx, %rcx
movq %rax, %rdx
movq -0x48(%rbp), %rax
movq %rdx, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
addq $0x280, %rax            # imm = 0x280
movq %rax, -0x60(%rbp)
jmp 0x4c9a
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
addq $-0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0x2120
movq -0x48(%rbp), %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x60(%rbp)
jne 0x4c9a
jmp 0x4cbe
movq -0x28(%rbp), %rdi
callq 0x22a0
nopw (%rax,%rax)
// File: scattana[P]Crossword-Anagram-CPP/board.cpp
// Function: Board::printBoard()
void Board::printBoard(){
	for(int i=0; i<15; i++){
		for(int j=0; j<15; j++){
			cout << data[i][j];
			// add a space in between for visual purposes
			cout << " ";
		}
		cout << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xf, -0xc(%rbp)
jge 0x4dad
movl $0x0, -0x10(%rbp)
cmpl $0xf, -0x10(%rbp)
jge 0x4d8f
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xf, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movq 0x4268(%rip), %rdi      # 0x8fd0
movsbl (%rax,%rcx), %esi
callq 0x21f0
movq 0x4258(%rip), %rdi      # 0x8fd0
leaq 0x1664(%rip), %rsi      # 0x63e3
callq 0x21a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4d48
movq 0x423a(%rip), %rdi      # 0x8fd0
movq 0x4223(%rip), %rsi      # 0x8fc0
callq 0x21c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4d3b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: scattana[P]Crossword-Anagram-CPP/board.cpp
// Function: Board::printHidden()
void Board::printHidden(){
	for(int i=0; i<15; i++){
		for(int j=0; j<15; j++){
			if(data[i][j]=='_') cout << '#';
			else cout << '_';
			// add a space in between for visual purposes
			cout << " ";
		}
		cout << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xf, -0xc(%rbp)
jge 0x4e71
movl $0x0, -0x10(%rbp)
cmpl $0xf, -0x10(%rbp)
jge 0x4e50
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0xf, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
jne 0x4e21
movq 0x41bb(%rip), %rdi      # 0x8fd0
movl $0x23, %esi
callq 0x21f0
jmp 0x4e32
movq 0x41a8(%rip), %rdi      # 0x8fd0
movl $0x5f, %esi
callq 0x21f0
movq 0x4197(%rip), %rdi      # 0x8fd0
leaq 0x15a3(%rip), %rsi      # 0x63e3
callq 0x21a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4dec
movq 0x4179(%rip), %rdi      # 0x8fd0
movq 0x4162(%rip), %rsi      # 0x8fc0
callq 0x21c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4ddb
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: scattana[P]Crossword-Anagram-CPP/board.cpp
// Function: Board::findMatch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Board::findMatch(string word){
	for(int i=0; i<15; i++){
		for(int j=0; j<15; j++){
			for(int k=0; k<word.size(); k++){
				if(word[k] == getSpot(i,j)) return 1 ;
			}
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xf, -0x1c(%rbp)
jge 0x5bef
movl $0x0, -0x20(%rbp)
cmpl $0xf, -0x20(%rbp)
jge 0x5bdf
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x24(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2130
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x5bd2
movq -0x38(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x22e0
movq -0x30(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x44(%rbp)
movl -0x1c(%rbp), %esi
movl -0x20(%rbp), %edx
callq 0x5ac0
movb %al, %cl
movl -0x44(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x5bc5
movl $0x1, -0x4(%rbp)
jmp 0x5bf6
jmp 0x5bc7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5b71
jmp 0x5bd4
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x5b64
jmp 0x5be1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5b53
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: 7shi[P]8086run/v2/bios.cpp
// Function: moveCursorToBottom()
void moveCursorToBottom() {
    if (cleared) {
        AH = 2, DL = 79, DH = 24;
        bios(0x10);
        AX = 0x0e0d;
        bios(0x10);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x12a447(%rip), %rax    # 0x12d5b2
testb $0x1, (%rax)
je 0x31ba
leaq 0x12a2e9(%rip), %rax    # 0x12d460
movq 0x20(%rax), %rax
movb $0x2, (%rax)
leaq 0x12a2db(%rip), %rax    # 0x12d460
movq 0x10(%rax), %rax
movb $0x4f, (%rax)
leaq 0x12a2cd(%rip), %rax    # 0x12d460
movq 0x30(%rax), %rax
movb $0x18, (%rax)
movl $0x10, %edi
callq 0x24c0
leaq 0x12a2a5(%rip), %rax    # 0x12d450
movw $0xe0d, (%rax)          # imm = 0xE0D
movl $0x10, %edi
callq 0x24c0
popq %rbp
retq
nopl (%rax)
// File: 7shi[P]8086run/v2/utils.cpp
// Function: msleep(int)
void msleep(int msec) {
    if (msec < 0) return;
#ifdef _WIN32
    Sleep(msec);
#else
    struct timespec ts = { msec / 1000, (msec % 1000) * 1000000 };
    nanosleep(&ts, NULL);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jge 0x8ff3
jmp 0x9028
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
imull $0xf4240, %edx, %eax    # imm = 0xF4240
cltq
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2050
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 7shi[P]8086run/v2/utils.cpp
// Function: mclock()
int mclock() {
#ifdef _WIN32
    clock_t clk = clock();
    static clock_t clk0 = clk;
    clk -= clk0;
    return clk * 1000 / CLOCKS_PER_SEC;
#else
    struct timeval tv;
    gettimeofday(&tv, NULL);
    static time_t sec0 = tv.tv_sec;
    return (tv.tv_sec - sec0) * 1000 + tv.tv_usec / 1000;
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2240
cmpb $0x0, 0x12462c(%rip)    # 0x12d678
jne 0x9076
leaq 0x124623(%rip), %rdi    # 0x12d678
callq 0x2270
cmpl $0x0, %eax
je 0x9076
movq -0x10(%rbp), %rax
movq %rax, 0x124606(%rip)    # 0x12d670
leaq 0x124607(%rip), %rdi    # 0x12d678
callq 0x20a0
movq -0x10(%rbp), %rax
subq 0x1245ef(%rip), %rax    # 0x12d670
imulq $0x3e8, %rax, %rax      # imm = 0x3E8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx            # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Rekran[P]HahTable-Chaining-/LinkedList.cpp
// Function: LinkedList::print()
void LinkedList::print(){
	Node *n = this->header.head;
	for(int i = 0;i < this->header.size; i++){
		std::cout<<"["<<i<<"]"<<n->word<<" ";
		n = n->Next;
		
		if(i%10 == 0 && i != 0)
			std::cout<<std::endl;	
 	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x2592
movq 0x4acf(%rip), %rdi      # 0x6fd8
leaq 0x1af4(%rip), %rsi      # 0x4004
callq 0x2130
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2200
movq %rax, %rdi
leaq 0x1adc(%rip), %rsi      # 0x4006
callq 0x2130
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x2130
movq %rax, %rdi
leaq 0x1ac4(%rip), %rsi      # 0x400d
callq 0x2130
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x2582
cmpl $0x0, -0x14(%rbp)
je 0x2582
movq 0x4a62(%rip), %rdi      # 0x6fd8
movq 0x4a4b(%rip), %rsi      # 0x6fc8
callq 0x2160
jmp 0x2584
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x24f2
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Rekran[P]HahTable-Chaining-/LinkedList.cpp
// Function: LinkedList::prepend(char*)
void LinkedList::prepend(char *word){
	if(header.head == NULL){
		Node *N1 = new Node();
		N1->word = word;
		
		this->header.head = N1;
		this->header.tail = N1;
		
		this->header.size += 1;	
			
	}else{
		
		Node *N1 = new Node();
		N1->word = word;
		
		N1->Next = header.head;
		this->header.head = N1;
		
		this->header.size += 1;	
	}

}

// 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)
cmpq $0x0, (%rax)
jne 0x262a
movl $0x18, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x2400
jmp 0x25d9
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x2695
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x2150
jmp 0x269b
movl $0x18, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x2400
jmp 0x2645
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x10(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq (%rax), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x2695
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x2150
jmp 0x269b
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: Rekran[P]HahTable-Chaining-/LinkedList.cpp
// Function: LinkedList::prepend(int)
void LinkedList::prepend(int value){
	if(header.head == NULL){
		Node *N1 = new Node();
		N1->Value = value;
		
		this->header.head = N1;
		this->header.tail = N1;
		
		this->header.size += 1;	
			
	}else{
		
		Node *N1 = new Node();
		N1->Value = value;
		
		N1->Next = header.head;
		this->header.head = N1;
		
		this->header.size += 1;	
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0x2737
movl $0x18, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x2400
jmp 0x26e8
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x10(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x27a0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x2150
jmp 0x27a6
movl $0x18, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x2400
jmp 0x2752
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl -0xc(%rbp), %edx
movq -0x30(%rbp), %rcx
movl %edx, 0x10(%rcx)
movq (%rax), %rdx
movq -0x30(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x27a0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x2150
jmp 0x27a6
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2210
nop
// File: Rekran[P]HahTable-Chaining-/LinkedList.cpp
// Function: LinkedList::append(int)
void LinkedList::append(int value){
	
	if(this->header.head == NULL){
		
		Node *N1 = new Node();
		N1->Value = value;
		
		this->header.head = N1;
		this->header.tail = N1;
		
		this->header.size += 1;	
			
	}else{
		
		Node *N1 = new Node();
		N1->Value = value;
		
		this->header.tail->Next = N1;
		this->header.tail = N1;		
		this->header.size += 1;	
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0x2837
movl $0x18, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x2400
jmp 0x27e8
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movl %edx, 0x10(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x28a2
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x2150
jmp 0x28a8
movl $0x18, %edi
callq 0x2140
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x2400
jmp 0x2852
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movl -0xc(%rbp), %edx
movq -0x30(%rbp), %rcx
movl %edx, 0x10(%rcx)
movq -0x30(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, (%rcx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x28a2
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x2150
jmp 0x28a8
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::search(char*)
bool HashTable::search(char *word){
	
	LinkedList &L = this->table[this->hash(word)];
	
	Node *aux = L.getHead();
	
while(aux != NULL){
	
	if(strcmp(aux->word,word) == 0){
		return true;
	}
	aux = aux->Next;
	
}
	
	
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x2a10
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x24b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2a01
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x21a0
cmpl $0x0, %eax
jne 0x29f4
movb $0x1, -0x1(%rbp)
jmp 0x2a05
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x29d1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::hash(char*)
unsigned int HashTable::hash(char *word){
	int size = strlen(word);
	int i;
	unsigned int value = 5381;
	
	for(i = 0;i< size;i++ ){
	
	value += (value << 5)  + word[i];
	
	}
	return value%MAX;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20b0
movl %eax, -0x14(%rbp)
movl $0x1505, -0x1c(%rbp)    # imm = 0x1505
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2a67
movl -0x1c(%rbp), %eax
shll $0x5, %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2a3a
movl -0x1c(%rbp), %eax
movl $0x14, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::loadDictionary(char*)
void HashTable::loadDictionary(char *path){
string line;
  
  ifstream myfile(path);
  if (myfile.is_open())
  {
    while ( myfile>>line )
    {
    
    	int n = line.length() + 1;
		char *char_array = new char[n];	
    	strcpy(char_array, line.c_str()); 
    	this->guarda(char_array);
    }
    myfile.close();
  }
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2190
movq -0x10(%rbp), %rsi
leaq -0x238(%rbp), %rdi
movl $0x8, %edx
callq 0x2220
jmp 0x2abe
leaq -0x238(%rbp), %rdi
callq 0x21e0
movb %al, -0x259(%rbp)
jmp 0x2ad2
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x2ae1
jmp 0x2be1
jmp 0x2ae3
leaq -0x238(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2180
movq %rax, -0x268(%rbp)
jmp 0x2afc
movq -0x268(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2170
movb %al, -0x269(%rbp)
jmp 0x2b1a
movb -0x269(%rbp), %al
testb $0x1, %al
jne 0x2b29
jmp 0x2bd1
leaq -0x30(%rbp), %rdi
callq 0x21c0
incl %eax
movl %eax, -0x248(%rbp)
movslq -0x248(%rbp), %rdi
callq 0x2030
movq %rax, -0x278(%rbp)
jmp 0x2b4f
movq -0x278(%rbp), %rax
movq %rax, -0x250(%rbp)
movq -0x250(%rbp), %rax
movq %rax, -0x280(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2090
movq -0x280(%rbp), %rdi
movq %rax, %rsi
callq 0x2120
movq -0x258(%rbp), %rdi
movq -0x250(%rbp), %rsi
callq 0x2c20
jmp 0x2b98
jmp 0x2ae3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
jmp 0x2bff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x2050
jmp 0x2bff
leaq -0x238(%rbp), %rdi
callq 0x2040
jmp 0x2bdf
jmp 0x2be1
leaq -0x238(%rbp), %rdi
callq 0x2050
leaq -0x30(%rbp), %rdi
callq 0x20e0
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x240(%rbp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
// File: Rekran[P]HahTable-Chaining-/HashTable.cpp
// Function: HashTable::print()
void HashTable::print(){
	
	for(int i = 0; i < MAX ; i++){
		LinkedList &l = this->table[i];
		std::cout << "Index "<< i << std::endl; 
		l.print();
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x2db8
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x426d(%rip), %rdi      # 0x6fd8
leaq 0x1296(%rip), %rsi      # 0x4008
callq 0x2130
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2200
movq %rax, %rdi
movq 0x423c(%rip), %rsi      # 0x6fc8
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x24d0
movq 0x4237(%rip), %rdi      # 0x6fd8
movq 0x4220(%rip), %rsi      # 0x6fc8
callq 0x2160
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d4b
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Rekran[P]HahTable-Chaining-/main.cpp
// Function: main
int main(int argc, char** argv) {
vector<string>erros;
HashTable ht = HashTable();

ht.loadDictionary("dictionary.txt");

string word;
  ifstream myfile("text.txt");
  if (myfile.is_open())
  {
    while ( myfile>>word )
    {
    	if(!ht.search(&word[0]))
			erros.push_back(word);
    }
    myfile.close();
  }
for(int i = 0; i< erros.size();i++)
	cout<<erros[i]<<endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp            # imm = 0x480
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3060
leaq -0x208(%rbp), %rdi
callq 0x28f0
jmp 0x2df0
leaq 0x1218(%rip), %rsi      # 0x400f
leaq -0x208(%rbp), %rdi
callq 0x2a80
jmp 0x2e05
leaq -0x238(%rbp), %rdi
callq 0x2190
leaq 0x1206(%rip), %rsi      # 0x401e
leaq -0x440(%rbp), %rdi
movl $0x8, %edx
callq 0x2220
jmp 0x2e2b
leaq -0x440(%rbp), %rdi
callq 0x21e0
movb %al, -0x445(%rbp)
jmp 0x2e3f
movb -0x445(%rbp), %al
testb $0x1, %al
jne 0x2e4e
jmp 0x2f6a
jmp 0x2e50
leaq -0x440(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x2180
movq %rax, -0x450(%rbp)
jmp 0x2e6c
movq -0x450(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2170
movb %al, -0x451(%rbp)
jmp 0x2e8a
movb -0x451(%rbp), %al
testb $0x1, %al
jne 0x2e99
jmp 0x2f5a
xorl %eax, %eax
movl %eax, %esi
leaq -0x238(%rbp), %rdi
callq 0x2230
movq %rax, -0x460(%rbp)
jmp 0x2eb2
movq -0x460(%rbp), %rsi
leaq -0x208(%rbp), %rdi
callq 0x2990
movb %al, -0x461(%rbp)
jmp 0x2ecd
movb -0x461(%rbp), %al
testb $0x1, %al
jne 0x2f55
jmp 0x2ed9
leaq -0x28(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3080
jmp 0x2eeb
jmp 0x2f55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x3042
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x3036
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x302a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x2050
jmp 0x302a
jmp 0x2e50
leaq -0x440(%rbp), %rdi
callq 0x2040
jmp 0x2f68
jmp 0x2f6a
movl $0x0, -0x444(%rbp)
movslq -0x444(%rbp), %rax
movq %rax, -0x470(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x30f0
movq %rax, %rcx
movq -0x470(%rbp), %rax
cmpq %rcx, %rax
jae 0x2fea
movslq -0x444(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x3110
movq %rax, %rsi
movq 0x4024(%rip), %rdi      # 0x6fd8
callq 0x2110
movq %rax, -0x478(%rbp)
jmp 0x2fc2
movq -0x478(%rbp), %rdi
movq 0x3ff8(%rip), %rsi      # 0x6fc8
callq 0x2160
jmp 0x2fd7
jmp 0x2fd9
movl -0x444(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x444(%rbp)
jmp 0x2f74
movl $0x0, -0x4(%rbp)
leaq -0x440(%rbp), %rdi
callq 0x2050
leaq -0x238(%rbp), %rdi
callq 0x20e0
leaq -0x208(%rbp), %rdi
callq 0x2c70
leaq -0x28(%rbp), %rdi
callq 0x3130
movl -0x4(%rbp), %eax
addq $0x480, %rsp            # imm = 0x480
popq %rbp
retq
leaq -0x238(%rbp), %rdi
callq 0x20e0
leaq -0x208(%rbp), %rdi
callq 0x2c70
leaq -0x28(%rbp), %rdi
callq 0x3130
movq -0x210(%rbp), %rdi
callq 0x2210
nopw (%rax,%rax)
// File: wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: fill_random(std::vector<unsigned long, std::allocator<unsigned long>>&, unsigned long)
void fill_random(std::vector<std::size_t>& vec, std::size_t size){
    std::mt19937 generator;
    std::uniform_int_distribution<std::size_t> distribution(0, MAX);

    for(std::size_t i = 0; i < size; ++i){
        vec.push_back(distribution(generator));
    }
}

// Assembly:
subq $0x13c8, %rsp           # imm = 0x13C8
movq %rdi, 0x13c0(%rsp)
movq %rsi, 0x13b8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1e50
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2faf080, %edx        # imm = 0x2FAF080
callq 0x1e70
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x13b8(%rsp), %rax
jae 0x132c
movq 0x13c0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1ed0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1ea0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x12dd
addq $0x13c8, %rsp           # imm = 0x13C8
retq
nopw %cs:(%rax,%rax)
// File: wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: display_vec(std::vector<unsigned long, std::allocator<unsigned long>>&)
void display_vec(std::vector<std::size_t>& vec){
    if(vec.size() > 0){
        std::cout << vec[0];

        for(std::size_t i = 1; i < vec.size(); ++i){
            std::cout << ", " << vec[i];
        }

        std::cout << std::endl;
    } else {
        std::cout << "empty" << std::endl;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1f00
cmpq $0x0, %rax
jbe 0x13fd
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1f20
movq (%rax), %rsi
movq 0x7c63(%rip), %rdi      # 0x8fd8
callq 0x1040
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1f00
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x13e8
movq 0x7c2d(%rip), %rdi      # 0x8fd8
leaq 0x4c52(%rip), %rsi      # 0x6004
callq 0x10d0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1f20
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0x1040
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x1383
movq 0x7be9(%rip), %rdi      # 0x8fd8
movq 0x7bd2(%rip), %rsi      # 0x8fc8
callq 0x10f0
jmp 0x141f
movq 0x7bd4(%rip), %rdi      # 0x8fd8
leaq 0x4bfc(%rip), %rsi      # 0x6007
callq 0x10d0
movq %rax, %rdi
movq 0x7bae(%rip), %rsi      # 0x8fc8
callq 0x10f0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: in_place_counting_sort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void in_place_counting_sort(std::vector<std::size_t>& A){
    std::vector<std::size_t> C(MAX + 1);

    for (std::size_t i = 0; i < SIZE; ++i){
        ++C[A[i]];
    }

    int current = 0;
    for (std::size_t i = 0; i < MAX; ++i){
        for(std::size_t j =0; j < C[i]; ++j){
            A[current++] = i;
        }
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
leaq 0x57(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1fe0
movq 0x18(%rsp), %rdx
leaq 0x58(%rsp), %rdi
movl $0x2faf081, %esi        # imm = 0x2FAF081
callq 0x1ff0
jmp 0x149e
leaq 0x57(%rsp), %rdi
callq 0x2070
movq $0x0, 0x38(%rsp)
cmpq $0x4c4b40, 0x38(%rsp)   # imm = 0x4C4B40
jae 0x150f
movq 0x70(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1f20
movq (%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1f20
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x14b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x2070
jmp 0x15be
movl $0x0, 0x34(%rsp)
movq $0x0, 0x28(%rsp)
cmpq $0x2faf080, 0x28(%rsp)  # imm = 0x2FAF080
jae 0x15af
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1f20
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq (%rcx), %rax
jae 0x159a
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x34(%rsp)
movslq %eax, %rsi
callq 0x1f20
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x1538
jmp 0x159c
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x1520
leaq 0x58(%rsp), %rdi
callq 0x2080
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x1140
nopl (%rax,%rax)
// File: wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: counting_sort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void counting_sort(std::vector<std::size_t>& A){
    std::vector<std::size_t> B(SIZE);
    std::vector<std::size_t> C(MAX);

    for (std::size_t i = 0; i < SIZE; ++i){
        ++C[A[i]];
    }

    for (std::size_t i = 1; i <= MAX; ++i){
        C[i] += C[i - 1];
    }

    for (long i = SIZE - 1; i >= 0; --i) {
        B[C[A[i]] - 1] = A[i];
        --C[A[i]];
    }

    for (std::size_t i = 0; i < SIZE; ++i){
        A[i] = B[i];
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1fe0
movq 0x28(%rsp), %rdx
leaq 0x88(%rsp), %rdi
movl $0x4c4b40, %esi         # imm = 0x4C4B40
callq 0x1ff0
jmp 0x160a
leaq 0x87(%rsp), %rdi
callq 0x2070
leaq 0x57(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1fe0
movq 0x20(%rsp), %rdx
leaq 0x58(%rsp), %rdi
movl $0x2faf080, %esi        # imm = 0x2FAF080
callq 0x1ff0
jmp 0x163c
leaq 0x57(%rsp), %rdi
callq 0x2070
movq $0x0, 0x48(%rsp)
cmpq $0x4c4b40, 0x48(%rsp)   # imm = 0x4C4B40
jae 0x16e1
movq 0xa0(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x1f20
movq (%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1f20
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x164f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x2070
jmp 0x1857
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x2070
leaq 0x88(%rsp), %rdi
callq 0x2080
jmp 0x1857
movq $0x1, 0x40(%rsp)
cmpq $0x2faf080, 0x40(%rsp)  # imm = 0x2FAF080
ja 0x173a
movq 0x40(%rsp), %rsi
subq $0x1, %rsi
leaq 0x58(%rsp), %rdi
callq 0x1f20
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1f20
movq 0x18(%rsp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x16ea
movq $0x4c4b3f, 0x38(%rsp)   # imm = 0x4C4B3F
cmpq $0x0, 0x38(%rsp)
jl 0x17e0
movq 0xa0(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1f20
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1f20
movq (%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1f20
movq (%rax), %rsi
subq $0x1, %rsi
leaq 0x88(%rsp), %rdi
callq 0x1f20
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0xa0(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1f20
movq (%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0x1f20
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x1743
movq $0x0, 0x30(%rsp)
cmpq $0x4c4b40, 0x30(%rsp)   # imm = 0x4C4B40
jae 0x1838
movq 0x30(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x1f20
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1f20
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x17e9
leaq 0x58(%rsp), %rdi
callq 0x2080
leaq 0x88(%rsp), %rdi
callq 0x2080
addq $0xa8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
// File: wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: binsort(std::vector<unsigned long, std::allocator<unsigned long>>&)
void binsort(std::vector<std::size_t>& A){
    std::vector<std::vector<std::size_t>> B(MAX + 1);

    for(std::size_t i = 0; i < SIZE; ++i){
        B[A[i]].push_back(A[i]);
    }

    std::size_t current = 0;
    for(std::size_t i = 0; i < MAX; ++i){
        for(auto item : B[i]){
            A[current++] = item;
        }
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x20e0
movq 0x10(%rsp), %rdx
leaq 0x68(%rsp), %rdi
movl $0x2faf081, %esi        # imm = 0x2FAF081
callq 0x20f0
jmp 0x18a4
leaq 0x67(%rsp), %rdi
callq 0x2170
movq $0x0, 0x48(%rsp)
cmpq $0x4c4b40, 0x48(%rsp)   # imm = 0x4C4B40
jae 0x1957
movq 0x80(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x1f20
movq (%rax), %rsi
leaq 0x68(%rsp), %rdi
callq 0x2180
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x1f20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x21a0
jmp 0x190b
jmp 0x190d
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x18b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x2170
jmp 0x1a32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2280
jmp 0x1a32
movq $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
cmpq $0x2faf080, 0x38(%rsp)  # imm = 0x2FAF080
jae 0x1a20
movq 0x38(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x2180
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1f80
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1fb0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x2210
testb $0x1, %al
jne 0x19bf
jmp 0x1a0b
leaq 0x28(%rsp), %rdi
callq 0x2250
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x80(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq %rsi, %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
callq 0x1f20
movq (%rsp), %rcx
movq %rcx, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x2260
jmp 0x19aa
jmp 0x1a0d
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x1969
leaq 0x68(%rsp), %rdi
callq 0x2280
addq $0x88, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x1140
nopl (%rax)
// File: wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: main
int main(){
    std::cout << "std::sort" << std::endl;
    bench(&std_sort);

    std::cout << "counting_sort" << std::endl;
    bench(&counting_sort);

    std::cout << "in_place_counting_sort" << std::endl;
    bench(&in_place_counting_sort);

    std::cout << "binsort" << std::endl;
    bench(&::binsort);

    std::cout << "radix_sort" << std::endl;
    bench(&radix_sort);

    return 0;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
movq 0x7278(%rip), %rdi      # 0x8fd8
leaq 0x42a6(%rip), %rsi      # 0x600d
callq 0x10d0
movq %rax, %rdi
movq 0x7252(%rip), %rsi      # 0x8fc8
callq 0x10f0
leaq -0x952(%rip), %rdi      # 0x1430
callq 0x22e0
movq 0x724a(%rip), %rdi      # 0x8fd8
leaq 0x428b(%rip), %rsi      # 0x6020
callq 0x10d0
movq %rax, %rdi
movq 0x7224(%rip), %rsi      # 0x8fc8
callq 0x10f0
leaq -0x7e0(%rip), %rdi      # 0x15d0
callq 0x22e0
movq 0x721c(%rip), %rdi      # 0x8fd8
leaq 0x4254(%rip), %rsi      # 0x6017
callq 0x10d0
movq %rax, %rdi
movq 0x71f6(%rip), %rsi      # 0x8fc8
callq 0x10f0
leaq -0x96e(%rip), %rdi      # 0x1470
callq 0x22e0
movq 0x71ee(%rip), %rdi      # 0x8fd8
leaq 0x423d(%rip), %rsi      # 0x602e
callq 0x10d0
movq %rax, %rdi
movq 0x71c8(%rip), %rsi      # 0x8fc8
callq 0x10f0
leaq -0x59c(%rip), %rdi      # 0x1870
callq 0x22e0
movq 0x71c0(%rip), %rdi      # 0x8fd8
leaq 0x4217(%rip), %rsi      # 0x6036
callq 0x10d0
movq %rax, %rdi
movq 0x719a(%rip), %rsi      # 0x8fc8
callq 0x10f0
leaq -0x3fa(%rip), %rdi      # 0x1a40
callq 0x22e0
xorl %eax, %eax
popq %rcx
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: wichtounet[P]articles/src/linear_sorting/bench.cpp
// Function: void bench<void (*)(std::vector<unsigned long, std::allocator<unsigned long>>&)>(void (*)(std::vector<unsigned long, std::allocator<unsigned long>>&))
void bench(Function sort_function){
    std::array<std::vector<std::size_t>, REPEAT> vec;

    for(std::size_t i = 0; i < REPEAT; ++i){
        fill_random(vec[i], SIZE);
    }

    Clock::time_point t0 = Clock::now();

    for(std::size_t i = 0; i < REPEAT; ++i){
        sort_function(vec[i]);
    }

    Clock::time_point t1 = Clock::now();
    milliseconds ms = std::chrono::duration_cast<milliseconds>(t1 - t0);

    std::cout << ms.count() << "ms" << std::endl;

    if(DISPLAY){
        display_vec(vec[0]);
    }
}

// Assembly:
subq $0x2d8, %rsp            # imm = 0x2D8
movq %rdi, 0x2d0(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5630
movq $0x0, 0x70(%rsp)
cmpq $0x19, 0x70(%rsp)
jae 0x2357
movq 0x70(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x5680
movq %rax, %rdi
movl $0x4c4b40, %esi         # imm = 0x4C4B40
callq 0x12a0
jmp 0x2328
jmp 0x232a
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x2302
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5740
jmp 0x2457
callq 0x1030
movq %rax, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
cmpq $0x19, 0x50(%rsp)
jae 0x23ac
movq 0x2d0(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x78(%rsp), %rdi
callq 0x5680
movq %rax, %rdi
movq 0x30(%rsp), %rax
callq *%rax
jmp 0x239a
jmp 0x239c
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x236a
callq 0x1030
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x56e0
movq %rax, 0x28(%rsp)
jmp 0x23cc
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x56b0
movq %rax, 0x20(%rsp)
jmp 0x23e7
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x5730
movq %rax, 0x18(%rsp)
jmp 0x2402
movq 0x18(%rsp), %rsi
movq 0x6bca(%rip), %rdi      # 0x8fd8
callq 0x1150
movq %rax, 0x10(%rsp)
jmp 0x241a
movq 0x10(%rsp), %rdi
leaq 0x3c66(%rip), %rsi      # 0x608c
callq 0x10d0
movq %rax, 0x8(%rsp)
jmp 0x2432
movq 0x8(%rsp), %rdi
movq 0x6b8a(%rip), %rsi      # 0x8fc8
callq 0x10f0
jmp 0x2445
leaq 0x78(%rsp), %rdi
callq 0x5740
addq $0x2d8, %rsp            # imm = 0x2D8
retq
movq 0x68(%rsp), %rdi
callq 0x1140
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/test/units/dataprov_hook/hook_srv.c
// Function: cmd_handler
scdcint_t cmd_handler(void *data, const char *cmd, const char *params, scdcint_t params_size)
{
  printf(PREFIX "cmd_handler: cmd: '%s', data: %p\n", cmd, data);

  if (strcmp(cmd, "quit") == 0)
  {
    printf(PREFIX "quiting server\n");
    sighandler(0);

  } else
  {
    printf(PREFIX "unkown server command: '%s'\n", cmd);
  }

  return SCDC_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0x7c79c(%rip), %rdi     # 0x8a023
movb $0x0, %al
callq 0xcd30
movq -0x10(%rbp), %rdi
leaq 0x7c7b6(%rip), %rsi     # 0x8a04f
callq 0xc980
cmpl $0x0, %eax
jne 0xd8ba
leaq 0x7c7aa(%rip), %rdi     # 0x8a054
movb $0x0, %al
callq 0xcd30
xorl %edi, %edi
callq 0xd810
jmp 0xd8cc
movq -0x10(%rbp), %rsi
leaq 0x7c7a9(%rip), %rdi     # 0x8a06e
movb $0x0, %al
callq 0xcd30
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/test/units/dataprov_hook/hook_srv.c
// Function: main
int main(int argc, char *argv[])
{
  scdc_dataprov_t dp_hook = SCDC_DATAPROV_NULL;


  printf(PREFIX "start hook demo server\n");

  signal(SIGABRT, &sighandler);
  signal(SIGTERM, &sighandler);
  signal(SIGINT, &sighandler);

  scdc_init(SCDC_INIT_DEFAULT);

  dp_hook = scdc_dataprov_open("hookdemo", "hook:id", &hook, 0x2501);

#if NODEPORT_TCP
  np_tcp = scdc_nodeport_open("tcp:max_connections", 2);
#endif
#if NODEPORT_UDS
  np_uds = scdc_nodeport_open("uds:max_connections", 2);
#endif
#if NODEPORT_STREAM
  np_stream = scdc_nodeport_open("stream:cmd_handler", cmd_handler, NULL);
#endif

#if NODEPORT_TCP
  scdc_nodeport_start(np_tcp, NODEPORT_TCP);
#endif
#if NODEPORT_UDS
  scdc_nodeport_start(np_uds, NODEPORT_UDS);
#endif
#if NODEPORT_STREAM
  scdc_nodeport_start(np_stream, NODEPORT_STREAM);
#endif

  printf(PREFIX "Press <ENTER> to quit!\n");
  getchar();

#if NODEPORT_STREAM
  scdc_nodeport_stop(np_stream);
#endif
#if NODEPORT_UDS
  scdc_nodeport_stop(np_uds);
#endif
#if NODEPORT_TCP
  scdc_nodeport_stop(np_tcp);
#endif

#if NODEPORT_STREAM
  scdc_nodeport_close(np_stream);
#endif
#if NODEPORT_UDS
  scdc_nodeport_close(np_uds);
#endif
#if NODEPORT_TCP
  scdc_nodeport_close(np_tcp);
#endif

  scdc_dataprov_close(dp_hook);

  scdc_release();

  printf(PREFIX "quit hook demo server\n");

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
leaq 0x7c790(%rip), %rdi     # 0x8a095
movb $0x0, %al
callq 0xcd30
movl $0x6, %edi
leaq -0x108(%rip), %rsi      # 0xd810
callq 0xc820
movl $0xf, %edi
leaq -0x119(%rip), %rsi      # 0xd810
callq 0xc820
movl $0x2, %edi
leaq -0x12a(%rip), %rsi      # 0xd810
callq 0xc820
leaq 0x7d149(%rip), %rdi     # 0x8aa8f
movb $0x0, %al
callq 0xe440
leaq 0x7c763(%rip), %rdi     # 0x8a0b7
leaq 0x7c765(%rip), %rsi     # 0x8a0c0
leaq 0xa41be(%rip), %rdx     # 0xb1b20
movl $0x2501, %ecx           # imm = 0x2501
movb $0x0, %al
callq 0xe970
movq %rax, -0x18(%rbp)
leaq 0x7c74f(%rip), %rdi     # 0x8a0c8
movl $0x2, %esi
movb $0x0, %al
callq 0xebb0
movq %rax, 0xa6d4c(%rip)     # 0xb46d8
leaq 0x7c749(%rip), %rdi     # 0x8a0dc
movl $0x2, %esi
movb $0x0, %al
callq 0xebb0
movq %rax, 0xa6d3a(%rip)     # 0xb46e0
movq 0xa6d2b(%rip), %rdi     # 0xb46d8
movl $0x4, %esi
callq 0xecc0
movq 0xa6d22(%rip), %rdi     # 0xb46e0
movl $0x4, %esi
callq 0xecc0
leaq 0x7c721(%rip), %rdi     # 0x8a0f0
movb $0x0, %al
callq 0xcd30
callq 0xc970
movq 0xa6cfe(%rip), %rdi     # 0xb46e0
callq 0xed20
movq 0xa6cea(%rip), %rdi     # 0xb46d8
callq 0xed20
movq 0xa6ce6(%rip), %rdi     # 0xb46e0
callq 0xec80
movq 0xa6cd2(%rip), %rdi     # 0xb46d8
callq 0xec80
movq -0x18(%rbp), %rdi
callq 0xea40
callq 0xe5f0
leaq 0x7c6f2(%rip), %rdi     # 0x8a112
movb $0x0, %al
callq 0xcd30
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: eschwabe[P]interview-practice/src/parenthesization.cpp
// Function: BuildString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void BuildString(const string current, int left_rem, int right_rem, vector<string>* list) {
    if(left_rem == 0 && right_rem == 0) {
        list->push_back(current);
    } else {
        if(left_rem > 0) {
            BuildString(current+"(", left_rem-1, right_rem, list);
        }
        if(right_rem > left_rem) {
            BuildString(current+")", left_rem, right_rem-1, list);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x23ab
cmpl $0x0, -0x10(%rbp)
jne 0x23ab
movq -0x70(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x2610
jmp 0x245d
cmpl $0x0, -0xc(%rbp)
jle 0x2402
movq -0x70(%rbp), %rsi
leaq 0x1c48(%rip), %rdx      # 0x4004
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2680
movq -0x78(%rbp), %rdi
movl -0xc(%rbp), %esi
decl %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x2370
jmp 0x23e0
leaq -0x38(%rbp), %rdi
callq 0x20b0
jmp 0x2402
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20b0
jmp 0x2466
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x245b
movq -0x70(%rbp), %rsi
leaq 0x1bf1(%rip), %rdx      # 0x4006
leaq -0x68(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2680
movq -0x80(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
decl %edx
movq -0x18(%rbp), %rcx
callq 0x2370
jmp 0x2439
leaq -0x68(%rbp), %rdi
callq 0x20b0
jmp 0x245b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20b0
jmp 0x2466
jmp 0x245d
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x21e0
nop
// File: eschwabe[P]interview-practice/src/parenthesization.cpp
// Function: main
int main(int argc, char *argv[])
{
    const int count = 4;
    vector<string> tmp;
    BuildString("", count, count, &tmp);

    for(auto s : tmp) {
        cout << s << endl;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4, -0x14(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2700
leaq -0x51(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x21f0
movq -0xa8(%rbp), %rdx
leaq 0x1b4e(%rip), %rsi      # 0x4005
leaq -0x50(%rbp), %rdi
callq 0x2720
jmp 0x24c2
leaq -0x50(%rbp), %rdi
movl $0x4, %edx
leaq -0x30(%rbp), %rcx
movl %edx, %esi
callq 0x2370
jmp 0x24d8
leaq -0x50(%rbp), %rdi
callq 0x20b0
leaq -0x51(%rbp), %rdi
callq 0x2170
leaq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x27d0
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x2800
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x2830
testb $0x1, %al
jne 0x2522
jmp 0x25da
leaq -0x78(%rbp), %rdi
callq 0x2870
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
callq 0x2070
jmp 0x253c
movq 0x3a95(%rip), %rdi      # 0x5fd8
leaq -0xa0(%rbp), %rsi
callq 0x2120
movq %rax, -0xb0(%rbp)
jmp 0x2558
movq -0xb0(%rbp), %rdi
movq 0x3a62(%rip), %rsi      # 0x5fc8
callq 0x2150
jmp 0x256d
leaq -0xa0(%rbp), %rdi
callq 0x20b0
leaq -0x78(%rbp), %rdi
callq 0x2890
jmp 0x250c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x25a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x20b0
leaq -0x51(%rbp), %rdi
callq 0x2170
jmp 0x25f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x25f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x20b0
jmp 0x25f6
movl $0x0, -0x4(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x28b0
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x28b0
movq -0x60(%rbp), %rdi
callq 0x21e0
nopl (%rax,%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc4.cc
// Function: operator<<(std::ostream&, TOKENTYPE const&)
ostream& operator<<(ostream& out, const TOKENTYPE& t) {
    string repr;
    switch(t) {
        case TOKENTYPE::ENDOFFILE:
            repr = "ENDOFFILE";
            break;
        case TOKENTYPE::INTEGER:
            repr = "INTEGER";
            break;
        case TOKENTYPE::PLUS:
            repr = "PLUS";
            break;
        case TOKENTYPE::MINUS:
            repr = "MINUS";
            break;
        case TOKENTYPE::MUL:
            repr = "MUL";
            break;
        case TOKENTYPE::DIV:
            repr = "DIV";
            break;
    }

    out << repr;
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2240
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x48(%rbp)
subq $0x5, %rax
ja 0x2523
movq -0x48(%rbp), %rax
leaq 0x1b7c(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b84(%rip), %rsi      # 0x401c
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24a3
jmp 0x2523
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
jmp 0x254d
leaq 0x1b60(%rip), %rsi      # 0x4026
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24d1
jmp 0x2523
leaq 0x1b54(%rip), %rsi      # 0x402e
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24e5
jmp 0x2523
leaq 0x1b45(%rip), %rsi      # 0x4033
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x24f9
jmp 0x2523
leaq 0x1b37(%rip), %rsi      # 0x4039
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x250d
jmp 0x2523
leaq 0x1b27(%rip), %rsi      # 0x403d
leaq -0x30(%rbp), %rdi
callq 0x2230
jmp 0x2521
jmp 0x2523
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2160
jmp 0x2532
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22b0
nopw %cs:(%rax,%rax)