LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: bummelbaerchen[P]e3dc/RscpExampleMain.cpp
// Function: processReceiveBuffer(unsigned char const*, int)
static int processReceiveBuffer(const unsigned char * ucBuffer, int iLength)
{
    RscpProtocol protocol;
    SRscpFrame frame;

    int iResult = protocol.parseFrame(ucBuffer, iLength, &frame);
    if(iResult < 0) {
        // check if frame length error occured
        // in that case the full frame length was not received yet
        // and the receive function must get more data
        if(iResult == RSCP::ERR_INVALID_FRAME_LENGTH) {
            return 0;
        }
        // otherwise a not recoverable error occured and the connection can be closed
        else {
            return iResult;
        }
    }

    int iProcessedBytes = iResult;

// Auslesen Zeitstempel aus dem Frame von der E3DC und ausgeben
//    time_t t;
//    struct tm * ts;
    
      tE3DC = frame.header.timestamp.seconds;
//    ts = localtime(&tE3DC);
    
//    printf("E3DC Zeit: %s", asctime(ts));

    

    // process each SRscpValue struct seperately
    for(unsigned int i=0; i < frame.data.size(); i++) {
        handleResponseValue(&protocol, &frame.data[i]);
    }

    // destroy frame data and free memory
    protocol.destroyFrameData(frame);

    // returned processed amount of bytes
    return iProcessedBytes;
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xadf0
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xaca0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x88(%rsp), %rsi
movl 0x84(%rsp), %eax
movl %eax, 0x38(%rsp)
leaq 0x38(%rsp), %rdx
callq 0xbc40
movl %eax, 0x1c(%rsp)
jmp 0x8c21
movl 0x1c(%rsp), %eax
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jge 0x8c8e
cmpl $-0x5, 0x3c(%rsp)
jne 0x8c76
movl $0x0, 0x94(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0x8d1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xacf0
leaq 0x78(%rsp), %rdi
callq 0xae10
jmp 0x8d41
movl 0x3c(%rsp), %eax
movl %eax, 0x94(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0x8d1e
movl 0x3c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x44(%rsp), %rax
movq %rax, 0x1db4e(%rip)     # 0x267f0
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
addq $0x18, %rdi
callq 0x9240
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x8cfa
leaq 0x58(%rsp), %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x9260
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
callq 0x4f10
jmp 0x8ceb
jmp 0x8ced
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x8caa
leaq 0x78(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xacc0
jmp 0x8d0b
movl 0x24(%rsp), %eax
movl %eax, 0x94(%rsp)
movl $0x1, 0x28(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xacf0
leaq 0x78(%rsp), %rdi
callq 0xae10
movl 0x94(%rsp), %eax
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x2300
nopl (%rax,%rax)
// File: bummelbaerchen[P]e3dc/RscpProtocol.cpp
// Function: RscpProtocol::setHeaderTimestamp(SRscpFrame*)
bool RscpProtocol::setHeaderTimestamp(SRscpFrame *frame) {
	// sanity check
	if(frame == NULL) {
		return false;
	}

	bool bTimeSet = false;
	// get linux timestamp
	struct timeval timeVal;
	gettimeofday(&timeVal, NULL);
	// set frame timestamp
	frame->header.timestamp.seconds = timeVal.tv_sec;
	frame->header.timestamp.nanoseconds = timeVal.tv_usec * 1000;

	return bTimeSet;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xae6d
movb $0x0, 0x37(%rsp)
jmp 0xaeab
movb $0x0, 0x1f(%rsp)
leaq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22b0
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x4(%rax)
imulq $0x3e8, 0x10(%rsp), %rax # imm = 0x3E8
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movb 0x1f(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: bummelbaerchen[P]e3dc/AES.cpp
// Function: (anonymous namespace)::SubByte(unsigned int)
uint32_t SubByte(uint32_t data)
	{ // does the SBox on this 4 byte data
	unsigned result = 0;
	result = byte_sub[data>>24];
	result <<= 8;
	result |= byte_sub[(data>>16)&255];
	result <<= 8;
	result |= byte_sub[(data>>8)&255];
	result <<= 8;
	result |= byte_sub[data&255];
	return result;
	}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
movl -0x4(%rsp), %eax
shrl $0x18, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x1cb72(%rip), %rax     # 0x2abc0
movzbl (%rax,%rcx), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
shll $0x8, %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x1cb48(%rip), %rax     # 0x2abc0
movzbl (%rax,%rcx), %eax
orl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
shll $0x8, %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x1cb1a(%rip), %rax     # 0x2abc0
movzbl (%rax,%rcx), %eax
orl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
shll $0x8, %eax
movl %eax, -0x8(%rsp)
movl -0x4(%rsp), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x1caef(%rip), %rax     # 0x2abc0
movzbl (%rax,%rcx), %eax
orl -0x8(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: bummelbaerchen[P]e3dc/AES.cpp
// Function: AES::Encrypt(unsigned char const*, unsigned char*, unsigned int, AES::BlockMode)
void AES::Encrypt(const unsigned char * datain, unsigned char * dataout, uint32_t numBlocks, BlockMode mode)
	{
	if (0 == numBlocks)
		return;
	unsigned int blocksize = Nb*4;
	switch (mode)
		{
		case ECB :
			while (numBlocks)
				{
				EncryptBlock(datain,dataout);
				datain   += blocksize;
				dataout  += blocksize;
				--numBlocks;
				}
			break;
		case CBC :
			{
			unsigned char buffer[32]; // max blocksize
			memcpy(buffer,iv,blocksize); // clear out - todo - allow setting the Initialization Vector - needed for security
			while (numBlocks)
				{
				for (unsigned int pos = 0; pos < blocksize; ++pos)
					buffer[pos] ^= *datain++;
				EncryptBlock(buffer,dataout);
				memcpy(buffer,dataout,blocksize);
				dataout  += blocksize;
				--numBlocks;
				}
			}
			break;
		default :
			break;
		}
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl %r8d, 0x48(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpl 0x4c(%rsp), %eax
jne 0x16c53
jmp 0x16d8b
movq 0x10(%rsp), %rax
movl (%rax), %eax
shll $0x2, %eax
movl %eax, 0x44(%rsp)
movl 0x48(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x16c7d
jmp 0x16c6f
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x16cd2
jmp 0x16d89
jmp 0x16c7f
cmpl $0x0, 0x4c(%rsp)
je 0x16ccd
movq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0xe280
movl 0x44(%rsp), %ecx
movq 0x58(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x58(%rsp)
movl 0x44(%rsp), %ecx
movq 0x50(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movl 0x4c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x16c7f
jmp 0x16d8b
movq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdi
addq $0x1ec, %rsi            # imm = 0x1EC
movl 0x44(%rsp), %eax
movl %eax, %edx
callq 0x2160
cmpl $0x0, 0x4c(%rsp)
je 0x16d87
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jae 0x16d3b
movq 0x58(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rsp)
movzbl (%rax), %edx
movl 0x1c(%rsp), %eax
movzbl 0x20(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x20(%rsp,%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x16d01
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0xe280
leaq 0x20(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x44(%rsp), %eax
movl %eax, %edx
callq 0x2160
movl 0x44(%rsp), %ecx
movq 0x50(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movl 0x4c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x16cee
jmp 0x16d8b
jmp 0x16d8b
addq $0x68, %rsp
retq
// File: bummelbaerchen[P]e3dc/SocketConnection.cpp
// Function: SocketSendData(int, unsigned char const*, int)
int SocketSendData(int iSocket, const unsigned char * ucBuffer, int iLength)
{
    // sanity check
    if(iSocket < 0) {
        return iSocket;
    }

    int iSentBytes = 0;
    while(iLength)
    {
        long result = send(iSocket, ucBuffer, iLength, 0);
        if(result <= 0) {
            return -1;
        }
        iSentBytes += result;
        ucBuffer += result;
        iLength -= result;
    }
    return iSentBytes;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
cmpl $0x0, 0x20(%rsp)
jge 0x20e22
movl 0x20(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x20e98
movl $0x0, 0x10(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x20e90
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
xorl %ecx, %ecx
callq 0x20f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jg 0x20e5d
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x20e98
movq 0x8(%rsp), %rcx
movslq 0x10(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movslq 0x14(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x14(%rsp)
jmp 0x20e2a
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::set_dimensions(int, int)
void Image::set_dimensions(int width, int height){
    int scale = anti_alias + 1;
    orig_width = width;
    orig_height = height;
    image_width = width * scale;
    image_height = height * scale;
    red_pixels = Eigen::MatrixXd();
    green_pixels = Eigen::MatrixXd();
    blue_pixels = Eigen::MatrixXd();
    red_pixels.conservativeResize(image_width, image_height);
    green_pixels.conservativeResize(image_width, image_height);
    blue_pixels.conservativeResize(image_width, image_height);

    t_values = Eigen::MatrixXd();
    t_values.conservativeResize(image_width, image_height);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movl %edx, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x74(%rsp)
movl 0x7c(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl 0x78(%rsp), %ecx
movl %ecx, 0xc(%rax)
movl 0x7c(%rsp), %ecx
imull 0x74(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl 0x78(%rsp), %ecx
imull 0x74(%rsp), %ecx
movl %ecx, 0x14(%rax)
leaq 0x58(%rsp), %rdi
callq 0x6060
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x58(%rsp), %rsi
callq 0x60c0
leaq 0x58(%rsp), %rdi
callq 0x60b0
leaq 0x40(%rsp), %rdi
callq 0x6060
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
leaq 0x40(%rsp), %rsi
callq 0x60c0
leaq 0x40(%rsp), %rdi
callq 0x60b0
leaq 0x28(%rsp), %rdi
callq 0x6060
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x28(%rsp), %rsi
callq 0x60c0
leaq 0x28(%rsp), %rdi
callq 0x60b0
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x18, %rdi
movslq 0x10(%rax), %rsi
movslq 0x14(%rax), %rdx
callq 0x6100
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movslq 0x10(%rax), %rsi
movslq 0x14(%rax), %rdx
callq 0x6100
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x48, %rdi
movslq 0x10(%rax), %rsi
movslq 0x14(%rax), %rdx
callq 0x6100
leaq 0x10(%rsp), %rdi
callq 0x6060
movq 0x8(%rsp), %rdi
addq $0xa8, %rdi
leaq 0x10(%rsp), %rsi
callq 0x60c0
leaq 0x10(%rsp), %rdi
callq 0x60b0
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0xa8, %rdi
movslq 0x10(%rax), %rsi
movslq 0x14(%rax), %rdx
callq 0x6100
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::Image(Image const&)
Image::Image(const Image&old_image){
    anti_alias = old_image.get_aa();
    int width = old_image.get_width();
    int height = old_image.get_height();
    set_dimensions(width, height);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
movb $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movl $0x0, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
addq $0x18, %rdi
movq %rdi, 0x38(%rsp)
callq 0x6060
movq 0x40(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x48(%rsp)
callq 0x6060
jmp 0x4f11
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
movq %rdi, 0x30(%rsp)
callq 0x6060
jmp 0x4f26
movq 0x40(%rsp), %rdi
addq $0x60, %rdi
movq %rdi, 0x28(%rsp)
callq 0x6060
jmp 0x4f3b
movq 0x40(%rsp), %rdi
addq $0x78, %rdi
movq %rdi, 0x20(%rsp)
callq 0x6060
jmp 0x4f50
movq 0x40(%rsp), %rdi
addq $0x90, %rdi
movq %rdi, 0x18(%rsp)
callq 0x6060
jmp 0x4f68
movq 0x40(%rsp), %rdi
addq $0xa8, %rdi
movq %rdi, 0x10(%rsp)
callq 0x6060
jmp 0x4f80
movq 0x68(%rsp), %rdi
callq 0x50b0
movl %eax, 0xc(%rsp)
jmp 0x4f90
movq 0x40(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%rax)
movq 0x68(%rsp), %rdi
callq 0x50c0
movl %eax, 0x8(%rsp)
jmp 0x4fac
movl 0x8(%rsp), %eax
movl %eax, 0x58(%rsp)
movq 0x68(%rsp), %rdi
callq 0x50d0
movl %eax, 0x4(%rsp)
jmp 0x4fc4
movq 0x40(%rsp), %rdi
movl 0x4(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x58(%rsp), %esi
movl 0x54(%rsp), %edx
callq 0x4d40
jmp 0x4fe0
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x5095
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x508b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x5081
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x5077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x506d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x5063
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
callq 0x60b0
movq 0x18(%rsp), %rdi
callq 0x60b0
movq 0x20(%rsp), %rdi
callq 0x60b0
movq 0x28(%rsp), %rdi
callq 0x60b0
movq 0x30(%rsp), %rdi
callq 0x60b0
movq 0x48(%rsp), %rdi
callq 0x60b0
movq 0x38(%rsp), %rdi
callq 0x60b0
movq 0x60(%rsp), %rdi
callq 0x45e0
nopl (%rax)
// File: IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::apply_focus_blur()
void Image::apply_focus_blur(){
    post_red_pixels = Eigen::MatrixXd(red_pixels);
    post_green_pixels = Eigen::MatrixXd(green_pixels);
    post_blue_pixels = Eigen::MatrixXd(blue_pixels);

    for (int x=0; x<image_width; x++){
        for (int y=0; y<image_height; y++){
            int blur = get_pixel_blur(x, y);
            blur_pixel(x, y, blur);
        }
    }
    red_pixels = Eigen::MatrixXd(post_red_pixels);
    green_pixels = Eigen::MatrixXd(post_green_pixels);
    blue_pixels = Eigen::MatrixXd(post_blue_pixels);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x18, %rsi
leaq 0x98(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
leaq 0x98(%rsp), %rsi
callq 0x60c0
leaq 0x98(%rsp), %rdi
callq 0x60b0
movq 0x8(%rsp), %rsi
addq $0x30, %rsi
leaq 0x80(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
leaq 0x80(%rsp), %rsi
callq 0x60c0
leaq 0x80(%rsp), %rdi
callq 0x60b0
movq 0x8(%rsp), %rsi
addq $0x48, %rsi
leaq 0x68(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
leaq 0x68(%rsp), %rsi
callq 0x60c0
leaq 0x68(%rsp), %rdi
callq 0x60b0
movl $0x0, 0x64(%rsp)
movq 0x8(%rsp), %rcx
movl 0x64(%rsp), %eax
cmpl 0x10(%rcx), %eax
jge 0x5750
movl $0x0, 0x60(%rsp)
movq 0x8(%rsp), %rcx
movl 0x60(%rsp), %eax
cmpl 0x14(%rcx), %eax
jge 0x5741
movq 0x8(%rsp), %rdi
movl 0x64(%rsp), %esi
movl 0x60(%rsp), %edx
callq 0x5c60
movq 0x8(%rsp), %rdi
movl %eax, 0x5c(%rsp)
movl 0x64(%rsp), %esi
movl 0x60(%rsp), %edx
movl 0x5c(%rsp), %ecx
callq 0x5d60
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x56fa
jmp 0x5743
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x56e4
movq 0x8(%rsp), %rsi
addq $0x60, %rsi
leaq 0x40(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x40(%rsp), %rsi
callq 0x60c0
leaq 0x40(%rsp), %rdi
callq 0x60b0
movq 0x8(%rsp), %rsi
addq $0x78, %rsi
leaq 0x28(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
leaq 0x28(%rsp), %rsi
callq 0x60c0
leaq 0x28(%rsp), %rdi
callq 0x60b0
movq 0x8(%rsp), %rsi
addq $0x90, %rsi
leaq 0x10(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
leaq 0x10(%rsp), %rsi
callq 0x60c0
leaq 0x10(%rsp), %rdi
callq 0x60b0
addq $0xb8, %rsp
retq
nopl (%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::convert_255(double)
int Image::convert_255(double value){
    // Convert a 0-1 double value to 0-255 int value
    if (value > 1)
        value = 1;
    if (value < 0)
        value = 0;
    value = value * 255.0;
    return int(value);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd -0x10(%rsp), %xmm0
movsd 0x5746f(%rip), %xmm1    # 0x5d008
ucomisd %xmm1, %xmm0
jbe 0x5bad
movsd 0x57461(%rip), %xmm0    # 0x5d008
movsd %xmm0, -0x10(%rsp)
xorps %xmm0, %xmm0
ucomisd -0x10(%rsp), %xmm0
jbe 0x5bc1
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rsp)
movsd 0x57447(%rip), %xmm0    # 0x5d010
mulsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
cvttsd2si -0x10(%rsp), %eax
retq
nopl (%rax)
// File: IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::set_focus_blur(double, double, double)
void Image::set_focus_blur(double distance, double strength, double length){
    focus_distance = distance;
    focus_strength = strength;
    focus_length = length;
    focus_blur = true;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm2, -0x20(%rsp)
movq -0x8(%rsp), %rax
cvttsd2si -0x10(%rsp), %ecx
movl %ecx, 0xc0(%rax)
cvttsd2si -0x18(%rsp), %ecx
movl %ecx, 0xc4(%rax)
cvttsd2si -0x20(%rsp), %ecx
movl %ecx, 0xc8(%rax)
movb $0x1, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::get_pixel_blur(int, int)
int Image::get_pixel_blur(int index_x, int index_y){
    // Calculates how close to the focal center this pixel was found. Blur progressively from there
    // Returns blur_number, which represents the number of pixels out from center to average
    double blur_number = 0;
    double t_value = t_values(index_x, index_y);
    double dist_from_center = abs(focus_distance - t_value);
    if (dist_from_center > focus_length){
        double dist_into_blur = dist_from_center - focus_length;
        blur_number = dist_into_blur * focus_strength / 100;
        int max_blur = image_width / 50;
        if (blur_number > max_blur)
            blur_number = max_blur;
    }
    return (int) blur_number;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
addq $0xa8, %rdi
movslq 0x3c(%rsp), %rsi
movslq 0x38(%rsp), %rdx
callq 0x61c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, 0x28(%rsp)
cvtsi2sdl 0xc0(%rax), %xmm0
subsd 0x28(%rsp), %xmm0
callq 0x6540
movq 0x8(%rsp), %rax
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
cvtsi2sdl 0xc8(%rax), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5d4e
movq 0x8(%rsp), %rax
movsd 0x20(%rsp), %xmm0
cvtsi2sdl 0xc8(%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
cvtsi2sdl 0xc4(%rax), %xmm1
mulsd %xmm1, %xmm0
movsd 0x57303(%rip), %xmm1    # 0x5d018
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movl 0x10(%rax), %eax
movl $0x32, %ecx
cltd
idivl %ecx
movl %eax, 0x14(%rsp)
movsd 0x30(%rsp), %xmm0
cvtsi2sdl 0x14(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x5d4c
cvtsi2sdl 0x14(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x5d4e
cvttsd2si 0x30(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: IsaacLaw12[P]RayTracer/./src/Image.cpp
// Function: Image::get_anti_alias_val(int, int, int, Eigen::Matrix<double, -1, -1, 0, -1, -1>*)
double Image::get_anti_alias_val(int index_x, int index_y, int scale, Eigen::MatrixXd* cur_color){
    double pixel_total = 0;
    int count = 0;
    for (int x=index_x*scale; x<(index_x+1)*scale; x++){
        for (int y=index_y*scale; y<(index_y+1)*scale; y++){
           pixel_total += (*cur_color)(x, y);
           count++;
        }
    }
    return pixel_total / count;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0x2c(%rsp), %eax
imull 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl 0x2c(%rsp), %ecx
addl $0x1, %ecx
imull 0x24(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6048
movl 0x28(%rsp), %eax
imull 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl 0x28(%rsp), %ecx
addl $0x1, %ecx
imull 0x24(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6039
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
movslq 0x4(%rsp), %rdx
callq 0x61c0
movsd (%rax), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5fe9
jmp 0x603b
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x5fc8
movsd 0x10(%rsp), %xmm0
cvtsi2sdl 0xc(%rsp), %xmm1
divsd %xmm1, %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: IsaacLaw12[P]RayTracer/./Eigen/Eigen/src/Core/util/Memory.h
// Function: double* Eigen::internal::conditional_aligned_realloc_new_auto<double, true>(double*, unsigned long, unsigned long)
inline T* conditional_aligned_realloc_new_auto(T* pts, std::size_t new_size, std::size_t old_size)
{
  check_size_for_overflow<T>(new_size);
  check_size_for_overflow<T>(old_size);
  if(NumTraits<T>::RequireInitialization && (new_size < old_size))
    destruct_elements_of_array(pts+new_size, old_size-new_size);
  T *result = reinterpret_cast<T*>(conditional_aligned_realloc<Align>(reinterpret_cast<void*>(pts), sizeof(T)*new_size, sizeof(T)*old_size));
  if(NumTraits<T>::RequireInitialization && (new_size > old_size))
  {
    EIGEN_TRY
    {
      construct_elements_of_array(result+old_size, new_size-old_size);
    }
    EIGEN_CATCH(...)
    {
      conditional_aligned_free<Align>(result);
      EIGEN_THROW;
    }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, 0x30(%rsp)
jbe 0x6e23
callq 0x6d70
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movabsq $0x1fffffffffffffff, %rax # imm = 0x1FFFFFFFFFFFFFFF
cmpq %rax, 0x28(%rsp)
jbe 0x6e43
callq 0x6d70
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
shlq $0x3, %rsi
movq 0x10(%rsp), %rdx
shlq $0x3, %rdx
callq 0x6e70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: IsaacLaw12[P]RayTracer/./Eigen/Eigen/src/Core/util/Memory.h
// Function: Eigen::internal::aligned_realloc(void*, unsigned long, unsigned long)
inline void* aligned_realloc(void *ptr, std::size_t new_size, std::size_t old_size)
{
  EIGEN_UNUSED_VARIABLE(old_size);

  void *result;
#if (EIGEN_DEFAULT_ALIGN_BYTES==0) || EIGEN_MALLOC_ALREADY_ALIGNED
  result = std::realloc(ptr,new_size);
#else
  result = handmade_aligned_realloc(ptr,new_size,old_size);
#endif

  if (!result && new_size)
    throw_std_bad_alloc();

  return result;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x6ef0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4560
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x6ee6
cmpq $0x0, 0x18(%rsp)
je 0x6ee6
callq 0x6d70
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
// File: IsaacLaw12[P]RayTracer/./src/Camera.cpp
// Function: Camera::set_bounds(double, double, double, double)
void Camera::set_bounds(double x1, double y1, double x2, double y2){
    near_bounding_left = x1;
    near_bounding_bottom = y1;
    near_bounding_right = x2;
    near_bounding_top = y2;
 }

// Assembly:
movq %rdi, -0x8(%rsp)
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm2, -0x20(%rsp)
movsd %xmm3, -0x28(%rsp)
movq -0x8(%rsp), %rax
movsd -0x10(%rsp), %xmm0
movsd %xmm0, 0xa8(%rax)
movsd -0x18(%rsp), %xmm0
movsd %xmm0, 0xb8(%rax)
movsd -0x20(%rsp), %xmm0
movsd %xmm0, 0xb0(%rax)
movsd -0x28(%rsp), %xmm0
movsd %xmm0, 0xc0(%rax)
retq
nopl (%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/Camera.cpp
// Function: Camera::get_pixel_position(int, int)
Eigen::Vector3d Camera::get_pixel_position(int x_pixel, int y_pixel){

    double px = x_pixel / (pixel_width-1.0) * (near_bounding_right - near_bounding_left) + near_bounding_left;
    double py = y_pixel / (pixel_height-1.0) * (near_bounding_top - near_bounding_bottom) + near_bounding_bottom;

    Eigen::Vector3d pixpt = eye + (-1 * focal_length * z_axis) + (px * x_axis) + (py * y_axis);
    return pixpt;
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x210(%rsp)
movq %rsi, 0x208(%rsp)
movl %edx, 0x204(%rsp)
movl %ecx, 0x200(%rsp)
movq 0x208(%rsp), %rdx
movq %rdx, 0x8(%rsp)
cvtsi2sdl 0x204(%rsp), %xmm0
cvtsi2sdl (%rdx), %xmm1
movsd 0x53594(%rip), %xmm2    # 0x5d008
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0xb0(%rdx), %xmm2
subsd 0xa8(%rdx), %xmm2
movsd 0xa8(%rdx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x1f8(%rsp)
cvtsi2sdl 0x200(%rsp), %xmm0
cvtsi2sdl 0x4(%rdx), %xmm1
movsd 0x5354d(%rip), %xmm2    # 0x5d008
subsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd 0xc0(%rdx), %xmm2
subsd 0xb8(%rdx), %xmm2
movsd 0xb8(%rdx), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x1f0(%rsp)
movq %rdx, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movsd 0x54361(%rip), %xmm0    # 0x5de60
mulsd 0x98(%rdx), %xmm0
movsd %xmm0, 0x70(%rsp)
addq $0x80, %rdx
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xa310
movq (%rsp), %rsi
leaq 0xa0(%rsp), %rdi
leaq 0x78(%rsp), %rdx
callq 0xa2a0
movq 0x8(%rsp), %rdx
addq $0x50, %rdx
leaq 0x48(%rsp), %rdi
leaq 0x1f8(%rsp), %rsi
callq 0xa310
leaq 0xd8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xa3d0
movq 0x8(%rsp), %rdx
addq $0x68, %rdx
leaq 0x20(%rsp), %rdi
leaq 0x1f0(%rsp), %rsi
callq 0xa310
leaq 0x148(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0xa440
movq 0x10(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0xa4b0
movq 0x18(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
retq
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./Eigen/Eigen/src/Core/Dot.h
// Function: Eigen::MatrixBase<Eigen::Matrix<double, 3, 1, 0, 3, 1>>::normalized() const
EIGEN_STRONG_INLINE const typename MatrixBase<Derived>::PlainObject
MatrixBase<Derived>::normalized() const
{
  typedef typename internal::nested_eval<Derived,2>::type _Nested;
  _Nested n(derived());
  RealScalar z = n.squaredNorm();
  // NOTE: after extensive benchmarking, this conditional does not impact performance, at least on recent x86 CPU
  if(z>RealScalar(0))
    return n / numext::sqrt(z);
  else
    return n;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x8760
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0xbb70
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9e30
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
movapd %xmm0, 0x90(%rsp)
movapd 0x90(%rsp), %xmm0
movapd %xmm0, 0x80(%rsp)
movapd 0x80(%rsp), %xmm0
sqrtpd %xmm0, %xmm0
movapd %xmm0, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xc370
movq (%rsp), %rsi
movsd %xmm0, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xbbb0
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xbc70
jmp 0x9e3f
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xa4f0
movq 0x10(%rsp), %rax
addq $0xa8, %rsp
retq
nopl (%rax)
// File: IsaacLaw12[P]RayTracer/./src/Light.cpp
// Function: Light::Light(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Light::Light(std::string driver_line){
    // Light string: "light x_loc y_loc z_loc w r g b"
    std::stringstream driver(driver_line);
    double light_obj_doubles[8] = {};
    light_obj_doubles[7] = 0;
    std::string driver_type = "";
    driver >> driver_type;

    double temp = 0;
    int counter = 0;
    while (driver >> temp){
        light_obj_doubles[counter++] = temp;
    }
    if (counter < 7 || counter > 8){
        // The correct number of numbers were not found
        load_successful = false;
        return;
    }
    assign_values(light_obj_doubles);
}

// Assembly:
subq $0x248, %rsp            # imm = 0x248
movq %rsi, 0x18(%rsp)
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq 0x240(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x0, (%rdi)
addq $0x10, %rdi
callq 0x11e20
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x11e20
movq 0x10(%rsp), %rax
movb $0x1, 0x40(%rax)
movl $0x10, %edi
movl $0x8, %esi
callq 0x11e40
movq 0x18(%rsp), %rsi
movl %eax, %edx
leaq 0xb0(%rsp), %rdi
callq 0x4520
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
movaps %xmm0, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movq $0x0, 0xa8(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x45f0
movq 0x20(%rsp), %rdx
leaq 0x503b5(%rip), %rsi     # 0x61dfe
leaq 0x50(%rsp), %rdi
callq 0x11e60
jmp 0x11a55
leaq 0x4f(%rsp), %rdi
callq 0x43c0
leaq 0xb0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x4450
jmp 0x11a73
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x42e0
movq %rax, 0x8(%rsp)
jmp 0x11a9d
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x4440
movb %al, 0x7(%rsp)
jmp 0x11ab7
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x11ac1
jmp 0x11b12
movsd 0x30(%rsp), %xmm0
movl 0x2c(%rsp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x2c(%rsp)
cltq
movsd %xmm0, 0x70(%rsp,%rax,8)
jmp 0x11a84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x43c0
jmp 0x11b6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4200
jmp 0x11b6b
cmpl $0x7, 0x2c(%rsp)
jl 0x11b20
cmpl $0x8, 0x2c(%rsp)
jle 0x11b33
movq 0x10(%rsp), %rax
movb $0x0, 0x40(%rax)
movl $0x1, 0x28(%rsp)
jmp 0x11b4c
movq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x11b90
jmp 0x11b44
movl $0x0, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x4200
leaq 0xb0(%rsp), %rdi
callq 0x4290
addq $0x248, %rsp            # imm = 0x248
retq
leaq 0xb0(%rsp), %rdi
callq 0x4290
movq 0x40(%rsp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/Light.cpp
// Function: Light::assign_values(double*)
void Light::assign_values(double spec_nums[]){
    double x_cord = spec_nums[0];
    double y_cord = spec_nums[1];
    double z_cord = spec_nums[2];
    w_value = spec_nums[3];
    double red_color = spec_nums[4];
    double green_color = spec_nums[5];
    double blue_color = spec_nums[6];
    lighting_group = spec_nums[7];
    light_pos << x_cord, y_cord, z_cord;
    if (w_value == 0){
        light_pos = 1000000000 * light_pos;
    }
    light_color << red_color, green_color, blue_color;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rsi
movq %rsi, 0x10(%rsp)
movq 0xd8(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0xc8(%rsp)
movq 0xd8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0xc0(%rsp)
movq 0xd8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, 0x8(%rsi)
movq 0xd8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, 0xb8(%rsp)
movq 0xd8(%rsp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, 0xb0(%rsp)
movq 0xd8(%rsp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, 0xa8(%rsp)
movq 0xd8(%rsp), %rax
cvttsd2si 0x38(%rax), %eax
movl %eax, (%rsi)
addq $0x10, %rsi
leaq 0x88(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0xd0(%rsp), %rdx
callq 0x11f20
movq 0x18(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x11f60
movq %rax, 0x20(%rsp)
jmp 0x11c8f
movq 0x20(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x11f60
jmp 0x11ca3
leaq 0x88(%rsp), %rdi
callq 0x120e0
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x11d1a
jp 0x11d1a
movq 0x10(%rsp), %rdx
movl $0x3b9aca00, 0x4c(%rsp) # imm = 0x3B9ACA00
addq $0x10, %rdx
leaq 0x50(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x12100
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x50(%rsp), %rsi
callq 0x121c0
jmp 0x11d1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x120e0
jmp 0x11d92
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0xb8(%rsp), %rdx
callq 0x11f20
movq (%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x11f60
movq %rax, 0x8(%rsp)
jmp 0x11d51
movq 0x8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x11f60
jmp 0x11d65
leaq 0x28(%rsp), %rdi
callq 0x120e0
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x120e0
movq 0x80(%rsp), %rdi
callq 0x45e0
nop
// File: IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: create_directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void create_directory(std::string save_folder){
    //   ***** THIS USES LINUX SYSTEM CALLS, TO RUN ON WINDOWS REWRITE ******
    // Clear the saved render folder of previous contents
    char remove_command[80] = "rm -r ";
    strcat(remove_command, save_folder.c_str());
    if (0 == system(remove_command)){
        // The result of this command does not need to be handled as the following system command
        //   properly alerts to the same potential problem set.
        ;
    }

    char create_command[80] = "mkdir ";
    strcat(create_command, save_folder.c_str());
    if (0 == system(create_command)){
        std::cout << save_folder << " directory created successfully\n";
    } else{
        std::cout << save_folder << " directory creation failed\n";
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0xc0(%rsp)
leaq 0x70(%rsp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x41a0
movq 0x10(%rsp), %rdi
movb $0x72, 0x70(%rsp)
movb $0x6d, 0x71(%rsp)
movb $0x20, 0x72(%rsp)
movb $0x2d, 0x73(%rsp)
movb $0x72, 0x74(%rsp)
movb $0x20, 0x75(%rsp)
leaq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x4120
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x4600
leaq 0x70(%rsp), %rdi
callq 0x4310
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x12cc8
jmp 0x12cc8
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x41a0
movq 0x10(%rsp), %rdi
movb $0x6d, 0x20(%rsp)
movb $0x6b, 0x21(%rsp)
movb $0x64, 0x22(%rsp)
movb $0x69, 0x23(%rsp)
movb $0x72, 0x24(%rsp)
movb $0x20, 0x25(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x4120
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4600
leaq 0x20(%rsp), %rdi
callq 0x4310
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x12d4c
movq 0x10(%rsp), %rsi
movq 0x8828a(%rip), %rdi     # 0x9afc0
callq 0x4340
movq %rax, %rdi
leaq 0x4f01f(%rip), %rsi     # 0x61d64
callq 0x4360
jmp 0x12d6c
movq 0x10(%rsp), %rsi
movq 0x88268(%rip), %rdi     # 0x9afc0
callq 0x4340
movq %rax, %rdi
leaq 0x4f01e(%rip), %rsi     # 0x61d85
callq 0x4360
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: parse_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int&)
int parse_int(std::string str, int &status){
    int result = 0;
    try {
        result = stoi(str);
    }
    catch(std::invalid_argument& e){
        status = 1;
    }
    return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x13b80
movl %eax, 0x4(%rsp)
jmp 0x12daa
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x12dee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x12df7
movq 0x18(%rsp), %rdi
callq 0x4110
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl $0x1, (%rax)
callq 0x4550
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: parse_folder_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string parse_folder_name(std::string name){
    std::string result = "";
    for (auto c: name){
        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')){
            result += c;
        }
    }
    return result;
}

// Assembly:
subq $0x68, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
leaq 0x56(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x45f0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x4efaa(%rip), %rsi     # 0x61dfe
callq 0x11e60
jmp 0x12e5b
leaq 0x56(%rsp), %rdi
callq 0x43c0
movq (%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4320
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x41c0
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x13bd0
testb $0x1, %al
jne 0x12ea4
jmp 0x12f34
leaq 0x30(%rsp), %rdi
callq 0x13c10
movb (%rax), %al
movb %al, 0x27(%rsp)
movsbl 0x27(%rsp), %eax
cmpl $0x61, %eax
jl 0x12ec8
movsbl 0x27(%rsp), %eax
cmpl $0x7a, %eax
jle 0x12edc
movsbl 0x27(%rsp), %eax
cmpl $0x41, %eax
jl 0x12f23
movsbl 0x27(%rsp), %eax
cmpl $0x5a, %eax
jg 0x12f23
movq 0x10(%rsp), %rdi
movsbl 0x27(%rsp), %esi
callq 0x4210
jmp 0x12eed
jmp 0x12f23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x56(%rsp), %rdi
callq 0x43c0
jmp 0x12f54
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x4200
jmp 0x12f54
jmp 0x12f25
leaq 0x30(%rsp), %rdi
callq 0x13c20
jmp 0x12e8c
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x12f4a
movq 0x10(%rsp), %rdi
callq 0x4200
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x45e0
nop
// File: IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: image_name(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string image_name(int frame_number, std::string save_folder){
    std::string padded_frame_num = std::to_string(frame_number);
    while (padded_frame_num.size() < 4){
        padded_frame_num = "0" + padded_frame_num;
    }
    std::string result = save_folder + "/output" + padded_frame_num + ".ppm";
    return result;
}

// Assembly:
subq $0xc8, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq %rdx, 0xb0(%rsp)
movl 0xbc(%rsp), %esi
leaq 0x90(%rsp), %rdi
callq 0x13cf0
leaq 0x90(%rsp), %rdi
callq 0x4260
cmpq $0x4, %rax
jae 0x134d3
leaq 0x4ea79(%rip), %rsi     # 0x61f07
leaq 0x70(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x13e30
jmp 0x134a2
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x4420
leaq 0x70(%rsp), %rdi
callq 0x4200
jmp 0x13474
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x1359b
movq 0x8(%rsp), %rsi
movb $0x0, 0x63(%rsp)
leaq 0x4ea25(%rip), %rdx     # 0x61f09
leaq 0x20(%rsp), %rdi
callq 0x14000
jmp 0x134f0
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x13fb0
jmp 0x13509
movq 0x10(%rsp), %rdi
leaq 0x4e9fc(%rip), %rdx     # 0x61f11
leaq 0x40(%rsp), %rsi
callq 0x13f60
jmp 0x13521
leaq 0x40(%rsp), %rdi
callq 0x4200
leaq 0x20(%rsp), %rdi
callq 0x4200
movb $0x1, 0x63(%rsp)
testb $0x1, 0x63(%rsp)
jne 0x13581
jmp 0x13577
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x1356b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x4200
leaq 0x20(%rsp), %rdi
callq 0x4200
jmp 0x1359b
movq 0x10(%rsp), %rdi
callq 0x4200
leaq 0x90(%rsp), %rdi
callq 0x4200
movq 0x18(%rsp), %rax
addq $0xc8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x4200
movq 0x68(%rsp), %rdi
callq 0x45e0
nopw %cs:(%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: multi_thread_render(RenderImage&, int)
void multi_thread_render(RenderImage &ri, int number_threads){
    std::vector<std::thread> render_threads;
    for (int i=0; i<number_threads; i++)
        render_threads.push_back(std::thread(&RenderImage::render_tiles, &ri));

    for (std::thread & t : render_threads)
        t.join();
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x14090
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
cmpl 0x7c(%rsp), %eax
jge 0x13680
leaq 0x1cf36(%rip), %rax     # 0x30530
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x140d0
jmp 0x1362b
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x140a0
jmp 0x1363c
leaq 0x50(%rsp), %rdi
callq 0x141a0
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x135e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x136f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x141a0
jmp 0x136f8
leaq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x141c0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x141f0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x14220
testb $0x1, %al
jne 0x136bd
jmp 0x136e6
leaq 0x18(%rsp), %rdi
callq 0x14260
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x4590
jmp 0x136d8
jmp 0x136da
leaq 0x18(%rsp), %rdi
callq 0x14270
jmp 0x136a8
leaq 0x60(%rsp), %rdi
callq 0x14290
addq $0x88, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x14290
movq 0x30(%rsp), %rdi
callq 0x45e0
nopl (%rax)
// File: IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: render_scene(Scene&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void render_scene(Scene &sc, int number_threads, std::string save_folder){
    RenderImage ri = RenderImage(&sc);
    while (sc.advance_frame()){
        ri.reset();
        if (number_threads > 1)
            multi_thread_render(ri, number_threads);
        else
            ri.render_tiles();
        ri.save_image(image_name(sc.get_current_frame(), save_folder));
    }
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdx, 0x10(%rsp)
movq %rdi, 0x100(%rsp)
movl %esi, 0xfc(%rsp)
movq %rdx, 0xf0(%rsp)
movq 0x100(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x301b0
movq 0x100(%rsp), %rdi
callq 0x3f720
movb %al, 0xf(%rsp)
jmp 0x13758
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x13765
jmp 0x13848
leaq 0x68(%rsp), %rdi
callq 0x30230
jmp 0x13771
cmpl $0x1, 0xfc(%rsp)
jle 0x137a3
movl 0xfc(%rsp), %esi
leaq 0x68(%rsp), %rdi
callq 0x135c0
jmp 0x1378e
jmp 0x137b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1385a
leaq 0x68(%rsp), %rdi
callq 0x30530
jmp 0x137af
jmp 0x137b1
movq 0x100(%rsp), %rdi
callq 0x3f680
movl %eax, 0x8(%rsp)
jmp 0x137c4
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x4130
jmp 0x137d5
movl 0x8(%rsp), %esi
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x13430
jmp 0x137ea
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x30460
jmp 0x137fb
leaq 0x38(%rsp), %rdi
callq 0x4200
leaq 0x18(%rsp), %rdi
callq 0x4200
jmp 0x13745
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1383c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4200
leaq 0x18(%rsp), %rdi
callq 0x4200
jmp 0x1385a
leaq 0x68(%rsp), %rdi
callq 0x142f0
addq $0x108, %rsp            # imm = 0x108
retq
leaq 0x68(%rsp), %rdi
callq 0x142f0
movq 0x60(%rsp), %rdi
callq 0x45e0
nop
// File: IsaacLaw12[P]RayTracer/./src/raytracer.cpp
// Function: main
int main(int argc, char*argv[]){
    int number_threads = 1;
    std::string driver_file = "";
    std::string save_folder = "";
    int valid_args = parse_args(argc, argv, number_threads, driver_file, save_folder);
    if (valid_args != 0){
        return valid_args;
    }

    create_directory(save_folder);
    Scene sc(driver_file);
    render_scene(sc, number_threads, save_folder);
    return 0;
}

// Assembly:
subq $0x338, %rsp            # imm = 0x338
movl $0x0, 0x334(%rsp)
movl %edi, 0x330(%rsp)
movq %rsi, 0x328(%rsp)
movl $0x1, 0x324(%rsp)
leaq 0x2ff(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x45f0
movq 0x10(%rsp), %rdx
leaq 0x4e544(%rip), %rsi     # 0x61dfe
leaq 0x300(%rsp), %rdi
callq 0x11e60
jmp 0x138c9
leaq 0x2ff(%rsp), %rdi
callq 0x43c0
leaq 0x2c7(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x45f0
movq 0x8(%rsp), %rdx
leaq 0x4e50a(%rip), %rsi     # 0x61dfe
leaq 0x2c8(%rsp), %rdi
callq 0x11e60
jmp 0x13903
leaq 0x2c7(%rsp), %rdi
callq 0x43c0
movl 0x330(%rsp), %edi
movq 0x328(%rsp), %rsi
leaq 0x324(%rsp), %rdx
leaq 0x300(%rsp), %rcx
leaq 0x2c8(%rsp), %r8
callq 0x12f60
movl %eax, 0x4(%rsp)
jmp 0x13942
movl 0x4(%rsp), %eax
movl %eax, 0x2c0(%rsp)
cmpl $0x0, 0x2c0(%rsp)
je 0x139de
movl 0x2c0(%rsp), %eax
movl %eax, 0x334(%rsp)
movl $0x1, 0x2bc(%rsp)
jmp 0x13b27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2f0(%rsp)
movl %eax, 0x2ec(%rsp)
leaq 0x2ff(%rsp), %rdi
callq 0x43c0
jmp 0x13b6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2f0(%rsp)
movl %eax, 0x2ec(%rsp)
leaq 0x2c7(%rsp), %rdi
callq 0x43c0
jmp 0x13b5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2f0(%rsp)
movl %eax, 0x2ec(%rsp)
jmp 0x13b50
leaq 0x298(%rsp), %rdi
leaq 0x2c8(%rsp), %rsi
callq 0x4130
jmp 0x139f5
leaq 0x298(%rsp), %rdi
callq 0x12c50
jmp 0x13a04
leaq 0x298(%rsp), %rdi
callq 0x4200
leaq 0x38(%rsp), %rdi
leaq 0x300(%rsp), %rsi
callq 0x4130
jmp 0x13a25
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3eca0
jmp 0x13a36
leaq 0x38(%rsp), %rdi
callq 0x4200
movl 0x324(%rsp), %eax
movl %eax, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x2c8(%rsp), %rsi
callq 0x4130
jmp 0x13a5e
movl (%rsp), %esi
leaq 0x58(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x13710
jmp 0x13a72
leaq 0x18(%rsp), %rdi
callq 0x4200
movl $0x0, 0x334(%rsp)
movl $0x1, 0x2bc(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x14310
jmp 0x13b27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2f0(%rsp)
movl %eax, 0x2ec(%rsp)
leaq 0x298(%rsp), %rdi
callq 0x4200
jmp 0x13b50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2f0(%rsp)
movl %eax, 0x2ec(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x4200
jmp 0x13b50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2f0(%rsp)
movl %eax, 0x2ec(%rsp)
jmp 0x13b1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x2f0(%rsp)
movl %eax, 0x2ec(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4200
leaq 0x58(%rsp), %rdi
callq 0x14310
jmp 0x13b50
leaq 0x2c8(%rsp), %rdi
callq 0x4200
leaq 0x300(%rsp), %rdi
callq 0x4200
movl 0x334(%rsp), %eax
addq $0x338, %rsp            # imm = 0x338
retq
leaq 0x2c8(%rsp), %rdi
callq 0x4200
leaq 0x300(%rsp), %rdi
callq 0x4200
movq 0x2f0(%rsp), %rdi
callq 0x45e0
nopw (%rax,%rax)
// File: IsaacLaw12[P]RayTracer/./src/AnimatedObject.cpp
// Function: AnimatedObject::AnimatedObject(Model*)
AnimatedObject::AnimatedObject(Model* animated_asset){
     original_obj = animated_asset;
     current_obj = new Model(*original_obj);
     animation_file = animated_asset->get_animation_file();
     load_animation();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x84029(%rip), %rcx     # 0x9ac08
movq %rcx, (%rax)
movl $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, 0x20(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x45f0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x4b1ec(%rip), %rsi     # 0x61dfe
callq 0x11e60
jmp 0x16c19
leaq 0x67(%rsp), %rdi
callq 0x43c0
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x8(%rsp)
callq 0x17910
movq 0x18(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, 0x48(%rax)
movl $0x258, %edi            # imm = 0x258
callq 0x4370
movq %rax, 0x10(%rsp)
jmp 0x16c55
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rsi
callq 0x1ab00
jmp 0x16c6a
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x50(%rax)
movq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x1bde0
jmp 0x16c89
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
leaq 0x30(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x4420
movq (%rsp), %rdi
callq 0x4200
movq 0x18(%rsp), %rdi
callq 0x16d20
jmp 0x16cb5
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x43c0
jmp 0x16d15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x16d01
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
movl $0x258, %esi            # imm = 0x258
callq 0x4380
movq 0x8(%rsp), %rdi
callq 0x11540
movq 0x20(%rsp), %rdi
callq 0x4200
movq 0x58(%rsp), %rdi
callq 0x45e0
nop