LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/zengfenfei[P]codility/src/MinAvgTwoSlice.cpp
// Function: main
int main() {
	vector<int> A(7);
	A[0] = 4;
	A[1] = 2;
	A[2] = 2;
	A[3] = 5;
	A[4] = 1;
	A[5] = 5;
	A[6] = 8;

	cout << solution(A) << '\n';	// 1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x1c, %edi
callq 0x1040
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
movq %rax, (%rdi)
addq $0x1c, %rax
movq %rax, 0x10(%rdi)
movq %rax, 0x8(%rdi)
movaps 0xd4d(%rip), %xmm0      # 0x2020
movups %xmm0, (%rbx)
movabsq $0x500000001, %rax      # imm = 0x500000001
movq %rax, 0x10(%rbx)
movl $0x8, 0x18(%rbx)
callq 0x11dc
movq 0x2ce1(%rip), %rdi      # 0x3fd8
movl %eax, %esi
callq 0x1080
leaq -0x11(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1060
movl $0x1c, %esi
movq %rbx, %rdi
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0x1c, %esi
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/robertomaldonado[P]HypercubeTopologyRouting/links.cpp
// Function: factorial(int)
int factorial(int n){
    int fact = 1;
    while( n>0 ){
      fact = fact*n;
      n--;
    }
    return fact;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %eax
testl %edi, %edi
jle 0x37ba
imull %edi, %eax
leal -0x1(%rdi), %ecx
cmpl $0x1, %edi
movl %ecx, %edi
ja 0x37ad
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/robertomaldonado[P]HypercubeTopologyRouting/checker.cpp
// Function: isArgCountCorrect(int)
int isArgCountCorrect(int arg_count){
    if (arg_count != 3){
        cout << "Usage: ./executable Nsize [dim|all]" << endl;
        return 0;
    }else{
        return 1;
    }
}

// Assembly:
movl $0x1, %eax
cmpl $0x3, %edi
je 0x432a
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x3ce9(%rip), %rbx      # 0x7fd0
leaq 0xe76(%rip), %rsi       # 0x5164
movl $0x23, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/robertomaldonado[P]HypercubeTopologyRouting/checker.cpp
// Function: isPowerOfTwo(int)
int isPowerOfTwo(int n_size){

    if ( (ceil(log2(n_size)) == floor(log2(n_size))) ){
        return 1;
    }else{
        cout << "Error: Nsize must be a power of 2 for hypercube." << endl;
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
cvtsi2sd %edi, %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0x2290
callq 0x2070
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x2290
callq 0x2260
movl $0x1, %eax
movsd -0x18(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x436d
jnp 0x43b1
movq 0x3c5c(%rip), %rbx      # 0x7fd0
leaq 0xe0d(%rip), %rsi       # 0x5188
movl $0x30, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/robertomaldonado[P]HypercubeTopologyRouting/checker.cpp
// Function: isValidOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int isValidOption(string routing_model){

    if ( routing_model.compare("dim") == 0 || routing_model.compare("all") == 0  ){
        return 1;
    }else{
        cout << "Usage: ./executable Nsize [dim|all]" << endl;
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0xc5a(%rip), %rsi       # 0x5023
callq 0x2090
movl $0x1, %ebx
testl %eax, %eax
je 0x442e
leaq 0xca5(%rip), %rsi       # 0x5083
movq %r14, %rdi
callq 0x2090
testl %eax, %eax
je 0x442e
movq 0x3bdf(%rip), %rbx      # 0x7fd0
leaq 0xd6c(%rip), %rsi       # 0x5164
movl $0x23, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp
// Function: map_to_bin_str[abi:cxx11](std::map<int, std::vector<int, std::allocator<int>>, std::less<int>, std::allocator<std::pair<int const, std::vector<int, std::allocator<int>>>>>&, int)
std::string map_to_bin_str(std::map<int, std::vector<int> > &nodes_map , int n_size){
    int bit_size = log2(n_size); //Stores how many bits long is each node 
    std::string output = "";
    //For each node in the map, print it with the corresponding neighbors
    for(std::map<int,std::vector<int> >::iterator nodes_map_it = nodes_map.begin(); nodes_map_it != nodes_map.end(); ++nodes_map_it){
        //Print the current node in binary
        output += int_to_bin_str( bit_size, nodes_map_it->first);
        output += ": ";
        //Print the neighbors in binary of the current node
        for( std::vector<int>::iterator nei_it = nodes_map_it->second.begin(); nei_it != nodes_map_it->second.end(); ++nei_it){
            output += int_to_bin_str( bit_size, *nei_it);
            if(nei_it+1 != nodes_map_it->second.end() )
                output += " ";
        }
        output += "\n";
    }
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cvtsi2sd %edx, %xmm0
callq 0x2290
movsd %xmm0, -0x58(%rbp)
leaq 0x10(%rbx), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rbx)
leaq 0xc3a(%rip), %rdx       # 0x50a9
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x4b7e
movq 0x18(%r14), %r15
addq $0x8, %r14
movq %r14, -0x60(%rbp)
cmpq %r14, %r15
je 0x4552
cvttsd2si -0x58(%rbp), %r12d
leaq -0x48(%rbp), %r13
movl 0x20(%r15), %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x459c
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x44ca
callq 0x2180
movq %rbx, %rdi
leaq 0xbde(%rip), %rsi       # 0x50b2
callq 0x22b0
movq 0x28(%r15), %r14
cmpq 0x30(%r15), %r14
je 0x452e
movl (%r14), %edx
movq %r13, %rdi
movl %r12d, %esi
callq 0x459c
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x20a0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4513
callq 0x2180
addq $0x4, %r14
cmpq 0x30(%r15), %r14
je 0x452e
movq %rbx, %rdi
leaq 0xbbd(%rip), %rsi       # 0x50e4
callq 0x22b0
jmp 0x44dd
movq %rbx, %rdi
leaq 0xb70(%rip), %rsi       # 0x50a8
callq 0x22b0
movq %r15, %rdi
callq 0x2120
movq %rax, %r15
cmpq -0x60(%rbp), %rax
jne 0x4499
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4583
jmp 0x456c
jmp 0x4583
jmp 0x4583
movq %rax, %r15
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4586
callq 0x2180
jmp 0x4586
movq %rax, %r15
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0x4594
callq 0x2180
movq %r15, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp
// Function: bin_vector_to_int(int, std::vector<bool, std::allocator<bool>>)
int bin_vector_to_int(int bit_size, std::vector<bool >node){
    int translated_node = 0;
    // cout << "Began translation..."<<endl;
    for(int i=0; i < node.size(); i++){
        // cout << pow(2, i) * node[i] << endl;
        translated_node += pow(2, i) * node[i];
    }
    return translated_node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rsi), %rax
subq (%rsi), %rax
movl 0x18(%rsi), %ecx
shlq $0x3, %rax
xorl %r14d, %r14d
addq %rcx, %rax
je 0x4918
movq %rsi, %rbx
xorl %r15d, %r15d
xorl %r14d, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
callq 0x2170
movl %r15d, %ecx
shrl $0x6, %ecx
movq (%rbx), %rax
movq (%rax,%rcx,8), %rcx
btq %r15, %rcx
movsd 0x8d9(%rip), %xmm1      # 0x51c0
jb 0x48ed
xorpd %xmm1, %xmm1
movq 0x10(%rbx), %rcx
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
mulsd %xmm1, %xmm0
addsd %xmm2, %xmm0
cvttsd2si %xmm0, %r14d
incq %r15
movl 0x18(%rbx), %edx
subq %rax, %rcx
leaq (%rdx,%rcx,8), %rax
cmpq %r15, %rax
ja 0x48c1
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp
// Function: int_to_bin_vector(int, int)
std::vector<bool> int_to_bin_vector(int bit_size, int node){

    int tmp_count = 0;
    std::vector<bool> node_bits;
    std::string output_str = "";
    // output_str += std::to_string(node) + "(";
    //Keep adding the bits based on the parity of bits
    while(node != 0){
        if( (node % 2) == 0 ){
            node_bits.push_back(0); node = floor(node/2);
        }else{
            node_bits.push_back(1); node = floor(node/2);
        }
    }
    //Push into the vector of node_bits
    tmp_count = node_bits.size();
    while(  tmp_count < bit_size ){
        node_bits.push_back(0);
        tmp_count++;
    }
    //Add the bits to the output string
    for(int i = node_bits.size()-1; i >= 0; i--)
        output_str += std::to_string(node_bits[i]);

    return node_bits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rdi)
movl %eax, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movl %eax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x747(%rip), %rdx       # 0x50a9
leaq -0x68(%rbp), %rdi
movq %rdx, %rsi
callq 0x4b7e
testl %r15d, %r15d
je 0x49a5
testb $0x1, %r15b
jne 0x4988
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4ab8
sarl %r15d
jmp 0x496e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x4ab8
movl %r15d, %eax
shrl $0x1f, %eax
addl %r15d, %eax
sarl %eax
movl %eax, %r15d
jmp 0x496e
movl 0x10(%rbx), %r13d
subl (%rbx), %r13d
shll $0x3, %r13d
addl 0x18(%rbx), %r13d
cmpl %r14d, %r13d
jge 0x49da
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4ab8
incl %r13d
cmpl %r14d, %r13d
jl 0x49b9
movl 0x10(%rbx), %r13d
subl (%rbx), %r13d
shll $0x3, %r13d
addl 0x18(%rbx), %r13d
movl %r13d, %eax
decl %eax
js 0x4a4a
leaq -0x38(%rbp), %r12
leaq -0x68(%rbp), %r15
decl %r13d
movq (%rbx), %rax
movl %r13d, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %r14
movq %r12, -0x48(%rbp)
movl $0x1, %esi
leaq -0x48(%rbp), %rdi
movl $0x2d, %edx
callq 0x21d0
xorl %edx, %edx
btq %r13, %r14
setb %dl
movq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x4b0c
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x20a0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x4a45
callq 0x2180
testl %r13d, %r13d
jg 0x49e9
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4a5c
callq 0x2180
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x4a9f
jmp 0x4a8a
jmp 0x4a8a
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x4a8d
callq 0x2180
jmp 0x4a8d
movq %rax, %r14
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4a9f
callq 0x2180
movq %rbx, %rdi
callq 0x3c84
movq %r14, %rdi
callq 0x2280
movq %rax, %rdi
callq 0x3b4b
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/khashlpp/./khashl.hpp
// Function: klib::KHashSet<klib::KHashMapBucket<unsigned int, int>, klib::KHashMapHash<klib::KHashMapBucket<unsigned int, int>, aux_hash, unsigned int>, klib::KHashMapEq<klib::KHashMapBucket<unsigned int, int>, std::equal_to<unsigned int>>, unsigned int>::put(klib::KHashMapBucket<unsigned int, int> const&, int*)
khint_t put(const T &key, int *absent_ = 0) {
		khint_t nb, i, last, mask;
		int absent = -1;
		nb = n_buckets();
		if (count >= (nb>>1) + (nb>>2)) { /* rehashing */
			if (resize(nb + khint_t(1)) < 0) {
				if (absent_) *absent_ = -1;
				return nb;
			}
			nb = n_buckets();
		} /* TODO: to implement automatically shrinking; resize() already support shrinking */
		mask = nb - 1;
		i = last = __kh_h2b(Hash()(key), bits);
		while (__kh_used(used, i) && !Eq()(keys[i], key)) {
			i = (i + 1U) & mask;
			if (i == last) break;
		}
		if (!__kh_used(used, i)) { /* not present at all */
			keys[i] = key;
			__kh_set_used(used, i);
			++count, absent = 1;
		} else absent = 0; /* Don't touch keys[i] if present */
		if (absent_) *absent_ = absent;
		return i;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl $0x1, %edx
shll %cl, %edx
movq 0x8(%rdi), %rax
xorl %r15d, %r15d
testq %rax, %rax
cmovnel %edx, %r15d
movq %rsi, %r12
movl %r15d, %edx
shrl %edx
movl %r15d, %esi
shrl $0x2, %esi
addl %edx, %esi
cmpl %esi, 0x4(%rdi)
jb 0x1708
leal 0x1(%r15), %esi
movq %r14, %rdi
callq 0x17a2
testl %eax, %eax
js 0x1787
movq 0x8(%r14), %rax
movl (%r14), %ecx
movl $0x1, %edx
shll %cl, %edx
xorl %r15d, %r15d
testq %rax, %rax
cmovnel %edx, %r15d
movl %r15d, %r8d
movl (%r12), %r9d
imull $0x9e3779b9, %r9d, %r15d # imm = 0x9E3779B9
negb %cl
shrl %cl, %r15d
decl %r8d
movq 0x10(%r14), %rdx
movl %r15d, %ecx
movl %ecx, %esi
shrl $0x5, %esi
movl (%rax,%rsi,4), %r10d
movl $0x1, %edi
shll %cl, %edi
btl %ecx, %r10d
jae 0x1760
movl %ecx, %r10d
cmpl %r9d, (%rdx,%r10,8)
je 0x1760
incl %ecx
andl %r8d, %ecx
cmpl %r15d, %ecx
jne 0x1725
movl %r15d, %esi
shrl $0x5, %esi
movl $0x1, %edi
movl %r15d, %ecx
shll %cl, %edi
jmp 0x1763
movl %ecx, %r15d
xorl %ecx, %ecx
testl %edi, (%rax,%rsi,4)
jne 0x178c
movl %r15d, %eax
movq (%r12), %rcx
movq %rcx, (%rdx,%rax,8)
movq 0x8(%r14), %rax
orl %edi, (%rax,%rsi,4)
incl 0x4(%r14)
movl $0x1, %ecx
jmp 0x178c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x1793
movl %ecx, (%rbx)
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/SQLParser.cpp
// Function: hsql::SQLParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, hsql::SQLParserResult*)
bool SQLParser::parse(const std::string& sql, SQLParserResult* result) {
  yyscan_t scanner;
  YY_BUFFER_STATE state;

  if (hsql_lex_init(&scanner)) {
    // Couldn't initialize the lexer.
    fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
    return false;
  }
  const char* text = sql.c_str();
  state = hsql__scan_string(text, scanner);

  // Parse the tokens.
  // If parsing fails, the result will contain an error object.
  int ret = hsql_parse(result, scanner);
  bool success = (ret == 0);
  result->setIsValid(success);

  hsql__delete_buffer(state, scanner);
  hsql_lex_destroy(scanner);

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
callq 0x12ce0
movl %eax, %ebx
testl %eax, %eax
jne 0x1381e
movq (%r15), %rdi
movq 0x8(%rsp), %rsi
callq 0x12f40
movq %rax, %r15
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x13130
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %r14, %rdi
callq 0x12a10
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x126d0
movq 0x8(%rsp), %rdi
callq 0x12500
testl %ebx, %ebx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1337c
jmp 0x1380f
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/SQLParser.cpp
// Function: hsql::SQLParser::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<short, std::allocator<short>>*)
bool SQLParser::tokenize(const std::string& sql, std::vector<int16_t>* tokens) {
  // Initialize the scanner.
  yyscan_t scanner;
  if (hsql_lex_init(&scanner)) {
    fprintf(stderr, "SQLParser: Error when initializing lexer!\n");
    return false;
  }

  YY_BUFFER_STATE state;
  state = hsql__scan_string(sql.c_str(), scanner);

  YYSTYPE yylval;
  YYLTYPE yylloc;

  // Step through the string until EOF is read.
  // Note: hsql_lex returns int, but we know that its range is within 16 bit.
  int16_t token = hsql_lex(&yylval, &yylloc, scanner);
  while (token != 0) {
    tokens->push_back(token);
    token = hsql_lex(&yylval, &yylloc, scanner);

    if (token == SQL_IDENTIFIER || token == SQL_STRING) {
      free(yylval.sval);
    }
  }

  hsql__delete_buffer(state, scanner);
  hsql_lex_destroy(scanner);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rdi
callq 0x12ce0
movl %eax, %ebx
testl %eax, %eax
jne 0x139b5
movq (%r15), %rdi
movq 0x10(%rsp), %rsi
callq 0x12f40
movq %rax, %r15
xorps %xmm0, %xmm0
leaq 0x18(%rsp), %rsi
movups %xmm0, 0x18(%rsi)
movq $0x0, 0x28(%rsi)
movq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x12910
movw %ax, 0xe(%rsp)
testw %ax, %ax
je 0x13973
leaq 0xe(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq 0x18(%rsp), %rbp
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x1392f
movw %ax, (%rsi)
addq $0x2, %rsi
movq %rsi, 0x8(%r14)
jmp 0x1393a
movq %r14, %rdi
movq %r12, %rdx
callq 0x12980
movq 0x10(%rsp), %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x12910
movw %ax, 0xe(%rsp)
movl %eax, %ecx
andl $0xfffe, %ecx           # imm = 0xFFFE
cmpl $0x102, %ecx            # imm = 0x102
jne 0x1396e
movq 0x48(%rsp), %rdi
callq 0x12ab0
movzwl 0xe(%rsp), %eax
testw %ax, %ax
jne 0x13918
movq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x126d0
movq 0x10(%rsp), %rdi
callq 0x12500
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x139a1
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x12990
testl %ebx, %ebx
sete %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1339e
jmp 0x139a1
jmp 0x139be
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x139d8
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x12990
movq %rbx, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/SQLParserResult.cpp
// Function: hsql::SQLParserResult::reset()
void SQLParserResult::reset() {
  for (SQLStatement* statement : statements_) {
    delete statement;
  }
  statements_.clear();

  isValid_ = false;

  free(errorMsg_);
  errorMsg_ = nullptr;
  errorLine_ = -1;
  errorColumn_ = -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0x13d8a
movq (%r14), %rdi
testq %rdi, %rdi
je 0x13d73
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x13d65
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x13d8a
movq %rax, 0x10(%rbx)
movb $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x12ab0
movq $0x0, 0x28(%rbx)
movq $-0x1, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::operator<<(std::ostream&, hsql::ConstraintType)
std::ostream& operator<<(std::ostream& os, const ConstraintType constraint_type) {
  switch (constraint_type) {
    case ConstraintType::Null:
      os << "NULL";
      break;
    case ConstraintType::NotNull:
      os << "NOT NULL";
      break;
    case ConstraintType::ForeignKey:
      os << "FOREIGN KEY";
      break;
    case ConstraintType::PrimaryKey:
      os << "PRIMARY KEY";
      break;
    case ConstraintType::Unique:
      os << "UNIQUE";
      break;
  }
  return os;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x4, %esi
ja 0x1ea36
movl %esi, %eax
leaq 0x146ca(%rip), %rcx     # 0x330b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x14753(%rip), %rsi     # 0x33149
jmp 0x1ea1b
leaq 0x8ab3(%rip), %rsi      # 0x274b2
movl $0x6, %edx
jmp 0x1ea2e
leaq 0x14d38(%rip), %rsi     # 0x33745
movl $0x4, %edx
jmp 0x1ea2e
leaq 0x1473a(%rip), %rsi     # 0x33155
movl $0xb, %edx
jmp 0x1ea2e
leaq 0x14717(%rip), %rsi     # 0x33140
movl $0x8, %edx
movq %rbx, %rdi
callq 0x12a70
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::ReferencesSpecification::~ReferencesSpecification()
ReferencesSpecification::~ReferencesSpecification() {
  free(schema);
  free(table);
  if (columns) {
    for (auto* column : *columns) {
      free(column);
    }
    delete columns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x12ab0
movq 0x8(%r14), %rdi
callq 0x12ab0
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x1eb50
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x1eb3a
movq (%r15), %rdi
callq 0x12ab0
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1eb1d
movq 0x10(%r14), %rbx
testq %rbx, %rbx
je 0x1eb5c
movq (%rbx), %r15
testq %r15, %r15
je 0x1eb5e
movq 0x10(%rbx), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x1eb5e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12990
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::ColumnDefinition::~ColumnDefinition()
ColumnDefinition::~ColumnDefinition() {
  free(name);
  delete column_constraints;
  if (references) {
    for (auto* ref : *references) {
      delete ref;
    }
  }
  delete references;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1c31a(%rip), %rax     # 0x3afa0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
callq 0x12ab0
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1eca7
movq %r14, %rdi
callq 0x12890
movl $0x38, %esi
movq %r14, %rdi
callq 0x12990
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x1ed11
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x1ecfb
movq (%r15), %r14
testq %r14, %r14
je 0x1ecd9
movq %r14, %rdi
callq 0x131a0
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1ecc9
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x1ed11
movq (%r14), %r15
testq %r15, %r15
je 0x1ed14
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x1ed14
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12990
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::ColumnDefinition::trySetNullableExplicit()
bool ColumnDefinition::trySetNullableExplicit() {
  if (column_constraints->count(ConstraintType::NotNull) || column_constraints->count(ConstraintType::PrimaryKey)) {
    if (column_constraints->count(ConstraintType::Null)) {
      return false;
    }
    nullable = false;
  }

  return true;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xc(%rsp), %rsi
movl $0x1, (%rsi)
callq 0x12dc0
testq %rax, %rax
jne 0x1ed7e
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x3, (%rsi)
callq 0x12dc0
testq %rax, %rax
je 0x1ed9f
movq 0x8(%rbx), %rdi
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
callq 0x12dc0
testq %rax, %rax
je 0x1ed9b
xorl %eax, %eax
jmp 0x1eda1
movb $0x0, 0x38(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::CreateStatement::~CreateStatement()
CreateStatement::~CreateStatement() {
  free(filePath);
  free(schema);
  free(tableName);
  free(indexName);
  delete select;

  if (columns) {
    for (auto* def : *columns) {
      delete def;
    }
    delete columns;
  }

  if (tableConstraints) {
    for (auto* def : *tableConstraints) {
      delete def;
    }
    delete tableConstraints;
  }

  if (indexColumns) {
    for (char* column : *indexColumns) {
      free(column);
    }
    delete indexColumns;
  }

  if (viewColumns) {
    for (char* column : *viewColumns) {
      free(column);
    }
    delete viewColumns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1c184(%rip), %rax     # 0x3af90
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
callq 0x12ab0
movq 0x30(%rbx), %rdi
callq 0x12ab0
movq 0x38(%rbx), %rdi
callq 0x12ab0
movq 0x40(%rbx), %rdi
callq 0x12ab0
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x1ee46
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x1eea4
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x1ee7e
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1ee69
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1ee5b
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x1ee94
movq (%r14), %r15
testq %r15, %r15
je 0x1ee97
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x1ee97
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0x1ef02
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x1eedc
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1eec7
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1eeb9
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0x1eef2
movq (%r14), %r15
testq %r15, %r15
je 0x1eef5
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x1eef5
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x1ef5a
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x1ef34
movq (%r15), %rdi
callq 0x12ab0
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1ef17
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x1ef4a
movq (%r14), %r15
testq %r15, %r15
je 0x1ef4d
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x1ef4d
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x1efb2
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x1ef8c
movq (%r15), %rdi
callq 0x12ab0
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1ef6f
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x1efa2
movq (%r14), %r15
testq %r15, %r15
je 0x1efa5
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x1efa5
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12c00
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/CreateStatement.cpp
// Function: hsql::CreateStatement::setColumnDefsAndConstraints(std::vector<hsql::TableElement*, std::allocator<hsql::TableElement*>>*)
void CreateStatement::setColumnDefsAndConstraints(std::vector<TableElement*>* tableElements) {
  columns = new std::vector<ColumnDefinition*>();
  tableConstraints = new std::vector<TableConstraint*>();

  for (auto tableElem : *tableElements) {
    if (auto* colDef = dynamic_cast<ColumnDefinition*>(tableElem)) {
      columns->emplace_back(colDef);
    } else if (auto* tableConstraint = dynamic_cast<TableConstraint*>(tableElem)) {
      tableConstraints->emplace_back(tableConstraint);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %edi
callq 0x12970
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movq %rax, 0x50(%rbx)
movl $0x18, %edi
callq 0x12970
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x10(%rax)
movq %rax, 0x58(%rbx)
movq (%r14), %r12
movq 0x8(%r14), %rbp
cmpq %rbp, %r12
je 0x1f0a7
movq 0x1bf40(%rip), %r14     # 0x3af78
movq 0x1bf01(%rip), %r15     # 0x3af40
movq (%r12), %r13
testq %r13, %r13
je 0x1f09e
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x12a60
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1f072
movq 0x50(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x120e0
jmp 0x1f09e
movq %r13, %rdi
movq %r14, %rsi
movq 0x1be11(%rip), %rdx     # 0x3ae90
xorl %ecx, %ecx
callq 0x12a60
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1f09e
movq 0x58(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x12120
addq $0x8, %r12
cmpq %rbp, %r12
jne 0x1f03f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::WindowDescription::~WindowDescription()
WindowDescription::~WindowDescription() {
  if (partitionList) {
    for (Expr* e : *partitionList) {
      delete e;
    }
    delete partitionList;
  }

  if (orderList) {
    for (OrderDescription* orderDescription : *orderList) {
      delete orderDescription;
    }
    delete orderList;
  }

  delete frameDescription;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b9e2(%rip), %rax     # 0x3aee8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x1f56b
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x1f545
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1f530
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1f522
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1f55b
movq (%r14), %r15
testq %r15, %r15
je 0x1f55e
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x1f55e
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x1f5c9
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x1f5a3
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1f58e
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1f580
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x1f5b9
movq (%r14), %r15
testq %r15, %r15
je 0x1f5bc
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x1f5bc
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1f5e3
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::~Expr()
Expr::~Expr() {
  delete expr;
  delete expr2;
  delete select;
  delete windowDescription;

  free(name);
  free(table);
  free(alias);

  if (exprList) {
    for (Expr* e : *exprList) {
      delete e;
    }
    delete exprList;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1b87e(%rip), %rax     # 0x3af08
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1f6a0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1f6af
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1f6be
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x1f6d0
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rdi
callq 0x12ab0
movq 0x38(%rbx), %rdi
callq 0x12ab0
movq 0x40(%rbx), %rdi
callq 0x12ab0
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x1f739
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x1f723
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1f70e
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1f700
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x1f745
movq (%r14), %r15
testq %r15, %r15
je 0x1f748
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x1f748
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12990
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeBetween(hsql::Expr*, hsql::Expr*, hsql::Expr*)
Expr* Expr::makeBetween(Expr* expr, Expr* left, Expr* right) {
  Expr* e = new Expr(kExprOperator);
  e->expr = expr;
  e->opType = kOpBetween;
  e->exprList = new std::vector<Expr*>();
  e->exprList->push_back(left);
  e->exprList->push_back(right);
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movq %r15, 0x10(%rbx)
movl $0x1, 0x8c(%rbx)
movl $0x18, %edi
callq 0x12970
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x20(%rbx)
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x12080
movq 0x20(%rbx), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x1f8ed
movq %r14, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x1f8f5
movq %rsp, %rdx
callq 0x12080
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeCaseList(hsql::Expr*)
Expr* Expr::makeCaseList(Expr* caseListElement) {
  Expr* e = new Expr(kExprOperator);
  // Case list expressions are temporary and will be integrated into the case
  // expressions exprList - thus assign operator type kOpNone
  e->opType = kOpNone;
  e->exprList = new std::vector<Expr*>();
  e->exprList->push_back(caseListElement);
  return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movl $0xa0, %edi
callq 0x12970
movq %rax, %rbx
movq %rax, %rdi
movl $0xa, %esi
callq 0x13330
movl $0x0, 0x8c(%rbx)
movl $0x18, %edi
callq 0x12970
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x20(%rbx)
movq %rsp, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x12080
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x12990
movq %r14, %rdi
callq 0x13110
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::substr(char const*, int, int)
char* substr(const char* source, int from, int to) {
  int len = to - from;
  char* copy = (char*)malloc(len + 1);
  ;
  strncpy(copy, source + from, len);
  copy[len] = '\0';
  return copy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
subl %esi, %ebx
leal 0x1(%rbx), %eax
movslq %eax, %rdi
callq 0x12bf0
movq %rax, %r15
movslq %ebp, %rsi
addq %r14, %rsi
movslq %ebx, %rbx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x12420
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/SQLStatement.cpp
// Function: hsql::SQLStatement::~SQLStatement()
SQLStatement::~SQLStatement() {
  if (hints) {
    for (Expr* hint : *hints) {
      delete hint;
    }
  }
  delete hints;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x1ad4f(%rip), %rax     # 0x3af60
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rbx
testq %rbx, %rbx
je 0x20269
movq (%rbx), %r14
movq 0x8(%rbx), %r12
cmpq %r12, %r14
je 0x20253
movq %rdi, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2023e
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
cmpq %r12, %r14
jne 0x20230
movq 0x10(%r15), %rbx
testq %rbx, %rbx
je 0x20269
movq (%rbx), %r14
testq %r14, %r14
je 0x2026b
movq 0x10(%rbx), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x12990
jmp 0x2026b
xorl %ebx, %ebx
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::operator<<(std::ostream&, hsql::ColumnType const&)
std::ostream& operator<<(std::ostream& stream, const ColumnType& column_type) {
  switch (column_type.data_type) {
    case DataType::UNKNOWN:
      stream << "UNKNOWN";
      break;
    case DataType::INT:
      stream << "INT";
      break;
    case DataType::BIGINT:
      stream << "BIGINT";
      break;
    case DataType::LONG:
      stream << "LONG";
      break;
    case DataType::FLOAT:
      stream << "FLOAT";
      break;
    case DataType::DOUBLE:
      stream << "DOUBLE";
      break;
    case DataType::REAL:
      stream << "REAL";
      break;
    case DataType::CHAR:
      stream << "CHAR(" << column_type.length << ")";
      break;
    case DataType::VARCHAR:
      stream << "VARCHAR(" << column_type.length << ")";
      break;
    case DataType::DECIMAL:
      stream << "DECIMAL";
      break;
    case DataType::TEXT:
      stream << "TEXT";
      break;
    case DataType::DATETIME:
      stream << "DATETIME";
      break;
    case DataType::DATE:
      stream << "DATE";
      break;
    case DataType::TIME:
      stream << "TIME";
      break;
    case DataType::SMALLINT:
      stream << "SMALLINT";
      break;
    case DataType::BOOLEAN:
      stream << "BOOLEAN";
      break;
  }
  return stream;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
cmpq $0xf, %rax
ja 0x20425
movq %rsi, %r14
leaq 0x12eb2(%rip), %rcx     # 0x331ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x130b4(%rip), %rsi     # 0x333fe
jmp 0x2040a
leaq 0x6fdf(%rip), %rsi      # 0x27335
jmp 0x20418
leaq 0x6e6b(%rip), %rsi      # 0x271cd
jmp 0x20418
leaq 0x13278(%rip), %rsi     # 0x335e6
jmp 0x20418
leaq 0x6e60(%rip), %rsi      # 0x271da
jmp 0x203f3
leaq 0x6e63(%rip), %rsi      # 0x271e6
movl $0x3, %edx
jmp 0x2041d
leaq 0x70ac(%rip), %rsi      # 0x27440
jmp 0x2040a
leaq 0x13069(%rip), %rsi     # 0x33406
movl $0x8, %edx
jmp 0x203b0
leaq 0x1305e(%rip), %rsi     # 0x33409
movl $0x5, %edx
movq %rbx, %rdi
callq 0x12a70
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x128b0
leaq 0x12ce0(%rip), %rsi     # 0x330ab
movl $0x1, %edx
movq %rax, %rdi
jmp 0x20420
leaq 0x6e4a(%rip), %rsi      # 0x27226
jmp 0x203e5
leaq 0x6dfe(%rip), %rsi      # 0x271e3
movl $0x6, %edx
jmp 0x2041d
leaq 0x6f3e(%rip), %rsi      # 0x27331
movl $0x8, %edx
jmp 0x2041d
leaq 0x6f89(%rip), %rsi      # 0x2738a
jmp 0x20418
leaq 0x6dc8(%rip), %rsi      # 0x271d2
movl $0x7, %edx
jmp 0x2041d
leaq 0x6f59(%rip), %rsi      # 0x27371
movl $0x4, %edx
movq %rbx, %rdi
callq 0x12a70
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x6e92(%rip), %rsi      # 0x272c9
movl $0x5, %edx
jmp 0x2041d
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::ExecuteStatement::~ExecuteStatement()
ExecuteStatement::~ExecuteStatement() {
  free(name);

  if (parameters) {
    for (Expr* param : *parameters) {
      delete param;
    }
    delete parameters;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1a830(%rip), %rax     # 0x3af10
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x12ab0
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x2074e
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x20728
movq (%r15), %rdi
testq %rdi, %rdi
je 0x20713
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0x20705
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x2073e
movq (%r14), %r15
testq %r15, %r15
je 0x20741
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x20741
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12c00
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::ExportStatement::~ExportStatement()
ExportStatement::~ExportStatement() {
  free(filePath);
  free(schema);
  free(tableName);
  delete select;
  free(encoding);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1a801(%rip), %rax     # 0x3afc8
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x12ab0
movq 0x28(%rbx), %rdi
callq 0x12ab0
movq 0x30(%rbx), %rdi
callq 0x12ab0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x207f8
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
callq 0x12ab0
movq %rbx, %rdi
popq %rbx
jmp 0x12c00
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::ImportStatement::~ImportStatement()
ImportStatement::~ImportStatement() {
  free(filePath);
  free(schema);
  free(tableName);
  delete whereClause;
  free(encoding);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x1a737(%rip), %rax     # 0x3afc0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x12ab0
movq 0x28(%rbx), %rdi
callq 0x12ab0
movq 0x30(%rbx), %rdi
callq 0x12ab0
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x208ba
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x40(%rbx), %rdi
callq 0x12ab0
movq %rbx, %rdi
popq %rbx
jmp 0x12c00
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::InsertStatement::~InsertStatement()
InsertStatement::~InsertStatement() {
  free(schema);
  free(tableName);
  delete select;

  if (columns) {
    for (char* column : *columns) {
      free(column);
    }
    delete columns;
  }

  if (values) {
    for (Expr* expr : *values) {
      delete expr;
    }
    delete values;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1a620(%rip), %rax     # 0x3af58
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
callq 0x12ab0
movq 0x28(%rbx), %rdi
callq 0x12ab0
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x20960
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x209b8
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x20992
movq (%r15), %rdi
callq 0x12ab0
addq $0x8, %r15
cmpq %r12, %r15
jne 0x20975
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x209a8
movq (%r14), %r15
testq %r15, %r15
je 0x209ab
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x209ab
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x20a16
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x209f0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x209db
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0x209cd
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x20a06
movq (%r14), %r15
testq %r15, %r15
je 0x20a09
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x20a09
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
callq 0x12990
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12c00
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::GroupByDescription::~GroupByDescription()
GroupByDescription::~GroupByDescription() {
  delete having;

  if (columns) {
    for (Expr* expr : *columns) {
      delete expr;
    }
    delete columns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1a3b2(%rip), %rax     # 0x3af48
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x20bac
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x20bfa
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x20be4
movq (%r15), %rdi
testq %rdi, %rdi
je 0x20bcf
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0x20bc1
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x20c06
movq (%r14), %r15
testq %r15, %r15
je 0x20c09
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x20c09
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::UpdateStatement::~UpdateStatement()
UpdateStatement::~UpdateStatement() {
  delete table;
  delete where;

  if (updates) {
    for (UpdateClause* update : *updates) {
      free(update->column);
      delete update->value;
      delete update;
    }
    delete updates;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x19fba(%rip), %rax     # 0x3af70
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x20fcc
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x20fdb
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %r15
testq %r15, %r15
je 0x21052
movq (%r15), %r14
movq 0x8(%r15), %r12
cmpq %r12, %r14
je 0x2102c
movq (%r14), %r15
movq (%r15), %rdi
callq 0x12ab0
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x2100a
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %esi
movq %r15, %rdi
callq 0x12990
addq $0x8, %r14
cmpq %r12, %r14
jne 0x20ff0
movq 0x28(%rbx), %r15
testq %r15, %r15
je 0x21042
movq (%r15), %r14
testq %r14, %r14
je 0x21045
movq 0x10(%r15), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x12990
jmp 0x21045
xorl %r15d, %r15d
movl $0x18, %esi
movq %r15, %rdi
callq 0x12990
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12c00
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::Alias::~Alias()
Alias::~Alias() {
  free(name);
  if (columns) {
    for (char* column : *columns) {
      free(column);
    }
    delete columns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x12ab0
movq 0x8(%r15), %rbx
testq %rbx, %rbx
je 0x210e1
movq (%rbx), %r14
movq 0x8(%rbx), %r12
cmpq %r12, %r14
je 0x210cb
movq (%r14), %rdi
callq 0x12ab0
addq $0x8, %r14
cmpq %r12, %r14
jne 0x210ae
movq 0x8(%r15), %rbx
testq %rbx, %rbx
je 0x210ed
movq (%rbx), %r14
testq %r14, %r14
je 0x210ef
movq 0x10(%rbx), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x12990
jmp 0x210ef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12990
nop
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::TableRef::~TableRef()
TableRef::~TableRef() {
  free(schema);
  free(name);

  delete select;
  delete join;
  delete alias;

  if (list) {
    for (TableRef* table : *list) {
      delete table;
    }
    delete list;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x19de4(%rip), %rax     # 0x3af20
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
callq 0x12ab0
movq 0x18(%rbx), %rdi
callq 0x12ab0
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x21164
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x21173
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x21184
movq %r14, %rdi
callq 0x12c80
movl $0x10, %esi
movq %r14, %rdi
callq 0x12990
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x211df
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x211c9
movq (%r15), %rdi
testq %rdi, %rdi
je 0x211b4
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0x211a6
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x211eb
movq (%r14), %r15
testq %r15, %r15
je 0x211ee
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x211ee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12990
// File: /workspace/github_cpp_makefile_star2_O3/hyrise[P]sql-parser/src/sql/statements.cpp
// Function: hsql::JoinDefinition::~JoinDefinition()
JoinDefinition::~JoinDefinition() {
  delete left;
  delete right;
  delete condition;

  if (namedColumns) {
    for (auto* column : *namedColumns) {
      free(column);
    }
    delete namedColumns;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x19d40(%rip), %rax     # 0x3afb0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x21286
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x21295
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x212a4
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x212ec
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x212d6
movq (%r15), %rdi
callq 0x12ab0
addq $0x8, %r15
cmpq %r12, %r15
jne 0x212b9
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x212f8
movq (%r14), %r15
testq %r15, %r15
je 0x212fb
movq 0x10(%r14), %rsi
subq %r15, %rsi
movq %r15, %rdi
callq 0x12990
jmp 0x212fb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
movl $0x18, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x12990
nop