LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::~UdpSocket()
UdpSocket::~UdpSocket(){
#ifdef LINUX
    close(fd_);
#else
    closesocket(fd_);
#endif

#ifdef ASYNC_UDP
    if(event_)
        event_free(event_);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x58b5(%rip), %rcx      # 0xad80
movq %rcx, (%rax)
movl 0x1003c(%rax), %edi
callq 0x2470
jmp 0x54db
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x54f7
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x23e0
jmp 0x54f5
jmp 0x54f7
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x5b10
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x2dd0
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::Send(char*, int)
int UdpSocket::Send(char* buf, int len){
	int result = sendto(fd_, buf, len, 0, (sockaddr*)&remote_addr_, sizeof(remote_addr_));
	if (result < 0){
		perror("udp send\n");
	}
    return result;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %r8
movl 0x1003c(%r8), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
addq $0x10040, %r8           # imm = 0x10040
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x2060
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x55bf
leaq 0x1df1(%rip), %rdi      # 0x73ab
callq 0x2230
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::SendTo(char*, int, char const*, unsigned short)
int UdpSocket::SendTo(char* buf, int len, const char* dst_ip, uint16_t dst_port){
	struct sockaddr_in sock_addr;
	sock_addr.sin_family = AF_INET;
	sock_addr.sin_port = htons(dst_port);
	sock_addr.sin_addr.s_addr = inet_addr(dst_ip);
	int result = sendto(fd_, buf, len, 0, (sockaddr*)&sock_addr, sizeof(sockaddr));
	if (result < 0){
		perror("udp send\n");
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movw $0x2, -0x34(%rbp)
movzwl -0x22(%rbp), %edi
callq 0x2050
movw %ax, -0x32(%rbp)
movq -0x20(%rbp), %rdi
callq 0x22d0
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, -0x30(%rbp)
movl 0x1003c(%rax), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
xorl %ecx, %ecx
leaq -0x34(%rbp), %r8
movl $0x10, %r9d
callq 0x2060
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0x5650
leaq 0x1d60(%rip), %rdi      # 0x73ab
callq 0x2230
movl -0x38(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::SendTo(char*, int, sockaddr_in const&)
int UdpSocket::SendTo(char* buf, int len, const struct sockaddr_in& sock_addr){
	int result = sendto(fd_, buf, len, 0, (sockaddr*)&sock_addr, sizeof(sockaddr));
	if (result < 0){
		perror("udp send\n");
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x1003c(%rax), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
movq -0x20(%rbp), %r8
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x2060
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x56af
leaq 0x1d01(%rip), %rdi      # 0x73ab
callq 0x2230
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::Recv(char*, int)
int UdpSocket::Recv(char* buf, int buf_len){
	struct sockaddr_in sock_addr;
#ifdef LINUX
	socklen_t addr_len = sizeof(sock_addr);
#else
	int addr_len = sizeof(sock_addr);
#endif
	int recv_bytes = recvfrom(fd_, buf, buf_len, 0, (sockaddr*)&sock_addr, &addr_len);
	if (recv_bytes < 0){
		perror("udp recv\n");
	}
    return recv_bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl $0x10, -0x28(%rbp)
movl 0x1003c(%rax), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
xorl %ecx, %ecx
leaq -0x24(%rbp), %r8
leaq -0x28(%rbp), %r9
callq 0x2210
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x5710
leaq 0x1caa(%rip), %rdi      # 0x73b5
callq 0x2230
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::RecvFrom(char*, int, unsigned int*, unsigned short*)
int UdpSocket::RecvFrom(char* buf, int buf_len, uint32_t* from_ip, uint16_t* from_port){
	struct sockaddr_in sock_addr;
#ifdef LINUX
	socklen_t addr_len = sizeof(sock_addr);
#else
	int addr_len = sizeof(sock_addr);
#endif
	int recv_bytes = recvfrom(fd_, buf, buf_len, 0, (sockaddr*)&sock_addr, &addr_len);
	if (recv_bytes < 0){
		perror("udp recv\n");
	}
	if (from_ip){
		*from_ip = ntohl(sock_addr.sin_addr.s_addr);
	}
	if (from_port){
		*from_port = ntohs(sock_addr.sin_port);
	}

	return recv_bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl $0x10, -0x3c(%rbp)
movl 0x1003c(%rax), %edi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
xorl %ecx, %ecx
leaq -0x38(%rbp), %r8
leaq -0x3c(%rbp), %r9
callq 0x2210
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jge 0x5778
leaq 0x1c42(%rip), %rdi      # 0x73b5
callq 0x2230
cmpq $0x0, -0x20(%rbp)
je 0x578f
movl -0x34(%rbp), %edi
callq 0x2350
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x57a9
movzwl -0x36(%rbp), %edi
callq 0x2450
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
movl -0x40(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/udp_socket.cpp
// Function: UdpSocket::WaitMsg(int, int*)
int UdpSocket::WaitMsg(int time_out, int *elapsed_time){
	const int MSG_IDLE = 0, MSG_ARRIVAL = 1;
	fd_set read_fds;
	FD_ZERO(&read_fds);
	FD_SET(fd_, &read_fds);
	struct timeval time_val;
	time_val.tv_sec = time_out / 1000;
	time_val.tv_usec = time_out % 1000 * 1000;
	int ret = select(fd_ + 1, &read_fds, NULL, NULL, &time_val);
	int result = MSG_IDLE;
	if (ret == -1){
		perror("udp select error\n");
		return result;
	}else if(ret == 0){
		//time out
		*elapsed_time = time_out;
	}else{
		if (FD_ISSET(fd_, &read_fds)){
			*elapsed_time = time_out - (time_val.tv_sec * 1000 + time_val.tv_usec / 1000);
			result = MSG_ARRIVAL;
		}
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x1, -0x28(%rbp)
leaq -0xa8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpq $0x10, %rax
jae 0x5839
movq -0xb8(%rbp), %rax
movl -0xac(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x5807
jmp 0x583b
movq -0xd8(%rbp), %rax
movl 0x1003c(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0xd8(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
movl 0x1003c(%rax), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0xa8(%rbp,%rax,8), %rcx
movq %rcx, -0xa8(%rbp,%rax,8)
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, -0xc8(%rbp)
movl -0x14(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movq -0xd8(%rbp), %rax
imull $0x3e8, %edx, %ecx      # imm = 0x3E8
movslq %ecx, %rcx
movq %rcx, -0xc0(%rbp)
movl 0x1003c(%rax), %edi
addl $0x1, %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xc8(%rbp), %r8
movq %rcx, %rdx
callq 0x2290
movl %eax, -0xcc(%rbp)
movl $0x0, -0xd0(%rbp)
cmpl $-0x1, -0xcc(%rbp)
jne 0x5910
leaq 0x1ac2(%rip), %rdi      # 0x73bf
callq 0x2230
movl -0xd0(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x59d8
cmpl $0x0, -0xcc(%rbp)
jne 0x5927
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
jmp 0x59cd
movq -0xd8(%rbp), %rax
movl 0x1003c(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0xd8(%rbp), %rax
movslq %ecx, %rcx
movq -0xa8(%rbp,%rcx,8), %rcx
movq %rcx, -0xe0(%rbp)
movl 0x1003c(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0xe0(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x59cb
movslq -0x14(%rbp), %rax
movq %rax, -0xe8(%rbp)
imulq $0x3e8, -0xc8(%rbp), %rcx # imm = 0x3E8
movq -0xc0(%rbp), %rax
movl $0x3e8, %esi            # imm = 0x3E8
cqto
idivq %rsi
movq %rax, %rdx
movq -0xe8(%rbp), %rax
addq %rdx, %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0xd0(%rbp)
jmp 0x59cd
jmp 0x59cf
movl -0xd0(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: gtarcoder[P]libevent_utils/utils.cpp
// Function: InitSocketAddr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned short, sockaddr_in*)
void InitSocketAddr(std::string& ip, uint16_t port, sockaddr_in* addr){
	memset((char*)addr, 0, sizeof(sockaddr_in));
	addr->sin_family = AF_INET;
	addr->sin_port = htons(port);
#ifndef LINUX
	addr->sin_addr.S_un.S_addr = inet_addr(ip.c_str());
#else
	addr->sin_addr.s_addr = inet_addr(ip.c_str());
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2180
movq -0x18(%rbp), %rax
movw $0x2, (%rax)
movzwl -0xa(%rbp), %edi
callq 0x2050
movw %ax, %cx
movq -0x18(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x8(%rbp), %rdi
callq 0x2130
movq %rax, %rdi
callq 0x22d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/utils.cpp
// Function: SetNonBlock(int)
int SetNonBlock(int fd){
	int flags;
	flags = fcntl(fd, F_GETFL);
	if (flags < 0) return flags;
	flags |= O_NONBLOCK;
	if (fcntl(fd, F_SETFL, flags) < 0){
    perror("fcntl set nonblock error : ");
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %edi
movl $0x3, %esi
movb $0x0, %al
callq 0x21a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x602b
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6069
movl -0xc(%rbp), %eax
orl $0x800, %eax            # imm = 0x800
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %edx
movl $0x4, %esi
movb $0x0, %al
callq 0x21a0
cmpl $0x0, %eax
jge 0x6062
leaq 0x138b(%rip), %rdi      # 0x73df
callq 0x2230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6069
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gtarcoder[P]libevent_utils/utils.cpp
// Function: SetReuseAddr(int)
int SetReuseAddr(int fd){
	int on = 1;
	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < -1){
    perror("setsocketopt so_reuseaddr error : ");
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x2440
cmpl $-0x1, %eax
jge 0x60c8
leaq 0x1341(%rip), %rdi      # 0x73fb
callq 0x2230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x60cf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gtarcoder[P]libevent_utils/utils.cpp
// Function: SetRecvSendBufSize(int, int)
int SetRecvSendBufSize(int fd, int size){
  if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &size,sizeof(size)) < 0){
    perror("setsocketopt so_recbuf error : ");
    return -1;
  }
  if(setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size,sizeof(size)) < 0){
    perror("setsocketopt so_sndbuf error : ");
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x8, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x2440
cmpl $0x0, %eax
jge 0x6124
leaq 0x1308(%rip), %rdi      # 0x741e
callq 0x2230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6161
movl -0x8(%rbp), %edi
movl $0x1, %esi
movl $0x7, %edx
leaq -0xc(%rbp), %rcx
movl $0x4, %r8d
callq 0x2440
cmpl $0x0, %eax
jge 0x615a
leaq 0x12f2(%rip), %rdi      # 0x743e
callq 0x2230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6161
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: gtarcoder[P]libevent_utils/utils.cpp
// Function: SetKeepLive(int, int, int, int)
int SetKeepLive(int fd, int idle, int interval, int count){
  if ( setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, (void *)&idle, sizeof(idle)) < 0 ){
    perror("setsocketopt tcp_keepidle error : ");
    return -1;
  }
  if ( setsockopt(fd, SOL_TCP,  TCP_KEEPINTVL, (void *)&interval, sizeof(idle)) < 0 ){
    perror("setsocketopt tcp_keepintvl error : ");
    return -1;
  }
  if ( setsockopt(fd, SOL_TCP,  TCP_KEEPCNT, (void *)&count, sizeof(count)) < 0 ){
    perror("setsocketopt tcp_keepcnt error : ");
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x8(%rbp), %edi
movl $0x6, %esi
movl $0x4, %r8d
leaq -0xc(%rbp), %rcx
movl %r8d, %edx
callq 0x2440
cmpl $0x0, %eax
jge 0x61b8
leaq 0x12b4(%rip), %rdi      # 0x745e
callq 0x2230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6228
movl -0x8(%rbp), %edi
movl $0x6, %esi
movl $0x5, %edx
leaq -0x10(%rbp), %rcx
movl $0x4, %r8d
callq 0x2440
cmpl $0x0, %eax
jge 0x61ee
leaq 0x12a1(%rip), %rdi      # 0x7481
callq 0x2230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6228
movl -0x8(%rbp), %edi
movl $0x6, %edx
leaq -0x14(%rbp), %rcx
movl $0x4, %r8d
movl %edx, %esi
callq 0x2440
cmpl $0x0, %eax
jge 0x6221
leaq 0x1292(%rip), %rdi      # 0x74a5
callq 0x2230
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6228
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: alex-courtis[P]xlayoutdisplay/src/Edid.cpp
// Function: Edid::dpiForMode(std::shared_ptr<Mode const> const&) const
long Edid::dpiForMode(const std::shared_ptr<const Mode> &mode) const {
    if (maxCmVert() == 0 || maxCmHoriz() == 0) {
        return 0;
    }
    double dpiHoriz = mode->width * INCHES_PER_CM / maxCmHoriz();
    double dpiVert = mode->height * INCHES_PER_CM / maxCmVert();

    // nearest 12 dpi
    return lround((dpiHoriz + dpiVert) / 24) * 12;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x0, %eax
je 0x7f62
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x0, %eax
jne 0x7f6f
movq $0x0, -0x8(%rbp)
jmp 0x801c
movq -0x18(%rbp), %rdi
callq 0x8400
movq -0x30(%rbp), %rdi
movl 0x8(%rax), %eax
cvtsi2sd %rax, %xmm0
movsd 0x38084(%rip), %xmm1    # 0x40010
movsd %xmm1, -0x40(%rbp)
mulsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movsd -0x48(%rbp), %xmm0
movl %eax, %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8400
movsd -0x40(%rbp), %xmm1
movq -0x30(%rbp), %rdi
movl 0xc(%rax), %eax
cvtsi2sd %rax, %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movsd -0x38(%rbp), %xmm0
movl %eax, %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd 0x37ffd(%rip), %xmm1    # 0x40008
divsd %xmm1, %xmm0
callq 0x7070
imulq $0xc, %rax, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alex-courtis[P]xlayoutdisplay/src/Mode.cpp
// Function: Mode::operator<(Mode const&) const
bool Mode::operator<(const Mode &o) const {
    if (width == o.width)
        if (height == o.height)
            return refresh < o.refresh;
        else
            return height < o.height;
    else
        return width < o.width;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x8ae0
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x8ac8
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8af6
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x8af6
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: alex-courtis[P]xlayoutdisplay/src/Monitors.cpp
// Function: calculateLaptopLidClosed(char const*)
bool calculateLaptopLidClosed(const char *laptopLidRootPath) {
    static char lidFileName[PATH_MAX];
    static char line[512];

    // find the lid state directory
    DIR *dir = opendir(laptopLidRootPath);
    if (dir) {
        struct dirent *dirent;
        while ((dirent = readdir(dir)) != nullptr) {
            if (dirent->d_type == DT_DIR && strcmp(dirent->d_name, ".") != 0 && strcmp(dirent->d_name, "..") != 0) {

                // read the lid state file
                snprintf(lidFileName, PATH_MAX, "%s/%s/%s", laptopLidRootPath, dirent->d_name, "state");
                FILE *lidFile = fopen(lidFileName, "r");
                if (lidFile != nullptr) {
                    if (fgets(line, 512, lidFile))
                        if (strcasestr(line, "closed"))
                            return true;
                    fclose(lidFile);
                }

                // drivers/acpi/button.c acpi_button_add_fs seems to indicate there will be only one file
                break;
            }
        }
        closedir(dir);
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x77a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8c28
jmp 0x8b26
movq -0x18(%rbp), %rdi
callq 0x77b0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8c1f
movq -0x20(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x8c1a
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
leaq 0x37a1e(%rip), %rsi     # 0x4057b
callq 0x7750
cmpl $0x0, %eax
je 0x8c1a
movq -0x20(%rbp), %rdi
addq $0x13, %rdi
leaq 0x37a00(%rip), %rsi     # 0x4057a
callq 0x7750
cmpl $0x0, %eax
je 0x8c1a
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %r8
addq $0x13, %r8
leaq 0x55f65(%rip), %rdi     # 0x5eb00
movl $0x1000, %esi           # imm = 0x1000
leaq 0x37662(%rip), %rdx     # 0x40209
leaq 0x37664(%rip), %r9      # 0x40212
movb $0x0, %al
callq 0x7810
leaq 0x55f44(%rip), %rdi     # 0x5eb00
leaq 0x38294(%rip), %rsi     # 0x40e57
callq 0x7610
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8c18
movq -0x28(%rbp), %rdx
leaq 0x56f22(%rip), %rdi     # 0x5fb00
movl $0x200, %esi            # imm = 0x200
callq 0x77f0
cmpq $0x0, %rax
je 0x8c0f
leaq 0x56f0b(%rip), %rdi     # 0x5fb00
leaq 0x3761c(%rip), %rsi     # 0x40218
callq 0x7a10
cmpq $0x0, %rax
je 0x8c0d
movb $0x1, -0x1(%rbp)
jmp 0x8c2c
jmp 0x8c0f
movq -0x28(%rbp), %rdi
callq 0x74b0
jmp 0x8c1f
jmp 0x8b26
movq -0x18(%rbp), %rdi
callq 0x7820
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: alex-courtis[P]xlayoutdisplay/src/calculations.cpp
// Function: ltrOutputs(std::__cxx11::list<std::shared_ptr<Output>, std::allocator<std::shared_ptr<Output>>> const&)
void ltrOutputs(const list<shared_ptr<Output>> &outputs) {
    int xpos = 0;
    int ypos = 0;
    for (const auto &output : outputs) {

        if (output->desiredActive) {

            // set the desired mode to optimal
            output->desiredMode = output->optimalMode;

            // position the screen
            output->desiredPos = make_shared<Pos>(xpos, ypos);

            // next position
            xpos += output->desiredMode->width;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbf80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbfb0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xbfe0
testb $0x1, %al
jne 0xac72
jmp 0xad29
leaq -0x20(%rbp), %rdi
callq 0xc010
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc040
testb $0x1, 0x90(%rax)
je 0xad19
movq -0x30(%rbp), %rdi
callq 0xc040
addq $0x60, %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc040
movq -0x48(%rbp), %rsi
movq %rax, %rdi
addq $0x98, %rdi
callq 0xc350
leaq -0x40(%rbp), %rdi
leaq -0xc(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xc380
movq -0x30(%rbp), %rdi
callq 0xc040
movq %rax, %rdi
addq $0xa8, %rdi
leaq -0x40(%rbp), %rsi
callq 0xc400
leaq -0x40(%rbp), %rdi
callq 0xc430
movq -0x30(%rbp), %rdi
callq 0xc040
movq %rax, %rdi
addq $0x98, %rdi
callq 0x8400
movl 0x8(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0xad1b
leaq -0x20(%rbp), %rdi
callq 0xc090
jmp 0xac5c
addq $0x50, %rsp
popq %rbp
retq
nop
// File: alex-courtis[P]xlayoutdisplay/src/calculations.cpp
// Function: calculateOptimalMode(std::__cxx11::list<std::shared_ptr<Mode const>, std::allocator<std::shared_ptr<Mode const>>> const&, std::shared_ptr<Mode const> const&)
const shared_ptr<const Mode> calculateOptimalMode(const list<shared_ptr<const Mode>> &modes, const shared_ptr<const Mode> &preferredMode) {
    shared_ptr<const Mode> optimalMode;

    // default optimal mode is empty
    if (!modes.empty()) {

        // use highest resolution/refresh for optimal
        const list<shared_ptr<const Mode>> reverseOrderedModes = reverseSort(modes);
        optimalMode = reverseOrderedModes.front();

        // override with highest refresh of preferred resolution, if available
        if (preferredMode)
            for (const auto &mode : reverseOrderedModes)
                if (mode->width == preferredMode->width && mode->height == preferredMode->height) {
                    optimalMode = mode;
                    break;
                }
    }

    return optimalMode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x9570
movq -0x10(%rbp), %rdi
callq 0x9700
testb $0x1, %al
jne 0xbd9e
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xc450
jmp 0xbcab
leaq -0x38(%rbp), %rdi
callq 0xc5c0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0xc350
movq -0x18(%rbp), %rdi
callq 0x95b0
testb $0x1, %al
jne 0xbcd2
jmp 0xbd95
leaq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x97a0
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x97d0
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xa070
testb $0x1, %al
jne 0xbd0a
jmp 0xbd93
leaq -0x58(%rbp), %rdi
callq 0xa0f0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x8400
movl 0x8(%rax), %eax
movl %eax, -0x7c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8400
movq %rax, %rcx
movl -0x7c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0xbd83
movq -0x68(%rbp), %rdi
callq 0x8400
movl 0xc(%rax), %eax
movl %eax, -0x80(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8400
movq %rax, %rcx
movl -0x80(%rbp), %eax
cmpl 0xc(%rcx), %eax
jne 0xbd83
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xc350
jmp 0xbd93
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x9820
jmp 0xbdbe
jmp 0xbd85
leaq -0x58(%rbp), %rdi
callq 0xa120
jmp 0xbcf4
jmp 0xbd95
leaq -0x38(%rbp), %rdi
callq 0x9860
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xbdb1
movq -0x78(%rbp), %rdi
callq 0x9820
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x7930
nopw (%rax,%rax)
// File: alex-courtis[P]xlayoutdisplay/src/util.h
// Function: std::__cxx11::list<std::shared_ptr<Mode const>, std::allocator<std::shared_ptr<Mode const>>> const reverseSort<Mode>(std::__cxx11::list<std::shared_ptr<Mode const>, std::allocator<std::shared_ptr<Mode const>>> const&)
inline const std::list<std::shared_ptr<const T>> reverseSort(const std::list<std::shared_ptr<const T>> &list) {
    std::list<std::shared_ptr<const T>> sorted = list;
    sorted.sort(sortSharedPtr<const T>);
    sorted.reverse();
    return sorted;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rsi
callq 0x9420
movq -0x30(%rbp), %rdi
leaq 0x381d(%rip), %rsi      # 0xfca0
callq 0xf890
jmp 0xc48a
movq -0x30(%rbp), %rdi
callq 0xfce0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xc4bf
jmp 0xc4b6
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9860
jmp 0xc4c9
movq -0x30(%rbp), %rdi
callq 0x9860
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x7930
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: alex-courtis[P]xlayoutdisplay/src/xrandrrutil.cpp
// Function: refreshFromModeInfo(_XRRModeInfo const&)
unsigned int refreshFromModeInfo(const XRRModeInfo &modeInfo) {
    double rate;
    double vTotal = modeInfo.vTotal;

    if (modeInfo.modeFlags & RR_DoubleScan)
        /* doublescan doubles the number of lines */
        vTotal *= 2;

    if (modeInfo.modeFlags & RR_Interlace)
        /* interlace splits the frame into two fields */
        /* the field rate is what is typically reported by monitors */
        vTotal /= 2;

    if (modeInfo.hTotal && vTotal)
        rate = ((double) modeInfo.dotClock / ((double) modeInfo.hTotal * vTotal));
    else
        rate = 0;

    // round up
    return static_cast<unsigned int>(round(rate));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
andq $0x20, %rax
cmpq $0x0, %rax
je 0x11341
movsd 0x2f2d9(%rip), %xmm0    # 0x40610
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
andq $0x10, %rax
cmpq $0x0, %rax
je 0x11369
movsd -0x18(%rbp), %xmm0
movsd 0x2f2b0(%rip), %xmm1    # 0x40610
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x113c8
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x11385
jp 0x11385
jmp 0x113c8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %xmm0
movaps 0x2f28b(%rip), %xmm1    # 0x40620
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2f28f(%rip), %xmm1    # 0x40630
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movl 0x20(%rax), %eax
cvtsi2sd %rax, %xmm1
mulsd -0x18(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x113d0
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x7200
cvttsd2si %xmm0, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: alex-courtis[P]xlayoutdisplay/src/xrdbutil.cpp
// Function: renderXrdbCmd[abi:cxx11](long const&)
const std::string renderXrdbCmd(const long &dpi) {
    stringstream ss;
    ss << "echo \"Xft.dpi: "
       << dpi
       << "\" | xrdb -merge";
    return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x73a0
leaq -0x188(%rbp), %rdi
leaq 0x2bd93(%rip), %rsi     # 0x407d1
callq 0x74a0
movq %rax, -0x1b0(%rbp)
jmp 0x14a4c
movq -0x1b0(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7980
movq %rax, -0x1c8(%rbp)
jmp 0x14a68
movq -0x1c8(%rbp), %rdi
leaq 0x2bd6b(%rip), %rsi     # 0x407e1
callq 0x74a0
jmp 0x14a7d
movq -0x1c0(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x7490
jmp 0x14a92
leaq -0x198(%rbp), %rdi
callq 0x73d0
movq -0x1b8(%rbp), %rax
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a0(%rbp)
movl %eax, -0x1a4(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x73d0
movq -0x1a0(%rbp), %rdi
callq 0x7930
nopl (%rax,%rax)
// File: alex-courtis[P]xlayoutdisplay/src/xutil.cpp
// Function: resetRootCursor()
void resetRootCursor() {
    Display* dpy = XOpenDisplay(nullptr);
    int screen = DefaultScreen(dpy);
    Window root = RootWindow(dpy, screen);
    Cursor cursor = XcursorLibraryLoadCursor(dpy, "left_ptr");
    XDefineCursor(dpy, root, cursor);
    XFreeCursor(dpy, cursor);
    XCloseDisplay(dpy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x7730
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xe0(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2bcc6(%rip), %rsi     # 0x407f1
callq 0x76e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7900
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7540
movq -0x8(%rbp), %rdi
callq 0x79e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: alex-courtis[P]xlayoutdisplay/main.cpp
// Function: parseLong(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
long parseLong(const string &name, const string &val) {
    try {
        return stoi(val);
    } catch (invalid_argument &e) {
        throw invalid_argument("invalid " + name + ": " + val);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x163d0
movl %eax, -0x90(%rbp)
jmp 0x14c1d
movl -0x90(%rbp), %eax
cltq
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x14d60
movq -0x18(%rbp), %rdi
callq 0x71d0
movq %rax, -0x28(%rbp)
movb $0x1, -0x89(%rbp)
movl $0x10, %edi
callq 0x7260
movq %rax, -0x98(%rbp)
movq -0x8(%rbp), %rdx
leaq 0x2bde0(%rip), %rsi     # 0x40a5a
leaq -0x88(%rbp), %rdi
callq 0x95d0
jmp 0x14c88
leaq 0x2bb4f(%rip), %rdx     # 0x407de
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x8100
jmp 0x14ca1
movq -0x10(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x16410
jmp 0x14cb4
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7910
jmp 0x14cc6
movq -0x98(%rbp), %rdi
movb $0x0, -0x89(%rbp)
movq 0x492ed(%rip), %rsi     # 0x5dfc8
movq 0x492ce(%rip), %rdx     # 0x5dfb0
callq 0x78c0
jmp 0x14d71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x14d40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x14d34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x14d2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x7320
leaq -0x68(%rbp), %rdi
callq 0x7320
leaq -0x88(%rbp), %rdi
callq 0x7320
testb $0x1, -0x89(%rbp)
jne 0x14d4b
jmp 0x14d57
movq -0x98(%rbp), %rdi
callq 0x73c0
callq 0x7860
jmp 0x14d5e
jmp 0x14d60
movq -0x18(%rbp), %rdi
callq 0x7930
movq %rax, %rdi
callq 0x8a00
nopw %cs:(%rax,%rax)
// File: joraso[P]Glassius/chaos.cpp
// Function: chaos::seed(double)
void chaos::seed(double s){
    /* Seeds the random number generator. */
    std::cout << "Seeding random number generation with: " << s << std::endl;
    //std::cout << "maximum random is: " << RAND_MAX << std::endl;
    std::srand(s);
    return;
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
movq 0x91a3(%rip), %rdi      # 0xbfd0
leaq 0x622c(%rip), %rsi      # 0x9060
callq 0x2140
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0x2240
movq %rax, %rdi
movq 0x9168(%rip), %rsi      # 0xbfb8
callq 0x2150
cvttsd2si (%rsp), %rax
movl %eax, %edi
callq 0x2130
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: joraso[P]Glassius/chaos.cpp
// Function: chaos::gaussian(double, double)
double chaos::gaussian(double mean, double std){
    /* Draws random numbers from a gaussian using the box-muller method */
    double r1 = chaos::random();
    double r2 = chaos::random();
    double z0 = sqrt(-2.0*log(r1))*cos(2.0*M_PI*r2);
    //double z1 = sqrt(-2.0*log(r1))*sin(2.0*M_PI*r2);
    return (z0 * std) + mean;
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
callq 0x2e70
movsd %xmm0, 0x20(%rsp)
callq 0x2e70
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2100
movaps %xmm0, %xmm1
movsd 0x6174(%rip), %xmm0     # 0x9050
mulsd %xmm1, %xmm0
callq 0x20f0
movsd %xmm0, 0x8(%rsp)
movsd 0x6155(%rip), %xmm0     # 0x9048
mulsd 0x18(%rsp), %xmm0
callq 0x2230
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addq $0x38, %rsp
retq
// File: joraso[P]Glassius/chaos.cpp
// Function: chaos::test(int)
void chaos::test(int n){
    /* Draw random numbers and prints them to "chaostest.csv" */
    double r;
    
    // Opening the file
    std::ofstream chaosfile;
    chaosfile.open("Data/chaostest.csv");
    
    for(int i=0;i<n;i++){
        // change the function you want to test here:
        r = gaussian(0.0, 1);
        chaosfile << r << std::endl;
    }
    chaosfile.close();
    return;
}

// Assembly:
subq $0x238, %rsp            # imm = 0x238
movl %edi, 0x234(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21e0
movq 0x10(%rsp), %rdi
leaq 0x612f(%rip), %rsi      # 0x9088
movl $0x10, %edx
callq 0x2060
jmp 0x2f65
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x234(%rsp), %eax
jge 0x2fe9
xorps %xmm0, %xmm0
movsd 0x60d3(%rip), %xmm1     # 0x9058
callq 0x2ea0
movsd %xmm0, 0x228(%rsp)
movsd 0x228(%rsp), %xmm0
leaq 0x28(%rsp), %rdi
callq 0x2240
movq %rax, 0x8(%rsp)
jmp 0x2fad
movq 0x8(%rsp), %rdi
movq 0x8fff(%rip), %rsi      # 0xbfb8
callq 0x2150
jmp 0x2fc0
jmp 0x2fc2
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2f6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x21c0
jmp 0x3007
leaq 0x28(%rsp), %rdi
callq 0x21a0
jmp 0x2ff5
leaq 0x28(%rsp), %rdi
callq 0x21c0
addq $0x238, %rsp            # imm = 0x238
retq
movq 0x20(%rsp), %rdi
callq 0x2210
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: joraso[P]Glassius/Stopwatch.cpp
// Function: Stopwatch::Stopwatch()
Stopwatch::Stopwatch(){
    tici = std::time(0);
    ticf = std::time(0);
    ticlast = std::time(0);
    return;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2120
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x2120
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x2120
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: joraso[P]Glassius/Stopwatch.cpp
// Function: Stopwatch::StampComplete()
void Stopwatch::StampComplete(){
    time_t lap = std::time(0);
    char* dt = std::ctime(&lap);
    std::cout << "Task completed: " << dt;
    double elapsed = std::difftime(lap, ticlast);
    std::cout << "Elapsed time: " << elapsed << " sec" << std::endl;
    ticlast = lap;
    return;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2120
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x2080
movq %rax, 0x10(%rsp)
movq 0x8eda(%rip), %rdi      # 0xbfd0
leaq 0x5fb4(%rip), %rsi      # 0x90b1
callq 0x2140
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x2140
movq (%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rax), %rsi
callq 0x20b0
movsd %xmm0, 0x8(%rsp)
movq 0x8ea2(%rip), %rdi      # 0xbfd0
leaq 0x5fae(%rip), %rsi      # 0x90e3
callq 0x2140
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2240
movq %rax, %rdi
leaq 0x5f70(%rip), %rsi      # 0x90c2
callq 0x2140
movq %rax, %rdi
movq 0x8e57(%rip), %rsi      # 0xbfb8
callq 0x2150
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: joraso[P]Glassius/Stopwatch.cpp
// Function: Stopwatch::EndStamp()
void Stopwatch::EndStamp(){
    ticf = std::time(0);
    char* dt = std::ctime(&ticf);
    std::cout << "Simulation finished: " << dt;
    double elapsed = std::difftime(ticf, tici);
    std::cout << "Total Elapsed time: " << elapsed << " sec" << std::endl;
    return;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2120
movq 0x8(%rsp), %rdi
movq %rax, 0x8(%rdi)
addq $0x8, %rdi
callq 0x2080
movq %rax, 0x18(%rsp)
movq 0x8e16(%rip), %rdi      # 0xbfd0
leaq 0x5f06(%rip), %rsi      # 0x90c7
callq 0x2140
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x2140
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rax), %rsi
callq 0x20b0
movsd %xmm0, 0x10(%rsp)
movq 0x8ddf(%rip), %rdi      # 0xbfd0
leaq 0x5ee5(%rip), %rsi      # 0x90dd
callq 0x2140
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x2240
movq %rax, %rdi
leaq 0x5ead(%rip), %rsi      # 0x90c2
callq 0x2140
movq %rax, %rdi
movq 0x8d94(%rip), %rsi      # 0xbfb8
callq 0x2150
addq $0x28, %rsp
retq
nop
// File: joraso[P]Glassius/Matrix.cpp
// Function: Matrix::Matrix(int const&, int const&)
Matrix::Matrix(const int& rows,const int& columns):rows(rows),columns(columns){
    data = new double* [rows];
    data[0] = new double [rows*columns];
    for(int i=1;i<rows;i++)
        data[i]=data[i-1]+columns;//Use pointer math to allocate it
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
imull (%rcx), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x3347
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movl 0xc(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x10(%rsp), %rcx
movslq (%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rdx
movq 0x8(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x32fb
addq $0x28, %rsp
retq
nopl (%rax)
// File: joraso[P]Glassius/Matrix.cpp
// Function: Matrix::operator=(Matrix const&)
Matrix & Matrix::operator=(const Matrix& rhs){
    if(this!= &rhs){//Check for user/compiler stupidity
        int i,j;
        rows = rhs.rows;
        columns = rhs.columns;
        if(data !=0){
            delete [] data[0];
            delete [] data;
        }
        data = new double* [rows];
        data[0] = new double [rows*columns];
        for(i=1;i<rows;i++)
            data[i]=data[i-1]+columns;
        for(i=0;i<rows;i++)
            for(j=0;j<columns;j++)
                data[i][j] = rhs.data[i][j];
    }
    return *this;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq 0x28(%rsp), %rax
je 0x3510
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x28(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
cmpq $0x0, 0x8(%rax)
je 0x33d4
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x33b4
movq 0x10(%rsp), %rdi
callq 0x2180
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x33d2
movq 0x8(%rsp), %rdi
callq 0x2180
jmp 0x33d4
movq 0x18(%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq 0x18(%rsp), %rcx
movq %rax, 0x8(%rcx)
movl (%rcx), %eax
imull 0x4(%rcx), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movl $0x1, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl (%rcx), %eax
jge 0x348f
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movl 0x24(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rdx
movslq 0x4(%rax), %rcx
shlq $0x3, %rcx
addq %rcx, %rdx
movq 0x8(%rax), %rax
movslq 0x24(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3446
movl $0x0, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl (%rcx), %eax
jge 0x350e
movl $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rcx
movl 0x20(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x34ff
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x24(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x20(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x8(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x20(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x34ac
jmp 0x3501
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3497
jmp 0x3510
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: joraso[P]Glassius/Matrix.cpp
// Function: Matrix::Matrix(Matrix const&)
Matrix::Matrix(const Matrix& rhs){
    int i,j;
    rows = rhs.rows;
    columns = rhs.columns;
    if(data !=0){
        data = 0;
    }
    data = new double* [rows];
    data[0] = new double [rows*columns];
    for(i=1;i<rows;i++)
        data[i]=data[i-1]+columns;
    for(i=0;i<rows;i++)
        for(j=0;j<columns;j++)
            data[i][j] = rhs.data[i][j];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
cmpq $0x0, 0x8(%rax)
je 0x3560
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movslq (%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
movl (%rcx), %eax
imull 0x4(%rcx), %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movl $0x1, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jge 0x361b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movl 0x14(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rdx
movslq 0x4(%rax), %rcx
shlq $0x3, %rcx
addq %rcx, %rdx
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x35d2
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl (%rcx), %eax
jge 0x369a
movl $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movl 0x10(%rsp), %eax
cmpl 0x4(%rcx), %eax
jge 0x368b
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movslq 0x14(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x10(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x8(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x3638
jmp 0x368d
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3623
addq $0x28, %rsp
retq
nop
// File: joraso[P]Glassius/Matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
ostream& operator << (ostream& os,const Matrix& rhs){
    // Edited this to make it comma delimited, cause that's easier to read.-JR
    for(int i=0;i<rhs.rows;i++){
        for(int j=0;j<rhs.columns;j++){
            os << rhs.data[i][j];
            if(j<(rhs.columns-1)){os << ",";}
        }
        os << endl;
    }
    return os;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x37b1
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3790
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq (%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x2240
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3783
movq 0x10(%rsp), %rdi
leaq 0x5974(%rip), %rsi      # 0x90f2
callq 0x2140
jmp 0x3785
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x372e
movq 0x10(%rsp), %rdi
movq 0x881c(%rip), %rsi      # 0xbfb8
callq 0x2150
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3716
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: joraso[P]Glassius/Particles.cpp
// Function: Particles::UpdateKinetic()
void Particles::UpdateKinetic(){
    /* Updates the kinetic energy according to the current particle
    velocities */
    int i, k;
    kinetic_energy = 0;
    for(i=0;i<N;i++){ 
        for(k=0;k<3;k++){kinetic_energy += (24.0)*(v[i][k]*v[i][k]);}
    }
    return;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
movl $0x0, -0xc(%rsp)
movq -0x18(%rsp), %rcx
movl -0xc(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x4048
movl $0x0, -0x10(%rsp)
cmpl $0x3, -0x10(%rsp)
jge 0x4036
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movslq -0xc(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq -0xc(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rsp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movsd 0x78(%rax), %xmm1
movsd 0x50e4(%rip), %xmm2     # 0x9100
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rax)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x3fd5
jmp 0x4038
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x3fbf
retq
nopl (%rax)