LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: karel-brinda[P]ococo/ext/htslib/knetfile.c
// Function: knet_read
ssize_t knet_read(knetFile *fp, void *buf, size_t len)
{
	off_t l = 0;
	if (fp->fd == -1) return 0;
	if (fp->type == KNF_TYPE_FTP) {
		if (fp->is_ready == 0) {
			if (!fp->no_reconnect) kftp_reconnect(fp);
			kftp_connect_file(fp);
		}
	} else if (fp->type == KNF_TYPE_HTTP) {
		if (fp->is_ready == 0)
			khttp_connect_file(fp);
	}
	if (fp->type == KNF_TYPE_LOCAL) { // on Windows, the following block is necessary; not on UNIX
		size_t rest = len;
		ssize_t curr;
		while (rest) {
			do {
				curr = read(fp->fd, (void*)((char*)buf + l), rest);
			} while (curr < 0 && EINTR == errno);
			if (curr < 0) return -1;
			if (curr == 0) break;
			l += curr; rest -= curr;
		}
	} else l = my_netread(fp->fd, buf, len);
	fp->offset += l;
	return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
jne 0x77583
movq $0x0, -0x8(%rbp)
jmp 0x776a6
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x775b4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x775b2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
jne 0x775a9
movq -0x10(%rbp), %rdi
callq 0x765d0
movq -0x10(%rbp), %rdi
callq 0x76810
jmp 0x775d4
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x775d2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x775d0
movq -0x10(%rbp), %rdi
callq 0x76e50
jmp 0x775d2
jmp 0x775d4
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x77676
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x77674
jmp 0x775f6
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x18(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x4840
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x39(%rbp)
jge 0x77633
callq 0x4070
movq %rax, %rcx
movl $0x4, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x775f6
cmpq $0x0, -0x38(%rbp)
jge 0x7764b
movq $-0x1, -0x8(%rbp)
jmp 0x776a6
cmpq $0x0, -0x38(%rbp)
jne 0x77654
jmp 0x77674
movq -0x38(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x775e9
jmp 0x7768e
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x77210
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: karel-brinda[P]ococo/ext/htslib/knetfile.c
// Function: socket_wait
static int socket_wait(int fd, int is_read)
{
	fd_set fds, *fdr = 0, *fdw = 0;
	struct timeval tv;
	int ret;
	tv.tv_sec = 5; tv.tv_usec = 0; // 5 seconds time out
	FD_ZERO(&fds);
	FD_SET(fd, &fds);
	if (is_read) fdr = &fds;
	else fdw = &fds;
	ret = select(fd+1, fdr, fdw, 0, &tv);
#ifndef _WIN32
	if (ret == -1) perror("select");
#else
	if (ret == 0)
		fprintf(stderr, "select time-out\n");
	else if (ret == SOCKET_ERROR)
		fprintf(stderr, "select: %d\n", WSAGetLastError());
#endif
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x90(%rbp)
movq $0x0, -0x98(%rbp)
movq $0x5, -0xa8(%rbp)
movq $0x0, -0xa0(%rbp)
leaq -0x88(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl $0x0, -0xb0(%rbp)
movl -0xb0(%rbp), %eax
cmpq $0x10, %rax
jae 0x77927
movq -0xb8(%rbp), %rax
movl -0xb0(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0xb0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xb0(%rbp)
jmp 0x778f5
jmp 0x77929
movl -0x4(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl -0x4(%rbp), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x88(%rbp,%rax,8), %rcx
movq %rcx, -0x88(%rbp,%rax,8)
cmpl $0x0, -0x8(%rbp)
je 0x77976
leaq -0x88(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x77984
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa8(%rbp), %r8
callq 0x4550
movl %eax, -0xac(%rbp)
cmpl $-0x1, -0xac(%rbp)
jne 0x779c3
leaq 0x7545(%rip), %rdi      # 0x7ef03
callq 0x4480
movl -0xac(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: tomfunkhouser[P]gaps/apps/grdview/grdview.cpp
// Function: GLUTMotion(int, int)
void GLUTMotion(int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;

  // Compute mouse movement
  int dx = x - GLUTmouse[0];
  int dy = y - GLUTmouse[1];
  
  // World in hand navigation 
  R3Point origin = grid->GridBox().Centroid();
  if (GLUTbutton[0]) viewer->RotateWorld(1.0, origin, x, y, dx, dy);
  else if (GLUTbutton[1]) viewer->ScaleWorld(1.0, origin, x, y, dx, dy);
  else if (GLUTbutton[2]) viewer->TranslateWorld(1.0, origin, x, y, dx, dy);
  if (GLUTbutton[0] || GLUTbutton[1] || GLUTbutton[2]) glutPostRedisplay();

  // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;
}

// Assembly:
subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movl %esi, 0x70(%rsp)
movl 0x18ea8e(%rip), %eax    # 0x1b38e0
movl 0x70(%rsp), %ecx
subl %ecx, %eax
movl %eax, 0x70(%rsp)
movl 0x74(%rsp), %eax
movl 0x19d472(%rip), %ecx    # 0x1c22d8
subl %ecx, %eax
movl %eax, 0x6c(%rsp)
movl 0x70(%rsp), %eax
movl 0x19d466(%rip), %ecx    # 0x1c22dc
subl %ecx, %eax
movl %eax, 0x68(%rsp)
movq 0x19d3bd(%rip), %rsi    # 0x1c2240
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x26cd0
movq (%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x38ee0
jmp 0x24ea1
leaq 0x18(%rsp), %rdi
callq 0x26bf0
cmpl $0x0, 0x19d42e(%rip)    # 0x1c22e0
je 0x24f02
movq 0x19d375(%rip), %rdi    # 0x1c2230
movl 0x74(%rsp), %edx
movl 0x70(%rsp), %ecx
movl 0x6c(%rsp), %r8d
movl 0x68(%rsp), %r9d
movq (%rdi), %rax
movsd 0x13a148(%rip), %xmm0   # 0x15f020
leaq 0x50(%rsp), %rsi
callq *0x58(%rax)
jmp 0x24f72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x26bf0
jmp 0x24fab
cmpl $0x0, 0x19d3db(%rip)    # 0x1c22e4
je 0x24f39
movq 0x19d31e(%rip), %rdi    # 0x1c2230
movl 0x74(%rsp), %edx
movl 0x70(%rsp), %ecx
movl 0x6c(%rsp), %r8d
movl 0x68(%rsp), %r9d
movq (%rdi), %rax
movsd 0x13a0f1(%rip), %xmm0   # 0x15f020
leaq 0x50(%rsp), %rsi
callq *0x50(%rax)
jmp 0x24f70
cmpl $0x0, 0x19d3a8(%rip)    # 0x1c22e8
je 0x24f6e
movq 0x19d2e7(%rip), %rdi    # 0x1c2230
movl 0x74(%rsp), %edx
movl 0x70(%rsp), %ecx
movl 0x6c(%rsp), %r8d
movl 0x68(%rsp), %r9d
movq (%rdi), %rax
movsd 0x13a0ba(%rip), %xmm0   # 0x15f020
leaq 0x50(%rsp), %rsi
callq *0x48(%rax)
jmp 0x24f70
jmp 0x24f72
cmpl $0x0, 0x19d367(%rip)    # 0x1c22e0
jne 0x24f8d
cmpl $0x0, 0x19d362(%rip)    # 0x1c22e4
jne 0x24f8d
cmpl $0x0, 0x19d35d(%rip)    # 0x1c22e8
je 0x24f92
callq 0xee000
movl 0x74(%rsp), %eax
movl %eax, 0x19d33c(%rip)    # 0x1c22d8
movl 0x70(%rsp), %eax
movl %eax, 0x19d336(%rip)    # 0x1c22dc
addq $0x78, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x20ee0
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/grdview/grdview.cpp
// Function: GLUTMouse(int, int, int, int)
void GLUTMouse(int button, int state, int x, int y)
{
  // Invert y coordinate
  y = GLUTwindow_height - y;
  
  // Process mouse button event

  // Remember button state 
  int b = (button == GLUT_LEFT_BUTTON) ? 0 : ((button == GLUT_MIDDLE_BUTTON) ? 1 : 2);
  GLUTbutton[b] = (state == GLUT_DOWN) ? 1 : 0;

  // Remember modifiers 
  GLUTmodifiers = glutGetModifiers();

  // Remember mouse position 
  GLUTmouse[0] = x;
  GLUTmouse[1] = y;

  // Redraw
  glutPostRedisplay();
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %ecx, 0x8(%rsp)
movl 0x18e906(%rip), %eax    # 0x1b38e0
subl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x24ff0
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0x25007
movl 0x14(%rsp), %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x1, %edx
cmovel %ecx, %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x10(%rsp), %ecx
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovel %eax, %edx
movslq 0x4(%rsp), %rcx
leaq 0x19d2b5(%rip), %rax    # 0x1c22e0
movl %edx, (%rax,%rcx,4)
callq 0xf6230
movl %eax, 0x19d2b3(%rip)    # 0x1c22ec
movl 0xc(%rsp), %eax
movl %eax, 0x19d295(%rip)    # 0x1c22d8
movl 0x8(%rsp), %eax
movl %eax, 0x19d28f(%rip)    # 0x1c22dc
callq 0xee000
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/grdview/grdview.cpp
// Function: GLUTMainLoop()
void GLUTMainLoop(void)
{
  // Set default values
  if (grid_threshold == -98765) {
    RNScalar max_threshold = grid->Maximum() - 1.0E-20;
    grid_threshold = grid->Mean() + 3 * grid->StandardDeviation();
    if (grid_threshold > max_threshold) grid_threshold = max_threshold;
  }

  // Set slice coords to middle of grid
  grid_slice_coords[RN_X] = grid->XResolution()/2;
  grid_slice_coords[RN_Y] = grid->YResolution()/2;
  grid_slice_coords[RN_Z] = grid->ZResolution()/2;

  // Run main loop -- never returns 
  glutMainLoop();
}

// Assembly:
subq $0x18, %rsp
movss 0x18e044(%rip), %xmm0   # 0x1b38d0
movss 0x1397fc(%rip), %xmm1   # 0x15f090
ucomiss %xmm1, %xmm0
jne 0x25929
jp 0x25929
movq 0x19c996(%rip), %rdi    # 0x1c2240
callq 0x26e90
movsd 0x139791(%rip), %xmm1   # 0x15f048
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x19c978(%rip), %rdi    # 0x1c2240
callq 0x26910
movsd %xmm0, 0x8(%rsp)
movq 0x19c966(%rip), %rdi    # 0x1c2240
callq 0x26d30
movsd 0x8(%rsp), %xmm1
movsd 0x13976b(%rip), %xmm2   # 0x15f058
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18dfcf(%rip)   # 0x1b38d0
movss 0x18dfc7(%rip), %xmm0   # 0x1b38d0
cvtss2sd %xmm0, %xmm0
ucomisd 0x10(%rsp), %xmm0
jbe 0x25927
movsd 0x10(%rsp), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x18dfa9(%rip)   # 0x1b38d0
jmp 0x25929
movq 0x19c910(%rip), %rdi    # 0x1c2240
callq 0x269c0
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x19c915(%rip)    # 0x1c2258
movq 0x19c8f6(%rip), %rdi    # 0x1c2240
callq 0x269e0
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x19c8ff(%rip)    # 0x1c225c
movq 0x19c8dc(%rip), %rdi    # 0x1c2240
callq 0x26a00
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x19c8e9(%rip)    # 0x1c2260
callq 0xf3070
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/grdview/grdview.cpp
// Function: main
int 
main(int argc, char **argv)
{
  // Initialize GLUT
  GLUTInit(&argc, argv);

  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Read grid
  grid = ReadGrid(grid_name);
  if (!grid) exit(-1);

  // Create viewer
  viewer = CreateViewer(grid);
  if (!viewer) exit(-1);

  // Run GLUT interface
  GLUTMainLoop();

  // Return success 
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x25730
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x25a30
cmpl $0x0, %eax
jne 0x259d1
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x209e0
movq 0x19c930(%rip), %rdi    # 0x1c2308
callq 0x25fd0
movq %rax, 0x19c85c(%rip)    # 0x1c2240
cmpq $0x0, 0x19c854(%rip)    # 0x1c2240
jne 0x259f8
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x209e0
movq 0x19c841(%rip), %rdi    # 0x1c2240
callq 0x26440
movq %rax, 0x19c825(%rip)    # 0x1c2230
cmpq $0x0, 0x19c81d(%rip)    # 0x1c2230
jne 0x25a1f
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x209e0
callq 0x25880
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: boomanaiden154[P]HTTPClientHPP/./client.hpp
// Function: HTTPClient::initalizeSocket(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
static int initalizeSocket(std::string address, int port)
    {
        int sockfd;

        struct addrinfo hints;
        struct addrinfo* servinfo;
        struct addrinfo* p;

        memset(&hints, 0, sizeof(hints));
        hints.ai_family = AF_UNSPEC;
        hints.ai_socktype = SOCK_STREAM;

        getaddrinfo(address.c_str(), std::to_string(port).c_str(), &hints, &servinfo);

        for(p = servinfo; p != NULL; p = p->ai_next)
        {
            if((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1)
            {
                continue;
            }
            if(connect(sockfd, p->ai_addr, p->ai_addrlen) == -1)
            {
                close(sockfd);
                continue;
            }
            break;
        }

        if(p == NULL)
        {
            return -1;
        }

        freeaddrinfo(servinfo);

        return sockfd;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x50(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x1, -0x48(%rbp)
callq 0x3110
movq %rax, -0x98(%rbp)
movl -0x14(%rbp), %esi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x60e0
movq -0xa0(%rbp), %rdi
callq 0x3110
movq -0x98(%rbp), %rdi
movq %rax, %rsi
leaq -0x50(%rbp), %rdx
leaq -0x58(%rbp), %rcx
callq 0x3370
jmp 0x4733
leaq -0x80(%rbp), %rdi
callq 0x31a0
movq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x47c2
movq -0x60(%rbp), %rax
movl 0x4(%rax), %edi
movq -0x60(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x60(%rbp), %rax
movl 0xc(%rax), %edx
callq 0x30a0
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x478c
jmp 0x47b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31a0
jmp 0x47ed
movl -0x18(%rbp), %edi
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x60(%rbp), %rax
movl 0x10(%rax), %edx
callq 0x3220
cmpl $-0x1, %eax
jne 0x47b2
movl -0x18(%rbp), %edi
callq 0x34b0
jmp 0x47b4
jmp 0x47c2
movq -0x60(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x4744
cmpq $0x0, -0x60(%rbp)
jne 0x47d2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x47e1
movq -0x58(%rbp), %rdi
callq 0x3390
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3440
nopl (%rax)
// File: boomanaiden154[P]HTTPClientHPP/./client.hpp
// Function: HTTPHeader::HTTPHeader(bool)
HTTPHeader(bool isRequest_ = false)
    {
        bufferIndex = 0;
        parsingFieldName = true;
        isRequest = isRequest_;
        parsingHeader = true;
        isDone = false;
        currentChunkLength = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x4260
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x33c0
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0x33c0
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
callq 0x33c0
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
callq 0x33c0
movq -0x18(%rbp), %rdi
addq $0xb8, %rdi
callq 0x33c0
movq -0x18(%rbp), %rdi
addq $0xe0, %rdi
callq 0x33c0
movq -0x18(%rbp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x33c0
movq -0x18(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x33c0
movq -0x18(%rbp), %rax
movl $0x0, 0xd8(%rax)
movb $0x1, 0x120(%rax)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
movb $0x1, 0x121(%rax)
movb $0x0, 0x122(%rax)
movl $0x0, 0x124(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: boomanaiden154[P]HTTPClientHPP/./client.hpp
// Function: HTTPHeader::parseData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void parseData(const std::string& input)
    {
        if(headers.find("transfer-encoding") != headers.end() && headers.find("transfer-encoding")->second == "chunked")
        {
            parseChunk(input);
        }
        else
        {
            body += input;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rax, -0x98(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3450
movq -0x90(%rbp), %rdx
movb $0x0, -0x82(%rbp)
movb $0x0, -0x83(%rbp)
leaq 0x202f(%rip), %rsi      # 0x9060
leaq -0x38(%rbp), %rdi
callq 0x41b0
jmp 0x703c
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7230
movq %rax, -0xa8(%rbp)
jmp 0x7055
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x4c50
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x4c20
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa9(%rbp)
jne 0x7091
jmp 0x711f
movq -0x98(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3450
movq -0xb8(%rbp), %rdx
movb $0x1, -0x82(%rbp)
leaq 0x1f99(%rip), %rsi      # 0x9060
leaq -0x80(%rbp), %rdi
callq 0x41b0
jmp 0x70d2
movq -0xc0(%rbp), %rdi
movb $0x1, -0x83(%rbp)
leaq -0x80(%rbp), %rsi
callq 0x7230
movq %rax, -0xc8(%rbp)
jmp 0x70f2
movq -0xc8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x4c80
movq %rax, %rdi
addq $0x20, %rdi
leaq 0x1f5e(%rip), %rsi      # 0x9072
callq 0x4800
movb %al, -0xa9(%rbp)
movb -0xa9(%rbp), %al
movb %al, -0xc9(%rbp)
testb $0x1, -0x83(%rbp)
jne 0x7136
jmp 0x713f
leaq -0x80(%rbp), %rdi
callq 0x31a0
testb $0x1, -0x82(%rbp)
jne 0x714a
jmp 0x7156
leaq -0x81(%rbp), %rdi
callq 0x3300
leaq -0x38(%rbp), %rdi
callq 0x31a0
leaq -0x39(%rbp), %rdi
callq 0x3300
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x7177
jmp 0x7205
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7350
jmp 0x721c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x71fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x71f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x71d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x83(%rbp)
jne 0x71cd
jmp 0x71d6
leaq -0x80(%rbp), %rdi
callq 0x31a0
jmp 0x71d8
testb $0x1, -0x82(%rbp)
jne 0x71e3
jmp 0x71ef
leaq -0x81(%rbp), %rdi
callq 0x3300
jmp 0x71f1
leaq -0x38(%rbp), %rdi
callq 0x31a0
leaq -0x39(%rbp), %rdi
callq 0x3300
jmp 0x7225
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x98, %rdi
callq 0x3380
addq $0xd0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3440
nop
// File: halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::sink to::action<void (*)(char const*), to::keyword_parser<char const*>>(void (*)(char const*), to::keyword_parser<char const*>)
sink action(F f, P parser) {
    return sink(sink::action,
        [f = std::move(f), parser = std::move(parser)](const char* arg) -> bool {
            return static_cast<bool>(f << parser(arg));
        });
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, %rax
movq -0x68(%rbp), %rsi
movq %rdi, -0x58(%rbp)
movq %rdi, %rcx
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6e90
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6ec0
jmp 0x450a
leaq -0x40(%rbp), %rdi
callq 0x6ee0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6ee0
movq -0x48(%rbp), %rdi
callq 0x3370
nopl (%rax,%rax)
// File: ys1998[P]spsim/src/alu.cpp
// Function: ALU1::tock()
void ALU1::tock(void){
	if(stall_cycles > 0)
		stall_cycles--;
	else {
		if(i.is_valid()){
			if(out->valid()){
				read = false;	// previous data has not been read; stall
			}else{
				read = true;
				out->write(std::make_tuple(i, res));
				Instruction reset; i = reset;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
cmpl $0x0, 0xb0(%rax)
jle 0x484e
movq -0x118(%rbp), %rax
movl 0xb0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xb0(%rax)
jmp 0x496f
movq -0x118(%rbp), %rdi
addq $0x8, %rdi
callq 0x6280
testb $0x1, %al
jne 0x4867
jmp 0x496d
movq -0x118(%rbp), %rax
movq 0xd0(%rax), %rdi
callq 0x6420
testb $0x1, %al
jne 0x4880
jmp 0x4893
movq -0x118(%rbp), %rax
movb $0x0, 0xc0(%rax)
jmp 0x496b
movq -0x118(%rbp), %rdx
movb $0x1, 0xc0(%rdx)
movq 0xd0(%rdx), %rax
movq %rax, -0x128(%rbp)
movq %rdx, %rsi
addq $0x8, %rsi
addq $0xbc, %rdx
leaq -0x88(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x6470
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
callq 0x6440
jmp 0x48e5
leaq -0x88(%rbp), %rdi
callq 0x64b0
leaq -0x110(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0xe8a0
movq -0x118(%rbp), %rdi
movq -0x130(%rbp), %rsi
addq $0x8, %rdi
callq 0x6380
jmp 0x491d
leaq -0x110(%rbp), %rdi
callq 0x61d0
jmp 0x496b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x64b0
jmp 0x4978
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x61d0
jmp 0x4978
jmp 0x496d
jmp 0x496f
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: ys1998[P]spsim/src/alu.cpp
// Function: ALU2::tock()
void ALU2::tock(void){
	if(stall_cycles > 0)
		stall_cycles--;
	else {
		if(i.is_valid()){
			if(out->valid()){
				read = false;	// previous data has not been read; stall
			}else{
				read = true;
				out->write(std::make_tuple(i, lo, hi));
				Instruction reset; i = reset;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
cmpl $0x0, 0xb0(%rax)
jle 0x551e
movq -0x118(%rbp), %rax
movl 0xb0(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xb0(%rax)
jmp 0x5649
movq -0x118(%rbp), %rdi
addq $0x8, %rdi
callq 0x6280
testb $0x1, %al
jne 0x5537
jmp 0x5647
movq -0x118(%rbp), %rax
movq 0xd0(%rax), %rdi
callq 0x6310
testb $0x1, %al
jne 0x5550
jmp 0x5563
movq -0x118(%rbp), %rax
movb $0x0, 0xc4(%rax)
jmp 0x5645
movq -0x118(%rbp), %rcx
movb $0x1, 0xc4(%rcx)
movq 0xd0(%rcx), %rax
movq %rax, -0x128(%rbp)
movq %rcx, %rsi
addq $0x8, %rsi
movq %rcx, %rdx
addq $0xc0, %rdx
addq $0xbc, %rcx
leaq -0x88(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x6500
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
callq 0x6330
jmp 0x55bf
leaq -0x88(%rbp), %rdi
callq 0x62f0
leaq -0x110(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0xe8a0
movq -0x118(%rbp), %rdi
movq -0x130(%rbp), %rsi
addq $0x8, %rdi
callq 0x6380
jmp 0x55f7
leaq -0x110(%rbp), %rdi
callq 0x61d0
jmp 0x5645
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x62f0
jmp 0x5652
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x61d0
jmp 0x5652
jmp 0x5647
jmp 0x5649
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3480
nop
// File: ys1998[P]spsim/src/alu.cpp
// Function: ALU2::flush(int)
void ALU2::flush(int id){
	if(i.get_id() > id){
		Instruction reset;
		i = reset;
		stall_cycles = 0;
		read = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
addq $0x8, %rdi
callq 0x6270
cmpl -0xc(%rbp), %eax
jle 0x56fd
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xe8a0
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x8, %rdi
callq 0x6380
jmp 0x56b7
movq -0xa0(%rbp), %rax
movl $0x0, 0xb0(%rax)
movb $0x1, 0xc4(%rax)
leaq -0x88(%rbp), %rdi
callq 0x61d0
jmp 0x56fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x61d0
jmp 0x5706
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: ys1998[P]spsim/src/alu.cpp
// Function: ALU3::ALU3(Latch<std::tuple<Instruction, int, int>>*, Latch<std::tuple<Instruction, int>>*, bool*)
ALU3::ALU3(	Latch< std::tuple<Instruction, int, int> >* in, 
			Latch< std::tuple<Instruction, int> >* out, bool* b){
	this->in = in; this->out = out; this->b = b;
	// store latencies of operations
	latencies[FUNCT["add"]] = LATENCY_ADD;
	latencies[FUNCT["sw"]] = LATENCY_SW;
	// set stall cycles to zero
	stall_cycles = 0;
	read = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x5e20
movq -0x90(%rbp), %rdi
leaq 0x29477(%rip), %rax     # 0x2ebd0
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0xa8(%rbp)
callq 0xe8a0
movq -0x90(%rbp), %rdi
subq $-0x80, %rdi
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
callq 0x5e40
movq -0x90(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0xc8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0xd0(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0xd8(%rax)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3490
movq -0x88(%rbp), %rdx
leaq 0x1c831(%rip), %rsi     # 0x22004
leaq -0x40(%rbp), %rdi
callq 0x6020
jmp 0x57de
leaq 0x29b13(%rip), %rdi     # 0x2f2f8
leaq -0x40(%rbp), %rsi
callq 0x5f40
movq %rax, -0xb0(%rbp)
jmp 0x57f7
movq -0xb0(%rbp), %rsi
movq -0xa0(%rbp), %rdi
callq 0x5e60
movq %rax, -0xb8(%rbp)
jmp 0x5813
movq -0xb8(%rbp), %rax
movl $0x1, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x31e0
leaq -0x41(%rbp), %rdi
callq 0x3300
movq -0x90(%rbp), %rax
subq $-0x80, %rax
movq %rax, -0xc8(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3490
movq -0xc0(%rbp), %rdx
leaq 0x1c7bb(%rip), %rsi     # 0x2201d
leaq -0x78(%rbp), %rdi
callq 0x6020
jmp 0x586d
leaq 0x29a84(%rip), %rdi     # 0x2f2f8
leaq -0x78(%rbp), %rsi
callq 0x5f40
movq %rax, -0xd0(%rbp)
jmp 0x5886
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
callq 0x5e60
movq %rax, -0xd8(%rbp)
jmp 0x58a2
movq -0xd8(%rbp), %rax
movl $0x1, (%rax)
leaq -0x78(%rbp), %rdi
callq 0x31e0
leaq -0x79(%rbp), %rdi
callq 0x3300
movq -0x90(%rbp), %rax
movl $0x0, 0xb0(%rax)
movb $0x1, 0xc0(%rax)
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5905
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31e0
leaq -0x41(%rbp), %rdi
callq 0x3300
jmp 0x593c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5933
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x31e0
leaq -0x79(%rbp), %rdi
callq 0x3300
movq -0x98(%rbp), %rdi
callq 0x61b0
movq -0xa8(%rbp), %rdi
callq 0x61d0
movq -0x50(%rbp), %rdi
callq 0x3480
nopl (%rax)
// File: ys1998[P]spsim/src/alu.cpp
// Function: ALU3::tick()
void ALU3::tick(void){
	if(in->valid() && read){
		auto inp = in->read();
		in->write(inp);
		i = std::get<0>(inp);
		if(i.is_valid())
			read = false;
		in1 = std::get<1>(inp);
		in2 = std::get<2>(inp);
		i.EXEC = CLOCK;
		i.RF2 = CLOCK + 1;
		if(i.is_valid() && latencies[std::get<1>(i.type())] == 1){
			res = in1 + in2;
			in->read();
		}
		else{
			stall_cycles = latencies[std::get<1>(i.type())] - 1;	
		}
	} 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movq 0xc8(%rax), %rdi
callq 0x6310
testb $0x1, %al
jne 0x598f
jmp 0x5bef
movq -0x130(%rbp), %rax
testb $0x1, 0xc0(%rax)
je 0x5bef
movq -0x130(%rbp), %rax
movq 0xc8(%rax), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x62b0
movq -0x130(%rbp), %rax
movq -0x138(%rbp), %rsi
movq 0xc8(%rax), %rdi
callq 0x6330
jmp 0x59e0
leaq -0x88(%rbp), %rdi
callq 0x6360
movq -0x130(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rdi
callq 0x6380
jmp 0x5a01
movq -0x130(%rbp), %rdi
addq $0x8, %rdi
callq 0x6280
movb %al, -0x139(%rbp)
jmp 0x5a19
movb -0x139(%rbp), %al
testb $0x1, %al
jne 0x5a25
jmp 0x5a58
movq -0x130(%rbp), %rax
movb $0x0, 0xc0(%rax)
jmp 0x5a58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x62f0
jmp 0x5bf8
leaq -0x88(%rbp), %rdi
movq %rdi, -0x148(%rbp)
callq 0x63e0
movq -0x148(%rbp), %rdi
movq %rax, %rcx
movq -0x130(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0xb4(%rax)
callq 0x6400
movq %rax, %rcx
movq -0x130(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0xb8(%rax)
leaq 0x2981a(%rip), %rcx     # 0x2f2bc
movl (%rcx), %edx
movq %rax, %rdi
addq $0x8, %rdi
movl %edx, 0x48(%rax)
movl (%rcx), %ecx
incl %ecx
movl %ecx, 0x4c(%rax)
callq 0x6280
movb %al, -0x13a(%rbp)
jmp 0x5ac2
movb -0x13a(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x149(%rbp)
jne 0x5ad7
jmp 0x5b35
movq -0x130(%rbp), %rsi
movq %rsi, %rax
subq $-0x80, %rax
movq %rax, -0x158(%rbp)
addq $0x8, %rsi
leaq -0x9c(%rbp), %rdi
callq 0x105b0
jmp 0x5afe
leaq -0x9c(%rbp), %rdi
callq 0x61f0
movq -0x158(%rbp), %rdi
movq %rax, %rsi
callq 0x60d0
movq %rax, -0x160(%rbp)
jmp 0x5b22
movq -0x160(%rbp), %rax
cmpl $0x1, (%rax)
sete %al
movb %al, -0x149(%rbp)
movb -0x149(%rbp), %al
testb $0x1, %al
jne 0x5b41
jmp 0x5b7f
movq -0x130(%rbp), %rax
movl 0xb4(%rax), %ecx
movl 0xb8(%rax), %edx
addl %edx, %ecx
movl %ecx, 0xbc(%rax)
movq 0xc8(%rax), %rsi
leaq -0x120(%rbp), %rdi
callq 0x62b0
jmp 0x5b71
leaq -0x120(%rbp), %rdi
callq 0x62f0
jmp 0x5be3
movq -0x130(%rbp), %rsi
movq %rsi, %rax
subq $-0x80, %rax
movq %rax, -0x168(%rbp)
addq $0x8, %rsi
leaq -0x128(%rbp), %rdi
callq 0x105b0
jmp 0x5ba6
leaq -0x128(%rbp), %rdi
callq 0x61f0
movq -0x168(%rbp), %rdi
movq %rax, %rsi
callq 0x60d0
movq %rax, -0x170(%rbp)
jmp 0x5bca
movq -0x130(%rbp), %rax
movq -0x170(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movl %ecx, 0xb0(%rax)
leaq -0x88(%rbp), %rdi
callq 0x62f0
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: ys1998[P]spsim/src/alu.cpp
// Function: ALU3::tock()
void ALU3::tock(void){
	if(i.is_valid()	){
		if(out->valid()){
			read = false;	// previous data has not been read; stall
		}else{
			read = true;
			out->write(std::make_tuple(i, res));
			Instruction reset; i = reset;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
addq $0x8, %rdi
callq 0x6280
testb $0x1, %al
jne 0x5c3c
jmp 0x5d42
movq -0x118(%rbp), %rax
movq 0xd0(%rax), %rdi
callq 0x6420
testb $0x1, %al
jne 0x5c55
jmp 0x5c68
movq -0x118(%rbp), %rax
movb $0x0, 0xc0(%rax)
jmp 0x5d40
movq -0x118(%rbp), %rdx
movb $0x1, 0xc0(%rdx)
movq 0xd0(%rdx), %rax
movq %rax, -0x128(%rbp)
movq %rdx, %rsi
addq $0x8, %rsi
addq $0xbc, %rdx
leaq -0x88(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x6470
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
callq 0x6440
jmp 0x5cba
leaq -0x88(%rbp), %rdi
callq 0x64b0
leaq -0x110(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0xe8a0
movq -0x118(%rbp), %rdi
movq -0x130(%rbp), %rsi
addq $0x8, %rdi
callq 0x6380
jmp 0x5cf2
leaq -0x110(%rbp), %rdi
callq 0x61d0
jmp 0x5d40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x64b0
jmp 0x5d4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x61d0
jmp 0x5d4b
jmp 0x5d42
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3480
nopw (%rax,%rax)
// File: ys1998[P]spsim/src/alu.cpp
// Function: ALU3::flush(int)
void ALU3::flush(int id){
	if(i.get_id() > id){
		Instruction reset;
		i = reset;
		stall_cycles = 0;
		read = true;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
addq $0x8, %rdi
callq 0x6270
cmpl -0xc(%rbp), %eax
jle 0x5dfd
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xe8a0
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x8, %rdi
callq 0x6380
jmp 0x5db7
movq -0xa0(%rbp), %rax
movl $0x0, 0xb0(%rax)
movb $0x1, 0xc0(%rax)
leaq -0x88(%rbp), %rdi
callq 0x61d0
jmp 0x5dfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x61d0
jmp 0x5e06
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ys1998[P]spsim/src/decoder.cpp
// Function: Decoder::Decoder(std::deque<Instruction, std::allocator<Instruction>>*, FreeList*, ActiveList*, int*, bool*, IntegerQueue*, AddressQueue*, int*, int*, Fetcher*)
Decoder::Decoder(Buffer<Instruction>* d, FreeList *f, ActiveList *a, int *r, 
				bool *b, IntegerQueue *iq, AddressQueue *aq, int *p, int *pa,
				Fetcher *ft){
	this->d = d; this->f = f; this->a = a;
	this->r = r; this->b = b; this->iq = iq;
	this->aq = aq; this->predict = p; this->predict_addr = pa;
	this->ft = ft;
	decode_signal = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x5e20
movq -0x38(%rbp), %rdi
leaq 0x2514c(%rip), %rax     # 0x2ec68
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0xa9b0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x68(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x70(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0x78(%rax)
movq 0x10(%rbp), %rcx
movq %rcx, 0x80(%rax)
movq 0x18(%rbp), %rcx
movq %rcx, 0x88(%rax)
movq 0x20(%rbp), %rcx
movq %rcx, 0x98(%rax)
movq 0x28(%rbp), %rcx
movq %rcx, 0xa0(%rax)
movq 0x30(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movb $0x1, 0x90(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ys1998[P]spsim/src/decoder.cpp
// Function: Decoder::tock()
void Decoder::tock(void){
	int cnt = 0;
	size_t i = 0; 
	while(!_q.empty() && cnt < INSTR_DECODED_PER_CYCLE && i < _q.size()){
		int ret = decode_instr(_q[i]);
		if(ret < 0){
			++i;
		}else if(ret == 0){
			_q.erase(_q.begin() + i);
			cnt++;
		}else{
			_q.clear();
			d->clear();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x130(%rbp), %rdi
addq $0x8, %rdi
callq 0xab40
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x131(%rbp)
jne 0xa7e7
xorl %eax, %eax
cmpl $0x2, -0xc(%rbp)
movb %al, -0x131(%rbp)
jge 0xa7e7
movq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x140(%rbp)
addq $0x8, %rdi
callq 0xac70
movq %rax, %rcx
movq -0x140(%rbp), %rax
cmpq %rcx, %rax
setb %al
movb %al, -0x131(%rbp)
movb -0x131(%rbp), %al
testb $0x1, %al
jne 0xa7f6
jmp 0xa92b
movq -0x130(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0xaca0
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x6c70
movq -0x130(%rbp), %rdi
movq -0x150(%rbp), %rsi
callq 0x9ba0
movl %eax, -0x144(%rbp)
jmp 0xa83b
leaq -0x98(%rbp), %rdi
callq 0x61d0
movl -0x144(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0xa88a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xa926
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa0(%rbp)
movl %eax, -0xa4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x61d0
jmp 0xa934
cmpl $0x0, -0x1c(%rbp)
jne 0xa904
movq -0x130(%rbp), %rsi
movq %rsi, %rax
addq $0x8, %rax
movq %rax, -0x158(%rbp)
addq $0x8, %rsi
leaq -0x108(%rbp), %rdi
callq 0xad70
movq -0x18(%rbp), %rdx
leaq -0xe8(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0xad30
leaq -0xc8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xada0
movq -0x158(%rbp), %rsi
leaq -0x128(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0xacd0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa924
movq -0x130(%rbp), %rdi
addq $0x8, %rdi
callq 0xade0
movq -0x130(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xade0
jmp 0xa926
jmp 0xa789
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0x3480
// File: ys1998[P]spsim/src/decoder.cpp
// Function: Decoder::flush(int)
void Decoder::flush(int id){
	// clean eveerything, no check needed
	_q.clear();
	d->clear();
	a->flush(id);
	iq->flush(id);
	aq->flush(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0xade0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0xade0
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x138c0
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x1c590
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x1d7b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ys1998[P]spsim/src/fetcher.cpp
// Function: Fetcher::tock()
void Fetcher::tock(void){
	for(int i = 0; i < INSTR_FETCHED_PER_CYCLE; ++i){
		if((unsigned int)_PC < cache->size() && (*cache)[_PC].is_valid() && dest->size() < FETCH_QUEUE_SIZE){
			Instruction temp = (*cache)[_PC++];
			temp.IF = CLOCK;
			dest->push_back(temp);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0xdd7b
movq -0xa0(%rbp), %rax
movl 0x8(%rax), %ecx
movq %rcx, -0xa8(%rbp)
movq 0x10(%rax), %rdi
callq 0xac70
movq %rax, %rcx
movq -0xa8(%rbp), %rax
cmpq %rcx, %rax
jae 0xdd6b
movq -0xa0(%rbp), %rax
movq 0x10(%rax), %rdi
movslq 0x8(%rax), %rsi
callq 0xaca0
movq %rax, %rdi
callq 0x6280
testb $0x1, %al
jne 0xdccd
jmp 0xdd6b
movq -0xa0(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xac70
cmpq $0x20, %rax
jae 0xdd6b
movq -0xa0(%rbp), %rax
movq 0x10(%rax), %rdi
movslq 0x8(%rax), %rsi
movl %esi, %ecx
incl %ecx
movl %ecx, 0x8(%rax)
callq 0xaca0
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6c70
movq -0xa0(%rbp), %rax
movq -0xb0(%rbp), %rsi
leaq 0x2158f(%rip), %rcx     # 0x2f2bc
movl (%rcx), %ecx
movl %ecx, -0x54(%rbp)
movq 0x18(%rax), %rdi
callq 0xab70
jmp 0xdd3d
leaq -0x88(%rbp), %rdi
callq 0x61d0
jmp 0xdd6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x61d0
jmp 0xdd84
jmp 0xdd6d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xdc71
addq $0xb0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x3480
// File: ys1998[P]spsim/src/flusher.cpp
// Function: Flusher::Flusher(Issuer*, Fetcher*, Decoder*, Writer*)
Flusher::Flusher(Issuer *is, Fetcher *f, Decoder *d, Writer *w){
	this->is = is;
	this->f = f;
	this->d = d;
	this->w = w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: ys1998[P]spsim/src/flusher.cpp
// Function: Flusher::flush(int, int)
void Flusher::flush(int id, int PC){
	is->flush(id);
	d->flush(id);
	f->update_PC(PC);
	w->flush(id);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0xdd90
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ys1998[P]spsim/src/instruction.cpp
// Function: Instruction::map(std::tuple<int, int, int, int>)
void Instruction::map(std::tuple<int, int, int, int> t){
	rt_ = std::get<1>(t);
	rd_ = std::get<2>(t);
	_rd = std::get<3>(t);
	rs_ = std::get<0>(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, %rax
movq -0x28(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x10ad0
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x18(%rax)
callq 0x10af0
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x1c(%rax)
callq 0x10b10
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x20(%rax)
callq 0x10b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, 0x14(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ys1998[P]spsim/src/issuer.cpp
// Function: Issuer::attach_latch(int, Latch<std::tuple<Instruction, int, int>>*, int)
void Issuer::attach_latch(int idx, Latch< std::tuple<Instruction, int, int> > *l,int type){
	this->l[idx] = l;
	if(type == 2)
		addrescal_latch =idx;
	if(type == 3)
		memory_latch = idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
movslq -0xc(%rbp), %rcx
movq %rdx, 0x1e8(%rax,%rcx,8)
cmpl $0x2, -0x1c(%rbp)
jne 0x1183d
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x220(%rax)
cmpl $0x3, -0x1c(%rbp)
jne 0x11850
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x224(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ys1998[P]spsim/src/lists.cpp
// Function: FreeList::find()
int FreeList::find(){
	for(int i = 0; i < NUM_PHY_REGS; i++) {
		if(free[i]) 
			return i;
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x40, -0x14(%rbp)
jge 0x13540
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
testb $0x1, (%rax,%rcx)
je 0x13533
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x13547
jmp 0x13535
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13517
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: ys1998[P]spsim/src/lists.cpp
// Function: ActiveList::push(Instruction)
int ActiveList::push(Instruction instr){
	if(_q.size() < ACTIVE_LIST_SIZE){
		_q.push_back({instr, false});
		return 0;
	}else{
		return -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x13ab0
cmpq $0x40, %rax
jae 0x13652
movq -0xc0(%rbp), %rsi
movb $0x0, -0x99(%rbp)
leaq -0x98(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
leaq -0x99(%rbp), %rdx
callq 0x13b10
movq -0xb8(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x13ae0
jmp 0x1361d
leaq -0x98(%rbp), %rdi
callq 0x13b50
movl $0x0, -0x4(%rbp)
jmp 0x13659
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x13b50
jmp 0x13665
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x3480
nopw %cs:(%rax,%rax)
// File: ys1998[P]spsim/src/lists.cpp
// Function: ActiveList::flush(int)
void ActiveList::flush(int id){
	size_t i = _q.size() - 1;
	while(i != 0){
		if(_q[i].first.get_id() > id){
			auto regs = _q[i].first.physical_regs();
			auto log_regs = _q[i].first.logical_regs();
			
			if(std::get<2>(regs) >= 0 && std::get<2>(regs) < NUM_PHY_REGS)
				f->add(std::get<2>(regs));
			
			if(std::get<2>(log_regs) != -1)
				*(r + std::get<2>(log_regs)) = std::get<3>(regs);
			if(std::get<2>(regs) != -1)
				*(b + std::get<2>(regs)) = false;
			
			_q.erase(_q.begin() + i);
		}
		i--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x13ab0
subq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13a7c
movq -0xc0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13d40
movq %rax, %rdi
callq 0x6270
cmpl -0xc(%rbp), %eax
jle 0x13a6b
movq -0xc0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13d40
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x10520
movq -0xc0(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13d40
movq %rax, %rsi
leaq -0x34(%rbp), %rdi
callq 0x10570
leaq -0x28(%rbp), %rdi
callq 0x10af0
cmpl $0x0, (%rax)
jl 0x13993
leaq -0x28(%rbp), %rdi
callq 0x10af0
cmpl $0x40, (%rax)
jge 0x13993
movq -0xc0(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10af0
movq -0xc8(%rbp), %rdi
movl (%rax), %esi
callq 0x12bc0
leaq -0x34(%rbp), %rdi
callq 0xaa30
cmpl $-0x1, (%rax)
je 0x139e6
leaq -0x28(%rbp), %rdi
callq 0x10b10
movq %rax, %rcx
movq -0xc0(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0xd4(%rbp)
movq 0x60(%rax), %rax
movq %rax, -0xd0(%rbp)
leaq -0x34(%rbp), %rdi
callq 0xaa30
movl -0xd4(%rbp), %edx
movq %rax, %rcx
movq -0xd0(%rbp), %rax
movslq (%rcx), %rcx
movl %edx, (%rax,%rcx,4)
leaq -0x28(%rbp), %rdi
callq 0x10af0
cmpl $-0x1, (%rax)
je 0x13a20
movq -0xc0(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10af0
movq %rax, %rcx
movq -0xe0(%rbp), %rax
movslq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0xc0(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0x13b70
movq -0x18(%rbp), %rdx
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x13dd0
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x13e10
movq -0xc0(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x13d70
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x138ea
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ys1998[P]spsim/src/main.cpp
// Function: print_mem(int*)
void print_mem(int *d){
	std::cout << "Memory (D-cache)\n";
	for(int j=0; j<4; ++j){
		std::cout << "\033[0;36m     Index     Value\033[0m";
	}
	std::cout << "\n";
	for(int i=0; i < DCACHE_SIZE/4; ++i){
		for(int j=0; j < 4; ++j){
				std::cout << "\033[1;36m" <<
				std::setfill(' ') << std::setw(10) << j*DCACHE_SIZE/4 + i << "\033[0m" <<
				std::setfill(' ') << std::setw(10) << *(d + j*DCACHE_SIZE/4 + i);
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1810d(%rip), %rdi     # 0x2efd0
leaq 0xb486(%rip), %rsi      # 0x22350
callq 0x3290
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x16efa
movq 0x180ed(%rip), %rdi     # 0x2efd0
leaq 0xb478(%rip), %rsi      # 0x22362
callq 0x3290
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16ed6
movq 0x180cf(%rip), %rdi     # 0x2efd0
leaq 0xb458(%rip), %rsi      # 0x22360
callq 0x3290
movl $0x0, -0x10(%rbp)
cmpl $0x19, -0x10(%rbp)
jge 0x17042
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x17021
movq 0x1809a(%rip), %rdi     # 0x2efd0
leaq 0xb40b(%rip), %rsi      # 0x22348
callq 0x3290
movq %rax, -0x50(%rbp)
movl $0x20, %edi
callq 0x19700
movq -0x50(%rbp), %rdi
movb %al, -0x15(%rbp)
movzbl -0x15(%rbp), %esi
callq 0x3400
movq %rax, -0x48(%rbp)
movl $0xa, %edi
callq 0x19720
movq -0x48(%rbp), %rdi
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0x3330
movq %rax, %rdi
imull $0x64, -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %esi
addl -0x10(%rbp), %esi
callq 0x3460
movq %rax, %rdi
leaq 0xb472(%rip), %rsi      # 0x22412
callq 0x3290
movq %rax, -0x40(%rbp)
movl $0x20, %edi
callq 0x19700
movq -0x40(%rbp), %rdi
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %esi
callq 0x3400
movq %rax, -0x38(%rbp)
movl $0xa, %edi
callq 0x19720
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
callq 0x3330
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
imull $0x64, -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x3460
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16f25
movq 0x17fa8(%rip), %rdi     # 0x2efd0
movq 0x17f91(%rip), %rsi     # 0x2efc0
callq 0x32e0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x16f14
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ys1998[P]spsim/inc/register.hpp
// Function: IntegerRegisterFile::IntegerRegisterFile()
IntegerRegisterFile() {								// default constructor
		for(int i=0; i < NUM_PHY_REGS; i++) {
			value[i] = 0;
		}
		hi = lo = 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x197b7
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x19797
movq -0x18(%rbp), %rax
movq $0x0, 0x108(%rax)
movq $0x0, 0x100(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)