LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tmtxt[P]microcontroller-emulation/rotamola34hc22.cpp
// Function: mcontroller::Rotamola34HC22::executeBranchAlways(int)
void Rotamola34HC22::executeBranchAlways(int address){

		if((address + 2) < this->getMemorySize()){
			// get the high byte and low byte address of the destination address
			unsigned char addressHighByte = this->getMemoryValueAtLocation(address + 1);
			unsigned char addressLowByte = this->getMemoryValueAtLocation(address + 2);

			// compute the destination address
			int destinationAddress = (addressHighByte << 8) | addressLowByte;

			// set the program counter to the new address
			this->setProgramCounter(destinationAddress);

			cout << "Message: Execution completed." << endl;
		} else {
			cerr << "Error: SIGWEED. Program executed past top of memory" << endl;
			this->executeHalt(address);
		}

	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal 0x2(%r14), %ebp
callq 0x3734
cmpl %eax, %ebp
jge 0x5214
incl %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3740
movl %eax, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3740
movzbl %r14b, %ecx
shll $0x8, %ecx
movzbl %al, %esi
orl %ecx, %esi
movq %rbx, %rdi
callq 0x373c
movq 0x5df3(%rip), %rbx      # 0xafc8
leaq 0x2514(%rip), %rsi      # 0x76f0
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20e0
movq 0x5dd5(%rip), %rbx      # 0xaff0
leaq 0x24ec(%rip), %rsi      # 0x770e
movl $0x33, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
popq %rbx
popq %r14
popq %rbp
jmp 0x5482
nop
// File: /workspace/github_cpp_makefile_star2_O1/tmtxt[P]microcontroller-emulation/rotamola34hc22.cpp
// Function: mcontroller::Rotamola34HC22::executeBranchIfALessThanB(int)
void Rotamola34HC22::executeBranchIfALessThanB(int address){

		if((address + 3) < this->getMemorySize()){
			
			// compare the value of A and B
			if(this->getA() < this->getB()){

				// get the high byte and low byte address of the destination address
				unsigned char addressHighByte = this->getMemoryValueAtLocation(address + 1);
				unsigned char addressLowByte = this->getMemoryValueAtLocation(address + 2);

				// compute the destination address
				int destinationAddress = (addressHighByte << 8) | addressLowByte;

				if(destinationAddress >= 0 && destinationAddress < this->getMemorySize()){
					


					// set the program counter to the new address
					this->setProgramCounter(destinationAddress);

					cout << "Message: Execution completed." << endl;

				} else {
					cout << "Error: Invalid memory address." << endl;
					this->executeHalt(address);
				}
			
			} else {
			
				// set the program counter to the third byte after the opcode
				this->setProgramCounter(address + 3);
				cout << "Message: Execution completed." << endl;
			}
			
		} else {
			cerr << "Error: SIGWEED. Program executed past top of memory" << endl;
			this->executeHalt(address);
		}

	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal 0x3(%r14), %ebp
callq 0x3734
cmpl %eax, %ebp
jge 0x530c
movb 0x1c(%rbx), %al
cmpb 0x1d(%rbx), %al
jae 0x52bc
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x3740
movl %eax, %ebp
addl $0x2, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3740
movzbl %bpl, %ecx
shll $0x8, %ecx
movzbl %al, %ebp
orl %ecx, %ebp
movq %rbx, %rdi
callq 0x3734
cmpl %eax, %ebp
jge 0x5357
movq %rbx, %rdi
movl %ebp, %esi
callq 0x373c
movq 0x5cfb(%rip), %rbx      # 0xafc8
leaq 0x241c(%rip), %rsi      # 0x76f0
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20e0
movq 0x5cdd(%rip), %rbx      # 0xaff0
leaq 0x23f4(%rip), %rsi      # 0x770e
movl $0x33, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
popq %rbx
popq %r14
popq %rbp
jmp 0x5482
movq 0x5c6a(%rip), %rbx      # 0xafc8
leaq 0x23dd(%rip), %rsi      # 0x7742
movl $0x1e, %edx
jmp 0x531f
// File: /workspace/github_cpp_makefile_star2_O1/tmtxt[P]microcontroller-emulation/rotamola34hc22.cpp
// Function: mcontroller::Rotamola34HC22::executeBranchIfLessThanA(int)
void Rotamola34HC22::executeBranchIfLessThanA(int address){

		if((address + 4) < this->getMemorySize()){
			
			// get the value to compare to A
			unsigned char comparisonValue = this->getMemoryValueAtLocation(address + 1);

			// compare A and comparisonValue
			if(comparisonValue < this->getA()){

				// get the high byte and low byte address of the destination address
				unsigned char addressHighByte = this->getMemoryValueAtLocation(address + 2);
				unsigned char addressLowByte = this->getMemoryValueAtLocation(address + 3);

				// compute the destination address
				int destinationAddress = (addressHighByte << 8) | addressLowByte;

				if(destinationAddress >=0 && destinationAddress < this->getMemorySize()){
					
					// set the program counter to the new address
					this->setProgramCounter(destinationAddress);
					cout << "Message: Execution completed." << endl;
				} else {
					cout << "Error: Invalid memory address." << endl;
					this->executeHalt(address);
				}

			
			} else {

				// set the program counter to the the fourth byte after the opcode
				this->setProgramCounter(address + 4);

				cout << "Message: Execution completed." << endl;
			
			}
		} else {
			cerr << "Error: SIGWEED. Program executed past top of memory" << endl;
			this->executeHalt(address);
		}

	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leal 0x4(%r14), %ebp
callq 0x3734
cmpl %eax, %ebp
jge 0x5421
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x3740
cmpb 0x1c(%rbx), %al
jae 0x53d1
leal 0x2(%r14), %esi
movq %rbx, %rdi
callq 0x3740
movl %eax, %ebp
addl $0x3, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3740
movzbl %bpl, %ecx
shll $0x8, %ecx
movzbl %al, %ebp
orl %ecx, %ebp
movq %rbx, %rdi
callq 0x3734
cmpl %eax, %ebp
jge 0x546c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x373c
movq 0x5be6(%rip), %rbx      # 0xafc8
leaq 0x2307(%rip), %rsi      # 0x76f0
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20e0
movq 0x5bc8(%rip), %rbx      # 0xaff0
leaq 0x22df(%rip), %rsi      # 0x770e
movl $0x33, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
popq %rbx
popq %r14
popq %rbp
jmp 0x5482
movq 0x5b55(%rip), %rbx      # 0xafc8
leaq 0x22c8(%rip), %rsi      # 0x7742
movl $0x1e, %edx
jmp 0x5434
nop
// File: /workspace/github_cpp_makefile_star2_O1/tmtxt[P]microcontroller-emulation/microcontrollerfactory.cpp
// Function: mcontroller::MicrocontrollerFactory::MicrocontrollerFactory()
MicrocontrollerFactory::MicrocontrollerFactory(){

		// Init all available micrcontrollers here so that later when there are
		// more microcontroller classes, just add them here
		this->addMicrocontroller("R500", MopsR500::create);
		this->addMicrocontroller("PIC32F42", MacrochipPIC32F42::create);
		this->addMicrocontroller("34HC22", Rotamola34HC22::create);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x23bd(%rip), %rsi      # 0x78d6
leaq 0x23ba(%rip), %rdx      # 0x78da
leaq 0x40(%rsp), %rdi
callq 0x3620
leaq -0x10ef(%rip), %rdx     # 0x4442
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0x564c
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x5555
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2376(%rip), %rsi      # 0x78db
leaq 0x2377(%rip), %rdx      # 0x78e3
leaq 0x20(%rsp), %rdi
callq 0x3620
leaq -0x1ab7(%rip), %rdx     # 0x3ac6
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x564c
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x55a1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2170
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2333(%rip), %rsi      # 0x78e4
leaq 0x2332(%rip), %rdx      # 0x78ea
movq %rsp, %rdi
callq 0x3620
leaq -0xb01(%rip), %rdx      # 0x4ac6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x564c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x55e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x563c
movq 0x10(%rsp), %rsi
jmp 0x562f
jmp 0x5639
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x563c
movq 0x30(%rsp), %rsi
jmp 0x562f
jmp 0x5639
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x563c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2170
jmp 0x563c
movq %rax, %r14
movq %rbx, %rdi
callq 0x350e
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/tmtxt[P]microcontroller-emulation/microcontrollerfactory.cpp
// Function: mcontroller::MicrocontrollerFactory::createMicrocontroller(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Microcontroller* MicrocontrollerFactory::createMicrocontroller(string name){


		// check if the create function is exist
		if(this->createFunctionMap.find(name) == this->createFunctionMap.end()){
			// not exist
			// notify user
			cerr << "Error: Invalid Microcontroller type." << endl;
			cout << "Message: Valid types of Microcontroller are "
				 << this->getAvailableMicrocontrollersString()
				 << endl;
			return 0;
		} else {
			// exist
			// get the create function from the map
			createFunction* createFn = this->createFunctionMap[name];			
			return createFn();
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5bb2
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
je 0x5705
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58f2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *(%rax)
movq 0x58e4(%rip), %r14      # 0xaff0
leaq 0x21d8(%rip), %rsi      # 0x78eb
movl $0x24, %edx
movq %r14, %rdi
callq 0x2190
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
movq 0x587a(%rip), %r14      # 0xafc8
leaq 0x21bb(%rip), %rsi      # 0x7910
movl $0x2c, %edx
movq %r14, %rdi
callq 0x2190
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x57f6
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x2190
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x20e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57c4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x57ee
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/tmtxt[P]microcontroller-emulation/microcontrollerfactory.cpp
// Function: mcontroller::MicrocontrollerFactory::getAvailableMicrocontrollersString[abi:cxx11]()
string MicrocontrollerFactory::getAvailableMicrocontrollersString(){
		// get the iterator
		map<string, createFunction*>::iterator it;

		// the return string
		string microcontrollerString;

		// iterate through the map
		for (it = this->createFunctionMap.begin(); it != this->createFunctionMap.end(); ++it){
			// get the key and then append to the string
			microcontrollerString.append(it->first);
			microcontrollerString.append(" ");
		}

		return microcontrollerString;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x18(%rsi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x5857
leaq 0x1b7a(%rip), %r12      # 0x73a6
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq %rbx, %rdi
callq 0x2080
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2270
movq %r15, %rdi
callq 0x20f0
movq %rax, %r15
cmpq %r14, %rax
jne 0x582c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x587b
movq (%r13), %rsi
incq %rsi
callq 0x2170
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/tmtxt[P]microcontroller-emulation/microcontrollerfactory.cpp
// Function: mcontroller::MicrocontrollerFactory::getAvailableMicrocontrollersSet[abi:cxx11]()
set<string> MicrocontrollerFactory::getAvailableMicrocontrollersSet(){
		// get the iterator
		map<string, createFunction*>::iterator it;

		// the return set
		set<string> microcontrollerSet;

		// iterate through the map
		for (it = this->createFunctionMap.begin(); it != this->createFunctionMap.end(); ++it){
			// insert the key to the set
			microcontrollerSet.insert(it->first);
		}

		return microcontrollerSet;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x18(%rsi), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x58d5
leaq 0x20(%r15), %rsi
movq %rbx, %rdi
callq 0x5e5a
movq %r15, %rdi
callq 0x20f0
movq %rax, %r15
cmpq %r14, %rax
jne 0x58b9
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x596e
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/main.cpp
// Function: cleanup(TrainingFileData*, QueryFileData*, float*, float**)
void cleanup(TrainingFileData* training_file_data, QueryFileData* query_file_data, float* training_points, float** query_points) {
    delete[] training_points;

    for (std::size_t i = 0; i < query_file_data->num_points; ++i) {
        delete query_points[i];
    }

    delete[] query_points;

    delete training_file_data;
    delete query_file_data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x230a
movq %rdx, %rdi
callq 0x2150
cmpq $0x0, 0x8(%rbx)
je 0x2330
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
testq %rdi, %rdi
je 0x2327
movl $0x4, %esi
callq 0x2130
incq %r12
cmpq 0x8(%rbx), %r12
jb 0x2314
testq %r15, %r15
je 0x233d
movq %r15, %rdi
callq 0x2150
testq %r14, %r14
je 0x234f
movl $0x18, %esi
movq %r14, %rdi
callq 0x2130
testq %rbx, %rbx
je 0x236c
movl $0x20, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2130
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/fileprocessor/TrainingFileProcessor.hpp
// Function: TrainingFileProcessor::readTrainingFileHeader()
TrainingFileData* readTrainingFileHeader() {
        char file_type[8];
        this->input_stream.read(reinterpret_cast<char *>(&file_type), 8);

        std::size_t file_id = 0;
        this->input_stream.read(reinterpret_cast<char *>(&file_id), 8);

        std::size_t num_points = 0;
        this->input_stream.read(reinterpret_cast<char *>(&num_points), 8);

        std::size_t num_dimensions = 0;
        this->input_stream.read(reinterpret_cast<char *>(&num_dimensions), 8);

        this->file_data = new TrainingFileData(file_id, num_points, num_dimensions);

        return static_cast<TrainingFileData*>(this->file_data);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x20(%rsp), %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x2140
xorl %ebp, %ebp
leaq 0x18(%rsp), %r15
movq %rbp, (%r15)
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2140
leaq 0x10(%rsp), %r12
movq %rbp, (%r12)
movl $0x8, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2140
leaq 0x8(%rsp), %r13
movq %rbp, (%r13)
movl $0x8, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2140
movl $0x18, %edi
callq 0x2120
movq (%r15), %rcx
movq (%r12), %rdx
movq (%r13), %rsi
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
movq %rsi, 0x10(%rax)
movq %rax, 0x228(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/fileprocessor/FileProcessor.hpp
// Function: FileProcessor::readPoints1D()
float* readPoints1D() {
        std::size_t num_points = this->file_data->num_points;
        float* points = new float[num_points * this->file_data->num_dimensions];

        for (std::size_t i = 0; i < num_points; ++i) {
            for (std::size_t j = 0; j < this->file_data->num_dimensions; ++j) {
                float* f = points + ((num_points * j) + i);

                this->input_stream.read(
                    (char*) f,
                    sizeof(float)
                );
            }
        }

        return points;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x228(%rdi), %rax
movq 0x8(%rax), %r14
movq 0x10(%rax), %rax
imulq %r14, %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x2030
movq %rax, (%rsp)
movq %r14, 0x8(%rsp)
testq %r14, %r14
je 0x2a69
leaq 0x20(%rbx), %r15
movq 0x8(%rsp), %rax
leaq (,%rax,4), %rbp
xorl %r14d, %r14d
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x228(%rbx), %rax
cmpq $0x0, 0x10(%rax)
je 0x2a59
movq 0x10(%rsp), %r12
xorl %r13d, %r13d
movl $0x4, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2140
incq %r13
movq 0x228(%rbx), %rax
addq %rbp, %r12
cmpq 0x10(%rax), %r13
jb 0x2a36
incq %r14
addq $0x4, 0x10(%rsp)
cmpq 0x8(%rsp), %r14
jne 0x2a20
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/filewriter/../../src/kdtree/KDTree.hpp
// Function: hpyc::KDTree<float>::KDTree(float*, unsigned long, unsigned long)
KDTree(ItemT* np_array_in, const std::size_t num_points_in, const std::size_t num_dimensions_in):
        np_array(np_array_in),
        num_points(num_points_in),
        num_dimensions(num_dimensions_in)
    {
        // TODO get rid of this copy? Need to work out whether the user is okay w/ sacrificing their existing array.
        this->np_array = new ItemT[num_points_in * num_dimensions_in];
        std::memcpy(this->np_array, np_array_in, sizeof(ItemT) * num_points_in * num_dimensions_in);

        // Create a column-major representation for compatibility with implemented Quickselect method.
        this->nodes = new ItemT*[num_dimensions_in];

        for (std::size_t i = 0; i < num_dimensions_in; ++i) {
            this->nodes[i] = np_array_in + (i * num_points_in);
        }

        this->buildTree(0, num_points_in, 0);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsi, (%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rcx, %r13
imulq %rdx, %r13
movq %r13, %rax
shrq $0x3e, %rax
shlq $0x2, %r13
xorl %ebp, %ebp
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
orq %r13, %rdi
callq 0x2030
movq %rax, (%r14)
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x20f0
movq %r15, %rax
shrq $0x3d, %rax
leaq (,%r15,8), %rcx
negq %rax
sbbq %rbp, %rbp
orq %rcx, %rbp
movq %rbp, %rdi
callq 0x2030
movq %rax, 0x8(%r14)
testq %r15, %r15
je 0x2b1c
leaq (,%rbx,4), %rax
xorl %ecx, %ecx
movq 0x8(%r14), %rdx
movq %r12, (%rdx,%rcx,8)
incq %rcx
addq %rax, %r12
cmpq %rcx, %r15
jne 0x2b09
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3386
nop
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/fileprocessor/QueryFileProcessor.hpp
// Function: QueryFileProcessor::readQueryFileHeader()
QueryFileData* readQueryFileHeader() {
        char file_type[8];
        this->input_stream.read(reinterpret_cast<char *>(&file_type), 8);

        std::size_t file_id = 0;
        this->input_stream.read(reinterpret_cast<char *>(&file_id), 8);

        std::size_t num_points = 0;
        this->input_stream.read(reinterpret_cast<char *>(&num_points), 8);

        std::size_t num_dimensions = 0;
        this->input_stream.read(reinterpret_cast<char *>(&num_dimensions), 8);

        std::size_t num_neighbors = 0;
        this->input_stream.read(reinterpret_cast<char *>(&num_neighbors), 8);

        this->file_data = new QueryFileData(file_id, num_points, num_dimensions, num_neighbors);

        return static_cast<QueryFileData*>(this->file_data);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x20(%rsp), %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x2140
xorl %r15d, %r15d
movq %rsp, %rsi
movq %r15, (%rsi)
movl $0x8, %edx
movq %r14, %rdi
callq 0x2140
leaq 0x18(%rsp), %r12
movq %r15, (%r12)
movl $0x8, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2140
leaq 0x10(%rsp), %r13
movq %r15, (%r13)
movl $0x8, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x2140
leaq 0x8(%rsp), %rbp
movq %r15, (%rbp)
movl $0x8, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2140
movl $0x20, %edi
callq 0x2120
movq %rsp, %rcx
movq (%rcx), %rcx
movq (%r12), %rdx
movq (%r13), %rsi
movq (%rbp), %rdi
movq %rcx, (%rax)
movq %rdx, 0x8(%rax)
movq %rsi, 0x10(%rax)
movq %rdi, 0x18(%rax)
movq %rax, 0x228(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/fileprocessor/FileProcessor.hpp
// Function: FileProcessor::readPointsRowCol()
float** readPointsRowCol() {
        std::size_t num_points = this->file_data->num_points;

        float** points = new float*[num_points];

        for (std::size_t i = 0; i < num_points; i++) {
            if (this->input_stream) {
                float* f = new float[this->file_data->num_dimensions];

                this->input_stream.read(
                    (char*) f,
                    this->file_data->num_dimensions * sizeof(float)
                );

                points[i] = (f);
            }
        }

        this->close();

        return points;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x228(%rdi), %rax
movq 0x8(%rax), %r13
movq %r13, %rax
shrq $0x3d, %rax
leaq (,%r13,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x2030
movq %rax, (%rsp)
testq %r13, %r13
je 0x2ca9
leaq 0x20(%rbx), %r15
xorl %ebp, %ebp
movq 0x20(%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rbx,%rax)
jne 0x2ca1
movq 0x228(%rbx), %r14
movq 0x10(%r14), %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
negq %rcx
movl $0x0, %edi
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x2030
movq %rax, %r12
movq 0x10(%r14), %rdx
shlq $0x2, %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x2140
movq (%rsp), %rax
movq %r12, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r13
jne 0x2c4b
movq 0x20(%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rbx,%rax)
jne 0x2cc4
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2050
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/filewriter/ResultsFileWriter.hpp
// Function: ResultsFileWriter::writeFileHeader()
void writeFileHeader() {
        char file_type[] = "RESULT\0\0";
        auto file_id = this->generateFileID();
        this->results_file.write(reinterpret_cast<const char*>(&file_type), 8);
        this->results_file.write(reinterpret_cast<const char*>(&this->training_file_data->file_id), 8);
        this->results_file.write(reinterpret_cast<const char*>(&this->query_file_data->file_id), 8);
        this->results_file.write(reinterpret_cast<const char*>(&file_id), 8);
        this->results_file.write(reinterpret_cast<const char*>(&(this->query_file_data->num_points)), 8);
        this->results_file.write(reinterpret_cast<const char*>(&(this->query_file_data->num_dimensions)), 8);
        this->results_file.write(reinterpret_cast<const char*>(&(this->query_file_data->num_neighbors)), 8);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movabsq $0x544c55534552, %rax   # imm = 0x544C55534552
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
callq 0x3200
movq %rsp, %r15
movq %rax, (%r15)
leaq 0x30(%rbx), %r14
movl $0x8, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2160
movq 0x20(%rbx), %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x2160
movq 0x28(%rbx), %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x2160
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movq 0x28(%rbx), %rsi
addq $0x8, %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x2160
movq 0x28(%rbx), %rsi
addq $0x10, %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x2160
movq 0x28(%rbx), %rsi
addq $0x18, %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x2160
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/filewriter/../../src/kdtree/KDTree.hpp
// Function: hpyc::KDTree<float>::nearestNeighborsSearch(float const*, unsigned long, unsigned long*, double*) const
void KDTree<ItemT>::nearestNeighborsSearch(const ItemT* query_point, const std::size_t num_neighbors, std::size_t* indices, double* distances) const {
    KNNQueue<ItemT> queue(query_point, num_neighbors, this->num_dimensions);

    this->nearestNeighborsSearch(query_point, 0, this->num_points, 0, queue);
        queue.sortArray();

    for (std::size_t i = num_neighbors; i > 0; --i) {
        indices[i - 1] = queue.array[i - 1].index;
        distances[i - 1] = queue.array[i - 1].distance_from_queried_point;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, 0x10(%rsp)
movq %rdi, %rbp
movq 0x18(%rdi), %r12
leaq 0x18(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x10(%rax)
movq %r12, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq %rdx, %rax
shrq $0x3c, %rax
movq %rdx, %rcx
shlq $0x4, %rcx
xorl %r13d, %r13d
negq %rax
movl $0x0, %edi
sbbq %rdi, %rdi
movq %rcx, 0x8(%rsp)
orq %rcx, %rdi
callq 0x2030
leaq 0x18(%rsp), %rcx
movq %rax, 0x28(%rcx)
movq %r12, %rax
shrq $0x3e, %rax
shlq $0x2, %r12
negq %rax
sbbq %r13, %r13
orq %r12, %r13
movq %r13, %rdi
callq 0x2030
leaq 0x18(%rsp), %r9
movq %rax, 0x8(%r9)
movq 0x10(%rbp), %rcx
movq %rbp, %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x41a4
movq 0x28(%rsp), %r12
testq %r12, %r12
je 0x2eeb
movq 0x40(%rsp), %r13
bsrq %r12, %rdx
shlq $0x4, %r12
addq %r13, %r12
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x4836
movq %r13, %rdi
movq %r12, %rsi
callq 0x4940
testq %r15, %r15
je 0x2f25
movq 0x40(%rsp), %rax
movq 0x8(%rsp), %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq -0x8(%rax), %rcx
movq %rcx, -0x8(%r14,%r15,8)
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbx,%r15,8)
leaq -0x1(%r15), %rcx
addq $-0x10, %rax
movq %rcx, %r15
testq %rcx, %rcx
jne 0x2f01
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2f34
callq 0x2150
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x2f55
callq 0x2150
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/filewriter/ResultsFileWriter.hpp
// Function: void ResultsFileWriter::writeQueryResults<float>(hpyc::KDTree<float>&, unsigned long*)
void writeQueryResults(hpyc::KDTree<ItemT>& tree, std::size_t* indices) {
        ItemT* point_to_write = new ItemT[this->query_file_data->num_dimensions];

        for (std::size_t i = 0; i < this->query_file_data->num_neighbors; i++) {
            tree.readPointAt(point_to_write, indices[i]);

            this->results_file.write(
                reinterpret_cast<char*>(&(point_to_write)),
                sizeof(ItemT) * this->query_file_data->num_dimensions
            );
        }

        delete[] point_to_write;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%rdi), %rax
movq 0x10(%rax), %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x2030
movq %rax, (%rsp)
movq 0x28(%r15), %rax
cmpq $0x0, 0x18(%rax)
je 0x2ffd
leaq 0x30(%r15), %r12
xorl %ebp, %ebp
movq %rsp, %r13
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x2fdd
movq (%rsp), %rdx
movq (%rbx,%rbp,8), %rsi
movq 0x8(%r14), %rdi
xorl %r8d, %r8d
movq (%rdi,%r8,8), %r9
movss (%r9,%rsi,4), %xmm0
movss %xmm0, (%rdx,%r8,4)
incq %r8
cmpq %r8, %rcx
jne 0x2fc5
movq 0x10(%rax), %rdx
shlq $0x2, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2160
incq %rbp
movq 0x28(%r15), %rax
cmpq 0x18(%rax), %rbp
jb 0x2fad
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x300b
callq 0x2150
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/filewriter/ResultsFileWriter.hpp
// Function: ResultsFileWriter::generateFileID()
std::size_t generateFileID() {
        std::ifstream urandom("/dev/urandom", std::ios::in|std::ios::binary);
        std::size_t rand = 0;

        if (urandom) {
            urandom.read(reinterpret_cast<char*>(&rand), 8);
            urandom.close();
        }

        return 69;
//        return rand;
    }

// Assembly:
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
leaq 0x1ed4(%rip), %rsi      # 0x50e3
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0xc, %edx
callq 0x21d0
movq $0x0, (%rsp)
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x3253
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x2140
leaq 0x8(%rsp), %rdi
callq 0x2050
leaq 0x8(%rsp), %rdi
callq 0x2060
movl $0x45, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/filewriter/../../src/kdtree/KNNQueue.hpp
// Function: hpyc::KNNQueue<float>::registerAsNeighbor(unsigned long)
void KNNQueue<ItemT>::registerAsNeighbor(std::size_t index) {
    double distance_from_query = distanceBetween(this->query_point, this->potential_neighbor, this->num_dimensions);

    this->array[current_size].index = index;
    this->array[this->current_size].distance_from_queried_point = distance_from_query;

    // Swap the new neighbor with the neighbor at i=0 if its distance from the query point is greater.
    std::swap(
        this->array[0],
        this->array[this->current_size & (0 - (this->array[0].distance_from_queried_point < this->array[current_size].distance_from_queried_point))]
    );

    ++this->current_size;
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4543
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movss (%rdx,%r8,4), %xmm1
subss (%rcx,%r8,4), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r8
cmpq %r8, %rax
jne 0x4521
jmp 0x4547
xorpd %xmm0, %xmm0
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
movq %rax, %rdx
shlq $0x4, %rdx
movq %rsi, (%rcx,%rdx)
movsd %xmm0, 0x8(%rcx,%rdx)
xorl %edx, %edx
ucomisd 0x8(%rcx), %xmm0
cmovaq %rax, %rdx
shlq $0x4, %rdx
movups (%rcx), %xmm0
movaps %xmm0, -0x18(%rsp)
movups (%rcx,%rdx), %xmm0
movups %xmm0, (%rcx)
movaps -0x18(%rsp), %xmm0
movups %xmm0, (%rcx,%rdx)
incq 0x20(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/filewriter/../../src/kdtree/KNNQueue.hpp
// Function: hpyc::KNNQueue<float>::registerAsNeighborIfCloser(unsigned long)
void KNNQueue<ItemT>::registerAsNeighborIfCloser(std::size_t index) {
    // If the priority queue is at capacity and the potential neighbor is closer to the query point than the current
    // furthest neighbor, remove the furthest neighbor from the priority queue and push the potential neighbor.
    double distance_from_query = distanceBetween(this->query_point, this->potential_neighbor, this->num_dimensions);

    if (this->closerThanFarthestNeighbor(distance_from_query)) {
        this->array[0].index = index;
        this->array[0].distance_from_queried_point = distance_from_query;

        this->siftDownRoot();
    }
}

// Assembly:
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x45c5
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
xorpd %xmm0, %xmm0
xorl %r8d, %r8d
movss (%rdx,%r8,4), %xmm1
subss (%rcx,%r8,4), %xmm1
cvtss2sd %xmm1, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %r8
cmpq %r8, %rax
jne 0x45a3
jmp 0x45c9
xorpd %xmm0, %xmm0
movq 0x28(%rdi), %rax
movsd 0x8(%rax), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x45e5
movq %rsi, (%rax)
movsd %xmm0, 0x8(%rax)
jmp 0x4736
retq
// File: /workspace/github_cpp_makefile_star2_O1/cfiutak1[P]HPyC-KD-Tree/./utils/filewriter/../../src/kdtree/KNNQueue.hpp
// Function: hpyc::KNNQueue<float>::siftDownRoot()
void KNNQueue<ItemT>::siftDownRoot() {
    std::size_t index = 0;
    std::size_t first_index_without_both_children = this->current_size / 2 - (this->current_size % 2 == 0);

    while (index < first_index_without_both_children) {
        std::size_t left_child = 2 * index + 1;
        std::size_t larger_child = left_child + (this->array[left_child] < this->array[left_child + 1]);
        std::size_t swap_destination = index + ((larger_child - index) & (0 - (this->array[index] < this->array[larger_child])));

        if (index == swap_destination) { return; }

        std::swap(
            this->array[index],
            this->array[swap_destination]
        );

        index = swap_destination;
    }

    // Special case for when the index only has one child.
    if (index == first_index_without_both_children && (this->current_size % 2 == 0)) {
        std::size_t left_child = 2 * index + 1;
        std::size_t swap_destination = index + ((left_child - index) & (0 - (this->array[index] < this->array[left_child])));

        std::swap(
            this->array[index],
            this->array[swap_destination]
        );
    }
}

// Assembly:
movq 0x20(%rdi), %rcx
movl %ecx, %eax
notl %eax
shrq %rcx
andl $0x1, %eax
subq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jae 0x47e5
leaq 0x1(,%rax,2), %rsi
movq 0x28(%rdi), %rdx
movq %rax, %r8
shlq $0x5, %r8
shlq $0x4, %rsi
movsd 0x28(%rdx,%r8), %xmm0
xorl %r8d, %r8d
ucomisd 0x8(%rdx,%rsi), %xmm0
seta %r8b
leaq (%r8,%rax,2), %rsi
incq %rsi
movq %rax, %r8
shlq $0x4, %r8
movq %rsi, %r9
shlq $0x4, %r9
movsd 0x8(%rdx,%r9), %xmm0
ucomisd 0x8(%rdx,%r8), %xmm0
ja 0x47a5
movq %rax, %rsi
movq %rax, %r9
cmpq %rsi, %rax
je 0x47d8
addq %rdx, %r8
movq %rsi, %r9
shlq $0x4, %r9
movups (%r8), %xmm0
movaps %xmm0, -0x18(%rsp)
movups (%rdx,%r9), %xmm0
movups %xmm0, (%r8)
movapd -0x18(%rsp), %xmm0
movupd %xmm0, (%rdx,%r9)
movq %rsi, %r9
cmpq %rsi, %rax
movq %r9, %rax
jne 0x4749
retq
jne 0x47e4
testb $0x1, 0x20(%rdi)
jne 0x47e4
leaq 0x1(,%rax,2), %rcx
movq 0x28(%rdi), %rdx
movq %rax, %rsi
shlq $0x4, %rsi
movq %rcx, %rdi
shlq $0x4, %rdi
movsd 0x8(%rdx,%rdi), %xmm0
ucomisd 0x8(%rdx,%rsi), %xmm0
cmovaq %rcx, %rax
shlq $0x4, %rax
movups (%rdx,%rsi), %xmm0
movaps %xmm0, -0x18(%rsp)
movups (%rdx,%rax), %xmm0
movups %xmm0, (%rdx,%rsi)
movaps -0x18(%rsp), %xmm0
movups %xmm0, (%rdx,%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/token.cpp
// Function: tokenBoolean::tokenBoolean(int, int, char*)
tokenBoolean::tokenBoolean(int l, int c, char* val){
    line = l;
    column = c;
    
    if ( strcmp(val,"true") == 0 ){
        value = true;
    } else {
        value = false;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
leaq 0x253c4(%rip), %rsi     # 0x2c004
movq %rcx, %rdi
callq 0x6400
testl %eax, %eax
sete 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/token.cpp
// Function: tokenConstant::tokenConstant(int, int, char*, int)
tokenConstant::tokenConstant(int l, int c, char* id, int t){
    line = l;
    column = c;
    
    ident = string(id);
    type = t;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rcx, %rsi
callq 0x6fae
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63c0
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6f7f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movl %ebx, 0x28(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x6fa6
movq (%r12), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_variable_declaration::dump(std::ostream&, int)
void AST_variable_declaration::dump(ostream &strm, int indentation){
    
    AST_declaration::dump(strm, indentation);
    
    strm << "Declaration: " << sym->getName()
         << " ("
         << types.types[ sym->getType() ]->name
         << ") [offset "
         << sym->offset
         << "] ";
    
    if ( value != 0 ){
        strm << "initialized with" << endl;
        value->dump(strm, indentation+1);
    } else {
        strm << "unitialized" << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x720c
leaq 0x2520b(%rip), %rsi     # 0x2c493
movl $0xd, %edx
movq %rbx, %rdi
callq 0x6360
movq 0x98(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x17fb8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x6360
movq %rax, %r15
leaq 0x2522d(%rip), %rsi     # 0x2c4ef
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
movq 0x98(%r14), %rdi
callq 0x17fde
cltq
leaq 0x37124(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r15, %rdi
callq 0x6360
movq %rax, %r15
leaq 0x2519c(%rip), %rsi     # 0x2c4a1
movl $0xa, %edx
movq %rax, %rdi
callq 0x6360
movq 0x98(%r14), %rax
movl 0x34(%rax), %esi
movq %r15, %rdi
callq 0x61e0
leaq 0x25181(%rip), %rsi     # 0x2c4ac
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7353
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
cmpq $0x0, 0xa0(%r14)
je 0x73ad
leaq 0x2514b(%rip), %rsi     # 0x2c4af
movl $0x10, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0xa0(%r14), %rdi
incl %ebp
movq (%rdi), %rax
movq %rbx, %rsi
movl %ebp, %edx
callq *(%rax)
jmp 0x73e8
leaq 0x2510c(%rip), %rsi     # 0x2c4c0
movl $0xb, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7411
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_discrete_arg_list::dump(std::ostream&, int)
void AST_discrete_arg_list::dump(ostream &strm, int indentation){  
    vector<symbol*>::iterator it;
    vector<pair<int,int> >::iterator it_boundaries;
    
    it_boundaries = boundaries.begin();
    for ( it = args.begin(); it != args.end(); ++it_boundaries){
        strm << setw(3) << (*it)->getLine() << ": ";
        dump_indentation(strm, indentation);

        strm << types.types[(*it)->getType()]->name << "(";
        strm << (*it)->getName();
        strm << ") in [" << (*it_boundaries).first << ", "
             << (*it_boundaries).second << "]";
        
        if ( ++it != args.end() ){
            strm << ",";
        }
        
        strm << endl;
        
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, 0x4(%rsp)
movq 0x10(%rdi), %rbp
cmpq 0x18(%rdi), %rbp
je 0x79d3
movq %rsi, %r14
movq %rdi, %r15
movq 0x28(%rdi), %rbx
leaq 0x26ef6(%rip), %r13     # 0x2e751
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%r14,%rax)
movq (%rbp), %rdi
callq 0x17fe2
movq %r14, %rdi
movl %eax, %esi
callq 0x6530
movl $0x2, %edx
movq %rax, %rdi
leaq 0x24e2a(%rip), %rsi     # 0x2c6b7
callq 0x6360
cmpl $0x0, 0x4(%rsp)
jle 0x78b3
movl 0x4(%rsp), %r12d
movl $0x4, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x6360
decl %r12d
jne 0x789e
movq (%rbp), %rdi
callq 0x17fde
cltq
leaq 0x36b43(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6360
movl $0x1, %edx
movq %rax, %rdi
leaq 0x24c05(%rip), %rsi     # 0x2c4f0
callq 0x6360
movq (%rbp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x17fb8
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x6360
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x792c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movl $0x6, %edx
movq %r14, %rdi
leaq 0x24bbf(%rip), %rsi     # 0x2c4fa
callq 0x6360
movl (%rbx), %esi
movq %r14, %rdi
callq 0x6530
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
leaq 0x250ea(%rip), %rsi     # 0x2ca46
callq 0x6360
movl 0x4(%rbx), %esi
movq %r12, %rdi
callq 0x6530
movl $0x1, %edx
movq %rax, %rdi
leaq 0x246c2(%rip), %rsi     # 0x2c03d
callq 0x6360
addq $0x8, %rbp
cmpq 0x18(%r15), %rbp
je 0x799e
movl $0x1, %edx
movq %r14, %rdi
leaq 0x24cf9(%rip), %rsi     # 0x2c692
callq 0x6360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
addq $0x8, %rbx
cmpq 0x18(%r15), %rbp
jne 0x785b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7a01
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x62f0
movq %rbx, %rdi
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_block::dump(std::ostream&, int)
void AST_block::dump(ostream &strm, int indentation){
    
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "{" << endl;
    
    vector<AST_statement*>::iterator it;
    for (it = statements.begin(); it != statements.end(); ++ it){
        (*it)->dump(strm, indentation+1);
    }
    
    strm << setw(3) << (statements.size() ? statements.back()->line : line) << ": ";
    dump_indentation(strm, indentation);
    strm << "}" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x6530
leaq 0x24c78(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r14d, %r14d
jle 0x7a6f
leaq 0x26cf9(%rip), %r12     # 0x2e751
movl %r14d, %ebp
movl $0x4, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x7a5b
leaq 0x24a8b(%rip), %rsi     # 0x2c501
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x80(%r15), %r12
movq 0x88(%r15), %rax
cmpq %rax, %r12
je 0x7adf
leal 0x1(%r14), %ebp
movq (%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
movl %ebp, %edx
callq *(%rax)
addq $0x8, %r12
movq 0x88(%r15), %rax
cmpq %rax, %r12
jne 0x7ac1
movq (%rbx), %rcx
movq -0x18(%rcx), %rcx
movq $0x3, 0x10(%rbx,%rcx)
cmpq 0x80(%r15), %rax
je 0x7afc
movq -0x8(%rax), %r15
addq $0x8, %r15
movl (%r15), %esi
movq %rbx, %rdi
callq 0x6530
leaq 0x24ba5(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %r14d, %r14d
jle 0x7b40
leaq 0x26c26(%rip), %r15     # 0x2e751
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6360
decl %r14d
jne 0x7b2b
leaq 0x249bc(%rip), %rsi     # 0x2c503
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6360
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x61f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_rlval::dump(std::ostream&, int)
void AST_rlval::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "R-L-Value:" << endl;
    value->dump(strm, indentation+1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %r14, %rdi
callq 0x6530
leaq 0x24a31(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebx, %ebx
jle 0x7cb4
leaq 0x26ab3(%rip), %r12     # 0x2e751
movl %ebx, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x7ca0
leaq 0x2485d(%rip), %rsi     # 0x2c518
movl $0xa, %edx
movq %r14, %rdi
callq 0x6360
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x48(%r15), %rdi
incl %ebx
movq (%rdi), %rax
movq (%rax), %rax
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/kelwinfc[P]ci4721-Fernandez-Gyomrey/src/AST/dump.cpp
// Function: AST_dereference::dump(std::ostream&, int)
void AST_dereference::dump(ostream &strm, int indentation){
    strm << setw(3) << line << ": ";
    dump_indentation(strm, indentation);
    strm << "Dereference [" << types.types[type]->name << "]" << endl;
    value->dump(strm, indentation+1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq $0x3, 0x10(%rsi,%rax)
movl 0x8(%rdi), %esi
movq %r14, %rdi
callq 0x6530
leaq 0x2497b(%rip), %rsi     # 0x2c6b7
movl $0x2, %edx
movq %rax, %rdi
callq 0x6360
testl %ebx, %ebx
jle 0x7d6a
leaq 0x269fd(%rip), %r12     # 0x2e751
movl %ebx, %ebp
movl $0x4, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x6360
decl %ebp
jne 0x7d56
leaq 0x247b2(%rip), %rsi     # 0x2c523
movl $0xd, %edx
movq %r14, %rdi
callq 0x6360
movslq 0x10(%r15), %rax
leaq 0x3667f(%rip), %rcx     # 0x3e408
movq (%rcx), %rcx
movq (%rcx,%rax,8), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %r14, %rdi
callq 0x6360
movq %rax, %r12
leaq 0x24293(%rip), %rsi     # 0x2c03d
movl $0x1, %edx
movq %rax, %rdi
callq 0x6360
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x62b0
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61f0
movq 0x48(%r15), %rdi
incl %ebx
movq (%rdi), %rax
movq (%rax), %rax
movq %r14, %rsi
movl %ebx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *%rax