LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/robertomaldonado[P]HypercubeTopologyRouting/links.cpp
// Function: print_single_route(int, std::vector<int, std::allocator<int>>&)
void print_single_route(int bits_for_node, vector<int> &ref_to_route){
    for(int i = 0 ; i < ref_to_route.size() ; i++){
        printf( int_to_bin_str(bits_for_node, ref_to_route[i]).c_str() );
        if( i+1 != ref_to_route.size() )
            printf("->");
        else
            printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq -0x48(%rbp), %r15
leaq 0x23cf(%rip), %r13      # 0x50b5
xorl %r12d, %r12d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r12, %rcx
jbe 0x2d47
movl (%rax,%r12,4), %edx
movq %r15, %rdi
movl %r14d, %esi
callq 0x3fbc
movq -0x48(%rbp), %rdi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
callq 0x20c0
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %rax, %r12
jne 0x2d3b
pushq $0xa
popq %rdi
callq 0x21c0
jmp 0x2ce9
movq %r13, %rdi
xorl %eax, %eax
callq 0x2040
jmp 0x2ce9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3085
imull %edi, %eax
decl %edi
jmp 0x307a
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
movl %edi, %ebx
callq 0x3119
callq 0x2060
movsd %xmm0, -0x10(%rbp)
movl %ebx, %edi
callq 0x3119
callq 0x2230
movsd -0x10(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x3e21
jp 0x3e21
pushq $0x1
popq %rax
jmp 0x3e3e
movq 0x41a0(%rip), %rdi      # 0x7fc8
leaq 0x132f(%rip), %rsi      # 0x515e
callq 0x2160
movq %rax, %rdi
callq 0x20d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x11cd(%rip), %rsi      # 0x5023
callq 0x2080
pushq $0x1
popq %rbx
testl %eax, %eax
je 0x3e92
leaq 0x121a(%rip), %rsi      # 0x5083
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x3e92
movq 0x414c(%rip), %rdi      # 0x7fc8
leaq 0x12b7(%rip), %rsi      # 0x513a
callq 0x2160
movq %rax, %rdi
callq 0x20d0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, %edi
callq 0x3119
cvttsd2si %xmm0, %r15d
leaq 0x11e3(%rip), %rsi      # 0x50a9
leaq -0x50(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rdx
callq 0x20a0
movq 0x18(%r14), %r13
addq $0x8, %r14
movq %r14, -0x30(%rbp)
cmpq -0x30(%rbp), %r13
je 0x3f81
movl 0x20(%r13), %edx
movq %r12, %rdi
movl %r15d, %esi
callq 0x3fbc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x20c0
movq %rbx, %rdi
leaq 0x119b(%rip), %rsi      # 0x50b2
callq 0x2270
movq 0x28(%r13), %r14
cmpq 0x30(%r13), %r14
je 0x3f62
movl (%r14), %edx
movq %r12, %rdi
movl %r15d, %esi
callq 0x3fbc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2280
movq %r12, %rdi
callq 0x20c0
addq $0x4, %r14
cmpq 0x30(%r13), %r14
je 0x3f20
movq %rbx, %rdi
leaq 0x1189(%rip), %rsi      # 0x50e4
callq 0x2270
jmp 0x3f20
movq %rbx, %rdi
leaq 0x113c(%rip), %rsi      # 0x50a8
callq 0x2270
movq %r13, %rdi
callq 0x2110
movq %rax, %r13
jmp 0x3ee1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f9b
jmp 0x3fa0
jmp 0x3f9b
jmp 0x3f9b
movq %rax, %r14
jmp 0x3fac
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/robertomaldonado[P]HypercubeTopologyRouting/transformations.cpp
// Function: int_to_bin_str[abi:cxx11](int, int)
std::string int_to_bin_str(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]);
    output_str += ")";

    return output_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
andq $0x0, -0x58(%rbp)
andl $0x0, -0x50(%rbp)
movl %edx, %r15d
andq $0x0, -0x48(%rbp)
movl %esi, %r14d
andl $0x0, -0x40(%rbp)
movq %rdi, %r13
andq $0x0, -0x38(%rbp)
leaq 0x10b5(%rip), %rsi      # 0x50a9
leaq -0x78(%rbp), %rdx
callq 0x20a0
leaq -0x98(%rbp), %rdi
movl %r15d, %esi
callq 0x4375
leaq 0x1185(%rip), %rdx      # 0x5198
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
movq %r13, -0x30(%rbp)
callq 0x434c
leaq -0x78(%rbp), %rsi
movq %r13, %rdi
callq 0x2280
leaq -0x78(%rbp), %rdi
callq 0x20c0
leaq -0x98(%rbp), %rdi
callq 0x20c0
leaq -0x58(%rbp), %r12
pushq $0x1
popq %r13
pushq $0x2
popq %rbx
testl %r15d, %r15d
je 0x4083
testb $0x1, %r15b
jne 0x406d
movq %r12, %rdi
xorl %esi, %esi
callq 0x43d6
sarl %r15d
jmp 0x4053
movq %r12, %rdi
movl %r13d, %esi
callq 0x43d6
movl %r15d, %eax
cltd
idivl %ebx
movl %eax, %r15d
jmp 0x4053
leaq -0x58(%rbp), %r15
movl 0x10(%r15), %ebx
subl (%r15), %ebx
shll $0x3, %ebx
addl 0x18(%r15), %ebx
movq -0x30(%rbp), %r13
cmpl %r14d, %ebx
jge 0x40ac
movq %r15, %rdi
xorl %esi, %esi
callq 0x43d6
incl %ebx
jmp 0x4099
leaq -0x58(%rbp), %r14
movl (%r14), %r12d
movl 0x10(%r14), %eax
shll $0x3, %eax
addl 0x18(%r14), %eax
shll $0x3, %r12d
notl %r12d
addl %eax, %r12d
leaq -0x78(%rbp), %r15
testl %r12d, %r12d
js 0x4105
movl %r12d, %esi
movq %r14, %rdi
callq 0x315e
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
movq %r15, %rdi
callq 0x4375
movq %r13, %rdi
movq %r15, %rsi
callq 0x2280
movq %r15, %rdi
callq 0x20c0
decl %r12d
jmp 0x40cc
leaq 0x108e(%rip), %rsi      # 0x519a
movq %r13, %rdi
callq 0x2270
leaq -0x58(%rbp), %rdi
callq 0x31fe
movq %r13, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4170
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x20c0
jmp 0x4142
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x20c0
jmp 0x416a
jmp 0x4170
movq %rax, %r14
jmp 0x417b
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x20c0
jmp 0x4173
jmp 0x4170
movq %rax, %r14
movq -0x30(%rbp), %r13
jmp 0x4173
movq %rax, %r14
movq %r13, %rdi
callq 0x20c0
leaq -0x58(%rbp), %rdi
callq 0x31fe
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movl 0x18(%rbx), %ecx
subq (%rbx), %rax
leaq (%rcx,%rax,8), %rax
cmpq %r14, %rax
jbe 0x41f9
cvtsi2sd %r14d, %xmm0
callq 0x2140
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x315e
movsd 0xfbc(%rip), %xmm0      # 0x5190
testq %rdx, (%rax)
jne 0x41dd
xorpd %xmm0, %xmm0
cvtsi2sd %r15d, %xmm1
movsd -0x20(%rbp), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm1, %xmm2
cvttsd2si %xmm2, %r15d
incq %r14
jmp 0x419f
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
andq $0x0, (%rdi)
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movl %edx, %r15d
andl $0x0, 0x18(%rdi)
movl %esi, %r14d
andq $0x0, 0x20(%rdi)
leaq 0xe6b(%rip), %rsi       # 0x50a9
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x20a0
pushq $0x1
popq %r12
pushq $0x2
popq %r13
testl %r15d, %r15d
je 0x4284
testb $0x1, %r15b
jne 0x426d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x43d6
sarl %r15d
jmp 0x4253
movq %rbx, %rdi
movl %r12d, %esi
callq 0x43d6
movl %r15d, %eax
cltd
idivl %r13d
movl %eax, %r15d
jmp 0x4253
movl 0x10(%rbx), %r15d
subl (%rbx), %r15d
shll $0x3, %r15d
addl 0x18(%rbx), %r15d
cmpl %r14d, %r15d
jge 0x42a7
movq %rbx, %rdi
xorl %esi, %esi
callq 0x43d6
incl %r15d
jmp 0x4293
movl (%rbx), %r12d
movl 0x10(%rbx), %eax
shll $0x3, %eax
addl 0x18(%rbx), %eax
shll $0x3, %r12d
notl %r12d
addl %eax, %r12d
leaq -0x68(%rbp), %r14
leaq -0x48(%rbp), %r15
testl %r12d, %r12d
js 0x42fe
movl %r12d, %esi
movq %rbx, %rdi
callq 0x315e
xorl %esi, %esi
testq %rdx, (%rax)
setne %sil
movq %r14, %rdi
callq 0x4375
movq %r15, %rdi
movq %r14, %rsi
callq 0x2280
movq %r14, %rdi
callq 0x20c0
decl %r12d
jmp 0x42c5
leaq -0x48(%rbp), %rdi
callq 0x20c0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x433c
movq %rax, %r14
leaq -0x68(%rbp), %rdi
callq 0x20c0
jmp 0x4333
jmp 0x4330
jmp 0x4330
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x20c0
movq %rbx, %rdi
callq 0x31fe
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/khashlpp/./../common.c
// Function: traverse_rng(unsigned int, unsigned int)
uint64_t traverse_rng(uint32_t n, uint32_t x0)
{
	uint64_t sum = 0;
	uint32_t i, x;
	for (i = 0, x = x0; i < n; ++i) {
		x = hash32(x);
		sum += get_key(n, x);
	}
	return sum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebp
xorl %ebx, %ebx
movl %edi, %r15d
subl $0x1, %r15d
jb 0x11fe
movl %r14d, %edi
callq 0x120c
movl %eax, %r14d
movl %ebp, %edi
movl %eax, %esi
callq 0x1237
movl %eax, %eax
addq %rax, %rbx
jmp 0x11dd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/khashlpp/./../common.c
// Function: hash32(unsigned int)
static inline uint32_t hash32(uint32_t key)
{
    key += ~(key << 15);
    key ^=  (key >> 10);
    key +=  (key << 3);
    key ^=  (key >> 6);
    key += ~(key << 11);
    key ^=  (key >> 16);
    return key;
}

// Assembly:
movl %edi, %eax
shll $0xf, %eax
notl %eax
addl %edi, %eax
movl %eax, %ecx
shrl $0xa, %ecx
xorl %eax, %ecx
leal (%rcx,%rcx,8), %eax
movl %eax, %ecx
shrl $0x6, %ecx
xorl %eax, %ecx
movl %ecx, %edx
shll $0xb, %edx
notl %edx
addl %ecx, %edx
movl %edx, %eax
shrl $0x10, %eax
xorl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/attractivechaos[P]udb2/khashlpp/test.cpp
// Function: test_int(unsigned int, unsigned int)
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	klib::KHashMap<uint32_t, int, aux_hash> h;
	for (i = 0, x = x0; i < n; ++i) {
		uint32_t k;
		int absent;
		x = hash32(x);
		k = h.put(get_key(n, x), &absent);
#ifndef UDB2_TEST_DEL
		if (absent) h.value(k) = 0;
		z += ++h.value(k);
#else
		if (absent) ++z;
		else h.del(k);
#endif
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u; capacity: %d\n", h.size(), z, h.n_buckets());
	return h.size();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r15d
movl %edi, %r14d
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %ebx, %ebx
leaq 0x8(%rsp), %r12
leaq 0xc(%rsp), %r13
movl %edi, %ebp
subl $0x1, %ebp
jb 0x1501
movl %r15d, %edi
callq 0x120c
movl %eax, %r15d
movl %r14d, %edi
movl %eax, %esi
callq 0x1237
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x156c
cmpl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rcx
movl %eax, %eax
je 0x14f3
andl $0x0, 0x4(%rcx,%rax,8)
pushq $0x1
popq %rdx
jmp 0x14f9
movl 0x4(%rcx,%rax,8), %edx
incl %edx
movl %edx, 0x4(%rcx,%rax,8)
addl %edx, %ebx
jmp 0x14ad
movq 0x2ad8(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
leaq 0x10(%rsp), %r14
movl 0x4(%r14), %edx
movb (%r14), %cl
pushq $0x1
popq %r8
shll %cl, %r8d
xorl %eax, %eax
cmpq $0x0, 0x8(%r14)
cmovel %eax, %r8d
leaq 0xb45(%rip), %rsi       # 0x2075
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1090
movl 0x4(%r14), %ebx
movq %r14, %rdi
callq 0x1580
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1580
movq %rbx, %rdi
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movl (%rdi), %ecx
pushq $0x1
popq %rbp
movl %ebp, %edx
shll %cl, %edx
movq 0x8(%rdi), %rax
xorl %r14d, %r14d
testq %rax, %rax
cmovnel %edx, %r14d
movq %rsi, %r12
movl %r14d, %edx
shrl %edx
movl %r14d, %esi
shrl $0x2, %esi
addl %edx, %esi
cmpl %esi, 0x4(%rdi)
jb 0x15fb
leal 0x1(%r14), %esi
movq %r15, %rdi
callq 0x168c
testl %eax, %eax
js 0x1682
movq 0x8(%r15), %rax
movl (%r15), %ecx
movl %ebp, %edx
shll %cl, %edx
xorl %r14d, %r14d
testq %rax, %rax
cmovnel %edx, %r14d
movl %r14d, %r8d
movl (%r12), %r9d
imull $0x9e3779b9, %r9d, %r14d # imm = 0x9E3779B9
negb %cl
shrl %cl, %r14d
decl %r8d
movq 0x10(%r15), %rdx
movl %r14d, %ecx
movl %ecx, %esi
shrl $0x5, %esi
movl (%rax,%rsi,4), %r10d
movl %ebp, %edi
shll %cl, %edi
btl %ecx, %r10d
jae 0x164d
movl %ecx, %r10d
cmpl %r9d, (%rdx,%r10,8)
je 0x164d
incl %ecx
andl %r8d, %ecx
cmpl %r14d, %ecx
jne 0x1618
movl %r14d, %esi
shrl $0x5, %esi
movl %ebp, %edi
movl %r14d, %ecx
shll %cl, %edi
jmp 0x1650
movl %ecx, %r14d
xorl %ecx, %ecx
testl %edi, (%rax,%rsi,4)
jne 0x166f
movl %r14d, %eax
movq (%r12), %rcx
movq %rcx, (%rdx,%rax,8)
movq 0x8(%r15), %rax
orl %edi, (%rax,%rsi,4)
incl 0x4(%r15)
movl %ebp, %ecx
testq %rbx, %rbx
je 0x1676
movl %ecx, (%rbx)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testq %rbx, %rbx
je 0x1676
pushq $-0x1
popq %rcx
jmp 0x1674
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17270
movl %eax, %ebx
testl %eax, %eax
jne 0x17c0a
movq (%r15), %rdi
movq 0x8(%rsp), %rsi
callq 0x17570
movq %rax, %r15
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x177c0
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %r14, %rdi
callq 0x16e20
movq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x169a0
movq 0x8(%rsp), %rdi
callq 0x16720
testl %ebx, %ebx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x2731f(%rip), %rax     # 0x3ef30
movq (%rax), %rcx
leaq 0xf420(%rip), %rdi      # 0x2703b
pushq $0x2a
popq %rsi
pushq $0x1
popq %rdx
callq 0x179f0
jmp 0x17bfb
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rdi
callq 0x17270
movl %eax, %ebx
testl %eax, %eax
jne 0x17d6f
movq (%r14), %rdi
movq 0x10(%rsp), %rsi
callq 0x17570
movq %rax, %r12
leaq 0x30(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x16cc0
leaq 0xe(%rsp), %r13
movw %ax, (%r13)
leaq 0x48(%rsp), %rbp
leaq 0x18(%rsp), %r14
testw %ax, %ax
je 0x17d3a
movq %r15, %rdi
movq %r13, %rsi
callq 0x162a0
movq 0x10(%rsp), %rdx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x16cc0
movw %ax, 0xe(%rsp)
movl %eax, %ecx
andl $0xfffe, %ecx           # imm = 0xFFFE
cmpl $0x102, %ecx            # imm = 0x102
jne 0x17cf4
movq 0x48(%rsp), %rdi
callq 0x16f30
movzwl 0xe(%rsp), %eax
jmp 0x17cf4
movq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x169a0
movq 0x10(%rsp), %rdi
callq 0x16720
leaq 0x30(%rsp), %rdi
callq 0x165a0
testl %ebx, %ebx
sete %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x271ba(%rip), %rax     # 0x3ef30
movq (%rax), %rcx
leaq 0xf2bb(%rip), %rdi      # 0x2703b
pushq $0x2a
popq %rsi
pushq $0x1
popq %rdx
callq 0x179f0
jmp 0x17d5b
jmp 0x17d8f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x165a0
movq %rbx, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/SQLParserResult.cpp
// Function: hsql::SQLParserResult::operator=(hsql::SQLParserResult&&)
SQLParserResult& SQLParserResult::operator=(SQLParserResult&& moved) {
  isValid_ = moved.isValid_;
  errorMsg_ = moved.errorMsg_;
  statements_ = std::move(moved.statements_);

  moved.errorMsg_ = nullptr;
  moved.reset();
  return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x20(%rsi), %al
movb %al, 0x20(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x16be0
andq $0x0, 0x28(%rbx)
movq %rbx, %rdi
callq 0x169b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18153
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1814d
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x1813a
movq 0x8(%rbx), %rax
cmpq %rax, 0x10(%rbx)
je 0x18161
movq %rax, 0x10(%rbx)
movb $0x0, 0x20(%rbx)
movq 0x28(%rbx), %rdi
callq 0x16f30
andq $0x0, 0x28(%rbx)
orq $-0x1, 0x30(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x16f30
movq 0x8(%rbx), %rdi
callq 0x16f30
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x21bc9
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x21ba8
movq (%r14), %rdi
callq 0x16f30
addq $0x8, %r14
jmp 0x21b95
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x21bb9
movq %rbx, %rdi
callq 0x17760
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16d50
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1d2c3(%rip), %rax     # 0x3ef98
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
callq 0x16f30
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x21cf6
movq %r14, %rdi
callq 0x16c00
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x21d4f
movq (%rax), %r12
movq 0x8(%rax), %r13
pushq $0x18
popq %r14
cmpq %r13, %r12
je 0x21d3c
movq (%r12), %r15
testq %r15, %r15
je 0x21d2b
movq %r15, %rdi
callq 0x17850
movq %r15, %rdi
movq %r14, %rsi
callq 0x16d50
addq $0x8, %r12
jmp 0x21d15
movq 0x40(%rbx), %rbx
testq %rbx, %rbx
je 0x21d4f
movq %rbx, %rdi
callq 0x17210
jmp 0x21d51
xorl %ebx, %ebx
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x16d50
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16f40
testq %rax, %rax
jne 0x21db6
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x3, (%rsi)
callq 0x16f40
testq %rax, %rax
je 0x21dd7
movq 0x8(%rbx), %rdi
leaq 0x4(%rsp), %rsi
movl $0x2, (%rsi)
callq 0x16f40
testq %rax, %rax
je 0x21dd3
xorl %eax, %eax
jmp 0x21dd9
movb $0x0, 0x38(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x1d14d(%rip), %rax     # 0x3ef88
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
callq 0x16f30
movq 0x30(%rbx), %rdi
callq 0x16f30
movq 0x38(%rbx), %rdi
callq 0x16f30
movq 0x40(%rbx), %rdi
callq 0x16f30
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x21e75
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x21eba
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x21e9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x21e98
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x21e85
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x21eaf
movq %r14, %rdi
callq 0x16f60
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq 0x58(%rbx), %rax
testq %rax, %rax
je 0x21eff
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x21ee3
movq (%r14), %rdi
testq %rdi, %rdi
je 0x21edd
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x21eca
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0x21ef4
movq %r14, %rdi
callq 0x16620
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x21f3e
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x21f22
movq (%r14), %rdi
callq 0x16f30
addq $0x8, %r14
jmp 0x21f0f
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x21f33
movq %r14, %rdi
callq 0x17760
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq 0x60(%rbx), %rax
testq %rax, %rax
je 0x21f7d
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x21f61
movq (%r14), %rdi
callq 0x16f30
addq $0x8, %r14
jmp 0x21f4e
movq 0x60(%rbx), %r14
testq %r14, %r14
je 0x21f72
movq %r14, %rdi
callq 0x17760
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x17100
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %r15
movq %r15, %rdi
callq 0x16d20
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x50(%rbx)
movq %r15, %rdi
callq 0x16d20
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x58(%rbx)
movq (%r14), %r12
movq 0x8(%r14), %rbp
movq 0x1cf7c(%rip), %r14     # 0x3ef70
movq 0x1cf3d(%rip), %r15     # 0x3ef38
cmpq %rbp, %r12
je 0x22065
movq (%r12), %r13
testq %r13, %r13
je 0x2205f
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x16ec0
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x22033
movq 0x50(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x160e0
jmp 0x2205f
movq %r13, %rdi
movq %r14, %rsi
movq 0x1ce50(%rip), %rdx     # 0x3ee90
xorl %ecx, %ecx
callq 0x16ec0
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2205f
movq 0x58(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x16140
addq $0x8, %r12
jmp 0x21ffb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x1c99b(%rip), %rax     # 0x3eee0
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x22591
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x22575
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2256f
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x2255c
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x22586
movq %r14, %rdi
callq 0x16920
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x225d6
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x225ba
movq (%r14), %rdi
testq %rdi, %rdi
je 0x225b4
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x225a1
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x225cb
movq %r14, %rdi
callq 0x163c0
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x16d50
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x225ea
movq (%rdi), %rax
popq %rbx
popq %r14
popq %r15
jmpq *0x8(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x1c87d(%rip), %rax     # 0x3ef00
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x22699
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x226a8
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x226b7
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x226c9
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x30(%rbx), %rdi
callq 0x16f30
movq 0x38(%rbx), %rdi
callq 0x16f30
movq 0x40(%rbx), %rdi
callq 0x16f30
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x2272e
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x2270d
movq (%r14), %rdi
testq %rdi, %rdi
je 0x22707
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x226f4
movq 0x20(%rbx), %rbx
testq %rbx, %rbx
je 0x2271e
movq %rbx, %rdi
callq 0x16920
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16d50
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeOpUnary(hsql::OperatorType, hsql::Expr*)
Expr* Expr::makeOpUnary(OperatorType op, Expr* expr) {
  Expr* e = new Expr(kExprOperator);
  e->opType = op;
  e->expr = expr;
  e->expr2 = nullptr;
  return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x17a60
movl %ebp, 0x8c(%rbx)
movq %r14, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeOpBinary(hsql::Expr*, hsql::OperatorType, hsql::Expr*)
Expr* Expr::makeOpBinary(Expr* expr1, OperatorType op, Expr* expr2) {
  Expr* e = new Expr(kExprOperator);
  e->opType = op;
  e->expr = expr1;
  e->expr2 = expr2;
  return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x17a60
movl %ebp, 0x8c(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x17a60
movq %r14, 0x10(%rbx)
movl $0x1, 0x8c(%rbx)
pushq $0x18
popq %rdi
callq 0x16d20
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x20(%rbx)
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0x16d40
movq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x16d40
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x16d20
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x17a60
andl $0x0, 0x8c(%rbx)
pushq $0x18
popq %rdi
callq 0x16d20
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x20(%rbx)
movq %rsp, %rsi
movq %rax, %rdi
callq 0x16d40
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeCaseListElement(hsql::Expr*, hsql::Expr*)
Expr* Expr::makeCaseListElement(Expr* when, Expr* then) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpCaseListElement;
  e->expr = when;
  e->expr2 = then;
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x17a60
movl $0x3, 0x8c(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeCase(hsql::Expr*, hsql::Expr*, hsql::Expr*)
Expr* Expr::makeCase(Expr* expr, Expr* caseList, Expr* elseExpr) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpCase;
  e->expr = expr;
  e->expr2 = elseExpr;
  e->exprList = caseList->exprList;
  caseList->exprList = nullptr;
  delete caseList;
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x17a60
movl $0x2, 0x8c(%rbx)
movq %r12, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq 0x20(%r14), %rax
movq %rax, 0x20(%rbx)
andq $0x0, 0x20(%r14)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeLiteral(bool)
Expr* Expr::makeLiteral(bool val) {
  Expr* e = new Expr(kExprLiteralInt);
  e->ival = (int)val;
  e->isBoolLiteral = true;
  return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0x2
popq %rsi
movq %rax, %rdi
callq 0x17a60
movzbl %bpl, %eax
movq %rax, 0x50(%rbx)
movb $0x1, 0x88(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
nop
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeIntervalLiteral(long, hsql::DatetimeField)
Expr* Expr::makeIntervalLiteral(int64_t duration, DatetimeField unit) {
  Expr* e = new Expr(kExprLiteralInterval);
  e->ival = duration;
  e->datetimeField = unit;
  return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0x5
popq %rsi
movq %rax, %rdi
callq 0x17a60
movq %r14, 0x50(%rbx)
movl %ebp, 0x60(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeColumnRef(char*, char*)
Expr* Expr::makeColumnRef(char* table, char* name) {
  Expr* e = new Expr(kExprColumnRef);
  e->name = name;
  e->table = table;
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %rax, %rdi
callq 0x17a60
movq %r15, 0x30(%rbx)
movq %r14, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeFunctionRef(char*, std::vector<hsql::Expr*, std::allocator<hsql::Expr*>>*, bool, hsql::WindowDescription*)
Expr* Expr::makeFunctionRef(char* func_name, std::vector<Expr*>* exprList, bool distinct, WindowDescription* window) {
  Expr* e = new Expr(kExprFunctionRef);
  e->name = func_name;
  e->exprList = exprList;
  e->distinct = distinct;
  e->windowDescription = window;
  return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movl $0xa0, %edi
callq 0x16d20
movq %rax, %r14
pushq $0x9
popq %rsi
movq %rax, %rdi
callq 0x17a60
movq %r12, 0x30(%r14)
movq %r15, 0x20(%r14)
movb %bpl, 0x90(%r14)
movq %rbx, 0x98(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0xa0, %esi
movq %r14, %rdi
callq 0x16d50
movq %rbx, %rdi
callq 0x17790
nop
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeArrayIndex(hsql::Expr*, long)
Expr* Expr::makeArrayIndex(Expr* expr, int64_t index) {
  Expr* e = new Expr(kExprArrayIndex);
  e->expr = expr;
  e->ival = index;
  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xe
popq %rsi
movq %rax, %rdi
callq 0x17a60
movq %r15, 0x10(%rbx)
movq %r14, 0x50(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeExists(hsql::SelectStatement*)
Expr* Expr::makeExists(SelectStatement* select) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpExists;
  e->select = select;
  return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x17a60
movl $0x1a, 0x8c(%rbx)
movq %r14, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeInOperator(hsql::Expr*, std::vector<hsql::Expr*, std::allocator<hsql::Expr*>>*)
Expr* Expr::makeInOperator(Expr* expr, std::vector<Expr*>* exprList) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpIn;
  e->expr = expr;
  e->exprList = exprList;

  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x17a60
movl $0x15, 0x8c(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeInOperator(hsql::Expr*, hsql::SelectStatement*)
Expr* Expr::makeInOperator(Expr* expr, SelectStatement* select) {
  Expr* e = new Expr(kExprOperator);
  e->opType = kOpIn;
  e->expr = expr;
  e->select = select;

  return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x17a60
movl $0x15, 0x8c(%rbx)
movq %r15, 0x10(%rbx)
movq %r14, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeExtract(hsql::DatetimeField, hsql::Expr*)
Expr* Expr::makeExtract(DatetimeField datetimeField, Expr* expr) {
  Expr* e = new Expr(kExprExtract);
  e->datetimeField = datetimeField;
  e->expr = expr;
  return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0xf
popq %rsi
movq %rax, %rdi
callq 0x17a60
movl %ebp, 0x60(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/hyrise[P]sql-parser/src/sql/Expr.cpp
// Function: hsql::Expr::makeCast(hsql::Expr*, hsql::ColumnType)
Expr* Expr::makeCast(Expr* expr, ColumnType columnType) {
  Expr* e = new Expr(kExprCast);
  e->columnType = columnType;
  e->expr = expr;
  return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xa0, %edi
callq 0x16d20
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %rax, %rdi
callq 0x17a60
leaq 0x20(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x78(%rbx)
movups %xmm0, 0x68(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x16d50
movq %r14, %rdi
callq 0x17790
// File: /workspace/github_cpp_makefile_star2_O2/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 0x170f0
movq %rax, %r15
movslq %ebp, %rsi
addq %r14, %rsi
movslq %ebx, %rbx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x165d0
movb $0x0, (%r15,%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq 0x1bdf4(%rip), %rax     # 0x3ef58
addq $0x10, %rax
movq %rax, (%rdi)
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x231aa
movq %rdi, %rbx
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x23197
movq (%r14), %rdi
testq %rdi, %rdi
je 0x23191
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x2317e
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x231aa
movq %rbx, %rdi
callq 0x16920
jmp 0x231ac
xorl %ebx, %ebx
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x16d50