LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: nextProbBinomial(int const&, long double const&, std::vector<long double, std::allocator<long double>> const&)
long double nextProbBinomial(const int& k, const long double& prevVal, const vector<long double>& params)
{
  if (params.size() < 3)
    {
      cerr << "Error:  nextProbBinomial() received an incorrect parameter vector; expected m, v, n."
           << endl
           << endl;
      exit(1);
    }
  if (0 == k)
    {
      cerr << "Error:  nextProbBinomial() received k = 0, which is invalid (require k > 0)."
           << endl
           << endl;
      exit(1);
    }
  const long double &m(params[0]), &v(params[1]), &nn(params[2]), kk(static_cast<long double>(k));
  if (kk > nn + 0.5) // really "if kk > nn," but we could have "kk == nn" with nn=15.99999 and kk=16.000001, hence the 0.5
    return 0.;
  if (v < 1.0e-8)
    {
      cerr << "Error:  nextProbBinomial() received v = 0, which is invalid (require variance > 0)."
           << endl
           << endl;
      exit(1);
    }
  return prevVal * (m - v) * (nn + 1. - kk) / (v * kk);
}

// Assembly:
pushq %rax
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
subq %rax, %rcx
cmpq $0x20, %rcx
jbe 0x2ab5
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x2ac5
movl %ecx, 0x4(%rsp)
fildl 0x4(%rsp)
fldt 0x20(%rax)
fld %st(0)
fadds 0x658a(%rip)            # 0x9004
fldz
fxch %st(3)
fucomi %st(1), %st
fstp %st(1)
ja 0x2aaf
fstp %st(2)
fldt 0x10(%rax)
fldl 0x6581(%rip)            # 0x9010
fucompi %st(1), %st
ja 0x2ad5
fldt (%rsi)
fldt (%rax)
fsub %st(2), %st
fmulp %st, %st(1)
fld1
faddp %st, %st(3)
fxch %st(2)
fsub %st(3), %st
fmulp %st, %st(2)
fmulp %st, %st(2)
fdivp %st, %st(1)
fldz
fldz
fxch %st(1)
fstp %st(0)
fstp %st(0)
popq %rax
retq
movq 0xa534(%rip), %rdi      # 0xcff0
leaq 0x6720(%rip), %rsi      # 0x91e3
jmp 0x2ae9
movq 0xa524(%rip), %rdi      # 0xcff0
leaq 0x6765(%rip), %rsi      # 0x9238
jmp 0x2ae9
fstp %st(2)
fstp %st(0)
fstp %st(0)
movq 0xa50e(%rip), %rdi      # 0xcff0
leaq 0x679c(%rip), %rsi      # 0x9285
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: nextProbPoisson(int const&, long double const&, std::vector<long double, std::allocator<long double>> const&)
long double nextProbPoisson(const int& k, const long double& prevVal, const vector<long double>& params)
{
  if (params.empty())
    {
      cerr << "Error:  nextProbPoisson() received an incorrect parameter vector; expected m."
           << endl
           << endl;
      exit(1);
    }
  if (0 == k)
    {
      cerr << "Error:  nextProbPoisson() received k = 0, which is invalid (require k > 0)."
           << endl
           << endl;
      exit(1);
    }
  const long double &m(params[0]), kk(static_cast<long double>(k));
  return prevVal * m / kk;
}

// Assembly:
pushq %rax
movq (%rdx), %rax
cmpq 0x8(%rdx), %rax
je 0x2b28
movl (%rdi), %ecx
testl %ecx, %ecx
je 0x2b38
movl %ecx, 0x4(%rsp)
fldt (%rsi)
fldt (%rax)
fmulp %st, %st(1)
fidivl 0x4(%rsp)
popq %rax
retq
movq 0xa4c1(%rip), %rdi      # 0xcff0
leaq 0x67a3(%rip), %rsi      # 0x92d9
jmp 0x2b46
movq 0xa4b1(%rip), %rdi      # 0xcff0
leaq 0x67e1(%rip), %rsi      # 0x9327
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: BackgroundRegionManager::BackgroundRegionManager(int const&, int const&)
BackgroundRegionManager::BackgroundRegionManager(const int& samplingInterval, const int& MAlength)
{
  m_posL = m_posC = m_posR = -1;
  m_runningSum_count = m_runningSum_countSquared
    = m_runningSum_count_duringPrevComputation = m_runningSum_countSquared_duringPrevComputation = 0;
  m_numPtsInNullRegion = m_numPtsInNullRegion_duringPrevComputation = 0;
  m_kcutoff = m_modeYval = m_modeXval = -1;
  m_MAlength = MAlength; // see explanation in findCutoff(); 5 is good when samplingInterval = 1, 15 is good when windowSize/samplingInterval ~= 250
  m_thresholdRatio = 1.33; // see explanation in findCutoff(); could instead try 1.4. 1.5 seems to be too high, 1.2 seems to be too low.
  m_sliding = false;
  m_needToUpdate_kcutoff = true;

  m_samplingInterval = samplingInterval;
  m_nextPosToSample = -1;
  m_sampledDataDistnSize = 0;

  m_minMAxN = m_kTrendReversal = -1;
  m_prev_k = -1;
  m_pmf = NULL;
  m_pCurChrom = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rdi), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rdi)
movaps %xmm0, 0x90(%rdi)
movaps %xmm0, 0x80(%rdi)
movaps %xmm0, 0x70(%rdi)
movaps %xmm0, 0x60(%rdi)
movaps %xmm0, 0x50(%rdi)
movq $0x0, 0xb0(%rdi)
movq %r12, %rdi
xorl %esi, %esi
callq 0x6ec2
leaq 0xb8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xf8(%rbx)
movups %xmm0, 0xe8(%rbx)
movups %xmm0, 0xd8(%rbx)
movups %xmm0, 0xc8(%rbx)
movups %xmm0, 0xb8(%rbx)
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x6ec2
leaq 0x128(%rbx), %rax
movl %r13d, 0x128(%rbx)
movq %r13, 0x130(%rbx)
movq %rax, 0x138(%rbx)
movq %rax, 0x140(%rbx)
movq %r13, 0x148(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x170(%rbx)
movq %r13, 0x180(%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x8(%rbx)
movq $-0x1, %rcx
movq %rcx, (%rbx)
movaps %xmm0, 0x10(%rbx)
movl %r13d, 0x20(%rbx)
movups %xmm0, 0x28(%rbx)
movl %r13d, 0x38(%rbx)
movq %rcx, 0x108(%rbx)
movl %eax, 0x110(%rbx)
movl (%r15), %edx
movl %edx, 0x3c(%rbx)
fldl 0x61e8(%rip)            # 0x9018
fstpt 0x40(%rbx)
movw $0x100, 0x118(%rbx)     # imm = 0x100
movl (%r14), %edx
movl %edx, 0x158(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rdx, 0x15c(%rbx)
movl %eax, 0x114(%rbx)
movq %rcx, 0x150(%rbx)
movq %r13, 0x168(%rbx)
movq %r13, 0x188(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x7aee
jmp 0x2e86
movq %rax, %r14
leaq 0x50(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2e9e
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x2230
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O1/Altius[P]hotspot2/src/hotspot2_part1.cpp
// Function: BackgroundRegionManager::setBounds(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, int, int)
void BackgroundRegionManager::setBounds(const string* pChrom, const int posL, const int posR)
{
  if (posR <= posL)
    {
      cerr << "Error:  BackgroundRegionManager::setBounds() received posL = "
           << posL << " and posR = " << posR << "; must have posL <= posR."
           << endl
           << endl;
      exit(1);
    }
  m_pCurChrom = pChrom; // used solely for warning and error messages and debugging
  m_posL = posL;
  m_posR = posR;
  m_posC = m_posL + (m_posR - m_posL) / 2; // integer division
  m_nextPosToSample = m_posL;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %ecx, %eax
subl %edx, %eax
jle 0x2eda
movq %rsi, 0x188(%rdi)
movl %ebp, (%rdi)
movl %ebx, 0x4(%rdi)
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %ebp, %ecx
movl %ecx, 0x8(%rdi)
movl %ebp, 0x15c(%rdi)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xa10f(%rip), %rdi      # 0xcff0
leaq 0x64cc(%rip), %rsi      # 0x93b4
callq 0x2210
movq %rax, %rdi
movl %ebp, %esi
callq 0x2390
leaq 0x64f4(%rip), %rsi      # 0x93f2
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
movl %ebx, %esi
callq 0x2390
leaq 0x64e8(%rip), %rsi      # 0x93ff
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/TheiaRT[P]libiris/tcp_client.cpp
// Function: TCPClient::connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool TCPClient::connect(std::string address, int port)
{
    /* New client; sock does not exist */
    if (sock == -1) {
        sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
        if (sock < 0) {
            perror("Could not create socket.");
            return false;
        }

#if defined(__APPLE__) && defined(__MACH__)
        int set = 1;
        setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, (void *)&set, sizeof(set));
#endif
    }
    else {
        /* Do nothing; sock exists */
    }

    /* Set up address structure */
    if (inet_addr(address.c_str()) == -1) {
        struct hostent *he;
        struct in_addr **addr_list;

        /* Valgrind may incorrectly report this as leaking. */
        he = gethostbyname(address.c_str());
        if (he == NULL) {
            herror("Could not resolve hostname.");
            return false;
        }

        addr_list = (struct in_addr **) he->h_addr_list;
        for (int i = 0; addr_list[i] != NULL; i++) {
            server.sin_addr = *addr_list[i];
            break;
        }
    }
    else {
        server.sin_addr.s_addr = inet_addr(address.c_str());
    }

    server.sin_family = AF_INET;
    server.sin_port = htons(port);

    if (::connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
        perror("Connect failed.");
        return false;
    }

    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
cmpl $-0x1, (%rdi)
jne 0x233e
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2050
movl %eax, (%r14)
testl %eax, %eax
js 0x23bd
movq (%r15), %rdi
callq 0x2100
movq (%r15), %rdi
cmpl $-0x1, %eax
je 0x2359
callq 0x2100
movl %eax, 0x8(%r14)
jmp 0x238b
callq 0x2120
movq %rax, %r15
testq %rax, %rax
je 0x237a
movq 0x18(%r15), %rax
movq (%rax), %rax
testq %rax, %rax
je 0x2386
movl (%rax), %eax
movl %eax, 0x8(%r14)
jmp 0x2386
leaq 0xc9c(%rip), %rdi       # 0x301d
callq 0x2140
testq %r15, %r15
je 0x23c9
leaq 0x4(%r14), %rsi
movw $0x2, 0x4(%r14)
rolw $0x8, %bx
movw %bx, 0x6(%r14)
movl (%r14), %edi
movl $0x10, %edx
callq 0x20c0
movl %eax, %ecx
movb $0x1, %al
testl %ecx, %ecx
jns 0x23cb
leaq 0xc7e(%rip), %rdi       # 0x3039
jmp 0x23c4
leaq 0xc40(%rip), %rdi       # 0x3004
callq 0x20d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/TheiaRT[P]libiris/tcp_client.cpp
// Function: TCPClient::send_data(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool TCPClient::send_data(std::string data, int size)
{
    if (send(sock, data.c_str(), data.length(), 0) < 0) {
        perror("Send failed.");
        return false;
    }

    return true;
}

// Assembly:
pushq %rbx
movl (%rdi), %edi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x2070
movq %rax, %rbx
testq %rax, %rax
js 0x23f6
testq %rbx, %rbx
setns %al
popq %rbx
retq
leaq 0xc4c(%rip), %rdi       # 0x3049
callq 0x20d0
jmp 0x23ee
// File: /workspace/github_cpp_makefile_star2_O1/TheiaRT[P]libiris/tcp_client.cpp
// Function: TCPClient::receive[abi:cxx11](int)
std::string TCPClient::receive(int size)
{
    std::string buffer = "";
    char *cbuffer = new char[size];
    bzero(cbuffer, size);
    int recvd = 0;
    while ((recvd = recv(sock, cbuffer, size - 1, 0)) > 0) {
        buffer += cbuffer;
        bzero(cbuffer, size);
    }

    if (recvd < 0) {
        perror("Receive failed.");
        return std::string();
    }

    delete [] cbuffer;
    close(sock);
    sock = -1;
    return buffer;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xc9b(%rip), %rdx       # 0x30c5
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x2566
movslq %ebp, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2080
leal -0x1(%r15), %eax
movslq %eax, %r13
leaq 0x8(%rsp), %rbp
movl (%r14), %edi
movq %r12, %rsi
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x2060
testl %eax, %eax
jle 0x248c
movq %rbp, %rdi
movq %r12, %rsi
callq 0x21a0
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2080
jmp 0x245e
js 0x2519
movq %r12, %rdi
callq 0x2150
movl (%r14), %edi
callq 0x21b0
movl $0xffffffff, (%r14)     # imm = 0xFFFFFFFF
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%rsp), %rcx
leaq 0x18(%rsp), %rdx
cmpq %rdx, %rcx
je 0x24cd
movq %rcx, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x24d3
movups (%rdx), %xmm0
movups %xmm0, (%rax)
leaq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rbx)
movq %rdx, -0x8(%rax)
movq %rdx, %rcx
movq $0x0, (%rax)
movb $0x0, (%rcx)
movq 0x8(%rsp), %rdi
cmpq %rdx, %rdi
je 0x2507
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb36(%rip), %rdi       # 0x3056
callq 0x20d0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rax
addq $0x8, %rax
leaq 0x18(%rsp), %rdx
jmp 0x24e6
jmp 0x253e
jmp 0x253e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x255d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2110
movq %rbx, %rdi
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O1/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: test003_mt_sync_req_rsp()
static void test003_mt_sync_req_rsp()
{
	static const char *tag = "test003: mt-sync-req-rsp";
	fprintf(stdout, "%s start...\n", tag);


	pthread_t tids[tcnt];
	for (int i = 0; i < tcnt; ++i) {
		errno = pthread_create(&tids[i], NULL, __test003_worker, (void *)(long)i);
		if (errno) {
			fprintf(stdout, "%s create the %dth thread failed: %m\n", tag, i);
			exit(1);
		}
	}

	for (int i = 0; i < tcnt; ++i) {
		pthread_join(tids[i], NULL);
	}

	fprintf(stdout, "%s done\n", tag);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x38f0(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x198e(%rip), %rsi      # 0x3070
leaq 0x1b36(%rip), %rdx      # 0x321f
xorl %eax, %eax
callq 0x11f0
movl 0x3a62(%rip), %eax      # 0x5158
movq %rsp, %r13
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
subq %rcx, %r13
movq %r13, %rsp
testl %eax, %eax
jle 0x174e
xorl %ebx, %ebx
leaq 0x381(%rip), %r14       # 0x1a99
movq %r13, %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1260
movl %eax, %r12d
callq 0x1040
movl %r12d, (%rax)
testl %r12d, %r12d
jne 0x17a2
incq %rbx
movslq 0x3a13(%rip), %rax      # 0x5158
addq $0x8, %r15
cmpq %rax, %rbx
jl 0x171b
cmpl $0x0, 0x3a03(%rip)      # 0x5158
jle 0x1774
xorl %ebx, %ebx
movq (%r13,%rbx,8), %rdi
xorl %esi, %esi
callq 0x1140
incq %rbx
movslq 0x39e9(%rip), %rax      # 0x5158
cmpq %rax, %rbx
jl 0x1759
movq 0x384d(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x190f(%rip), %rsi      # 0x3094
leaq 0x1a93(%rip), %rdx      # 0x321f
xorl %eax, %eax
callq 0x11f0
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x381f(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x1a85(%rip), %rsi      # 0x3238
leaq 0x1a65(%rip), %rdx      # 0x321f
movl %ebx, %ecx
xorl %eax, %eax
callq 0x11f0
movl $0x1, %edi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O1/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _send_req(int, int, int, char const*)
static void __send_req(int fd, int cmd, int size, const char *tag)
{
	struct proto_h16_head *h; 
	int msize = size + sizeof(*h);

	char *reqbuf = new char[msize];	
	h = (struct proto_h16_head *)reqbuf;

	h->len = msize;
	h->cmd = cmd;
	h->ver = 1;
	h->syn = 2;
	h->ack = 3;

	if (size >= (int)sizeof(int)) {
		*(int *)(reqbuf + sizeof *h) = random() % 3000;
	}	

	ssize_t wlen = beyondy::XbsWriteN(fd, reqbuf, msize, timeout);
	if (wlen != msize) {
		fprintf(stdout, "FAIL: %s pkg-size=%d, write req failed: %m\n", tag, size);
		exit(1);
	}

	delete[] reqbuf;	
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %r13d
movl %edi, %ebp
leal 0x10(%r14), %eax
movslq %eax, %r15
movq %r15, %rdi
callq 0x1030
movq %rax, %r12
movl %r15d, (%rax)
movw %r13w, 0x4(%rax)
movw $0x1, 0x6(%rax)
movabsq $0x300000002, %rax      # imm = 0x300000002
movq %rax, 0x8(%r12)
cmpl $0x4, %r14d
jl 0x184a
callq 0x10c0
movq %rax, %rcx
movabsq $-0x513cc1e098ead65b, %rdx # imm = 0xAEC33E1F671529A5
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shrq $0xb, %rdx
addl %eax, %edx
imull $0xbb8, %edx, %eax      # imm = 0xBB8
subl %eax, %ecx
movl %ecx, 0x10(%r12)
movl $0x7530, %ecx           # imm = 0x7530
movl %ebp, %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1cb3
cmpq %r15, %rax
jne 0x1877
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11c0
movq 0x374a(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x184a(%rip), %rsi      # 0x30d2
movq %rbx, %rdx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x11f0
movl $0x1, %edi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O1/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _read_rsp(int, int, char const*)
static void __read_rsp(int fd, int size, const char *tag)
{
	int msize = size + sizeof(struct proto_h16_head);
	char *rspbuf = new char[msize];

	ssize_t rlen = beyondy::XbsReadN(fd, rspbuf, msize, timeout);
	if (rlen != msize) {
		fprintf(stdout, "FAIL: %s pkg-size=%d, read rsp failed: %m\n", tag, msize);
		exit(1);
	}

	// TODO: cksum rspbuf
	delete[] rspbuf;
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movl %edi, %ebp
addl $0x10, %ebx
movslq %ebx, %r12
movq %r12, %rdi
callq 0x1030
movq %rax, %r15
movl $0x7530, %ecx           # imm = 0x7530
movl %ebp, %edi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1eb1
cmpq %r12, %rax
jne 0x18e6
movq %r15, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11c0
movq 0x36db(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x1807(%rip), %rsi      # 0x30fe
movq %r14, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x11f0
movl $0x1, %edi
callq 0x11a0
// File: /workspace/github_cpp_makefile_star2_O1/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _test002_sender_entry(void*)
static void *__test002_sender_entry(void *p)
{
	static const char *tag = "test002: async-req-rsp sender";

	int fd = (int)(long)p;	
	for (int i = 0; i < scnt; ++i) {
		struct timeval t1, t2;

		gettimeofday(&t1, NULL);
		__send_req(fd, cmd, sizes[i], tag);

		gettimeofday(&t2, NULL);
		fprintf(stdout, "%s send req with pkg-size=%ld took %ldms\n", \
			tag, (long)sizes[i], DIFF_TV(&t1, &t2));
	}

	return NULL;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x186b(%rip), %r15      # 0x3190
movabsq $0x20c49ba5e353f7cf, %r12 # imm = 0x20C49BA5E353F7CF
leaq 0x1878(%rip), %r13      # 0x31ae
xorl %r14d, %r14d
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movl 0x3815(%rip), %esi      # 0x5160
leaq 0x197e(%rip), %rax      # 0x32d0
movl (%r14,%rax), %ebp
movl %ebx, %edi
movl %ebp, %edx
movq %r15, %rcx
callq 0x17cd
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movq 0x3653(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
movslq %ebp, %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rdx
imulq $0x3e8, %rdx, %rsi      # imm = 0x3E8
subq 0x20(%rsp), %rax
imulq %r12
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0x7, %rdx
addq %rdx, %r8
addq %rsi, %r8
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11f0
addq $0x4, %r14
cmpq $0x38, %r14
jne 0x1939
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _test002_reader_entry(void*)
static void *__test002_reader_entry(void *p)
{
	static const char *tag = "test002: async-req-rsp reader";

	int fd = (int)(long)p;
	for (int i = 0; i < scnt; ++i) {
		struct timeval t1, t2;

		gettimeofday(&t1, NULL);
		__read_rsp(fd, sizes[i], tag);

		gettimeofday(&t2, NULL);
		fprintf(stdout, "%s read rsp for pkg-size=%ld took %ldms\n", 
			tag, (long)sizes[i], DIFF_TV(&t1, &t2));
	}

	return NULL;	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x17ea(%rip), %r15      # 0x31d8
movabsq $0x20c49ba5e353f7cf, %r12 # imm = 0x20C49BA5E353F7CF
leaq 0x17f7(%rip), %r13      # 0x31f6
xorl %r14d, %r14d
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
leaq 0x18bb(%rip), %rax      # 0x32d0
movl (%r14,%rax), %ebp
movl %ebx, %edi
movl %ebp, %esi
movq %r15, %rdx
callq 0x189f
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movq 0x3590(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
movslq %ebp, %rcx
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
subq 0x18(%rsp), %rdx
imulq $0x3e8, %rdx, %rsi      # imm = 0x3E8
subq 0x20(%rsp), %rax
imulq %r12
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0x7, %rdx
addq %rdx, %r8
addq %rsi, %r8
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11f0
addq $0x4, %r14
cmpq $0x38, %r14
jne 0x1a02
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/roberty65[P]bServer/frame/testClient/testEcho.cpp
// Function: _test003_worker(void*)
static void *__test003_worker(void *p)
{
	static const char *tag = "test003: mt-sync-req-rsp-worker";

	int fd = beyondy::XbsClient(host, O_NONBLOCK, 30000);
	if (fd < 0) {
		fprintf(stdout, "%s connect failed: %m\n", tag);
		exit(1);
	}

	for (int i = 0; i < scnt; ++i) {
		struct timeval t1, t2, t3;

		gettimeofday(&t1, NULL);	
		__send_req(fd, cmd, sizes[i], tag);

		gettimeofday(&t2, NULL);
		__read_rsp(fd, sizes[i], tag);

		gettimeofday(&t3, NULL);
		fprintf(stdout, "%s pkg-size=%ld send took %ldms, read took %ld ms\n", \
			tag, (long)sizes[i], DIFF_TV(&t1, &t2), DIFF_TV(&t2, &t3));
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x36a2(%rip), %rdi      # 0x5150
movl $0x7530, %edx           # imm = 0x7530
movl $0x800, %esi            # imm = 0x800
callq 0x2547
testl %eax, %eax
js 0x1bce
movl %eax, %ebx
leaq 0x1790(%rip), %r15      # 0x325e
movabsq $0x20c49ba5e353f7cf, %r12 # imm = 0x20C49BA5E353F7CF
leaq 0x179f(%rip), %rbp      # 0x327e
xorl %r13d, %r13d
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movl 0x366c(%rip), %esi      # 0x5160
leaq 0x17d5(%rip), %rax      # 0x32d0
movl (%r13,%rax), %r14d
movl %ebx, %edi
movl %r14d, %edx
movq %r15, %rcx
callq 0x17cd
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0x189f
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1240
movq 0x348f(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
movslq %r14d, %rcx
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %r9
subq %rax, %r9
movq %rax, %r8
subq 0x28(%rsp), %r8
movq 0x10(%rsp), %rsi
subq %rdx, %rsi
movq %rdx, %rax
subq 0x30(%rsp), %rax
imulq $0x3e8, %r8, %r10       # imm = 0x3E8
imulq %r12
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0x7, %rdx
addq %rdx, %r8
addq %r10, %r8
imulq $0x3e8, %r9, %r10       # imm = 0x3E8
movq %rsi, %rax
imulq %r12
movq %rdx, %r9
shrq $0x3f, %r9
sarq $0x7, %rdx
addq %rdx, %r9
addq %r10, %r9
movq %rbp, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x11f0
addq $0x4, %r13
cmpq $0x38, %r13
jne 0x1ae2
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x33f3(%rip), %rax      # 0x4fc8
movq (%rax), %rdi
leaq 0x149e(%rip), %rsi      # 0x307d
leaq 0x1678(%rip), %rdx      # 0x325e
xorl %eax, %eax
callq 0x11f0
movl $0x1, %edi
callq 0x11a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/daltonbr[P]RayTracing/./src/vec3.h
// Function: random_in_unit_sphere()
vec3 random_in_unit_sphere()
{
    vec3 p;
    do
    {
        p = 2.0 * vec3(drand48(), drand48(), drand48()) - vec3(1, 1, 1);
    } while (p.squared_length() >= 1.0);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x20b0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, -0x20(%rbp)
callq 0x20b0
cvtsd2ss %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
callq 0x20b0
movaps -0x10(%rbp), %xmm4
movaps -0x20(%rbp), %xmm3
xorps %xmm1, %xmm1
cvtsd2ss %xmm0, %xmm1
addss %xmm3, %xmm3
addss %xmm4, %xmm4
addss %xmm1, %xmm1
movss 0x15c6e(%rip), %xmm0    # 0x18004
addss %xmm0, %xmm3
addss %xmm0, %xmm4
addss %xmm0, %xmm1
movaps %xmm4, %xmm0
mulss %xmm4, %xmm0
movaps %xmm3, %xmm2
mulss %xmm3, %xmm2
addss %xmm0, %xmm2
movaps %xmm1, %xmm0
mulss %xmm1, %xmm0
addss %xmm2, %xmm0
ucomiss 0x15c42(%rip), %xmm0    # 0x18008
jae 0x2354
unpcklps %xmm4, %xmm3            # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
movaps %xmm3, %xmm0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/daltonbr[P]RayTracing/./src/vec3.h
// Function: refract(vec3 const&, vec3 const&, float, vec3&)
bool refract(const vec3& v, const vec3& n, float ni_over_nt, vec3& refracted)
{
    vec3 uv = unit_vector(v);
    float dt = dot(uv, n);
    float discriminant = 1.0 - ni_over_nt * ni_over_nt * (1 - dt * dt);
    if (discriminant > 0)
    {
        refracted = ni_over_nt * (uv - n * dt) - n * sqrt(discriminant);
        return true;
    }
    else
    {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movaps %xmm0, %xmm10
movq %rsi, %r14
movsd (%rdi), %xmm7
movss 0x8(%rdi), %xmm8
movaps %xmm7, %xmm9
shufps $0x55, %xmm7, %xmm9     # xmm9 = xmm9[1,1],xmm7[1,1]
movaps %xmm9, %xmm0
mulss %xmm9, %xmm0
movaps %xmm7, %xmm1
mulss %xmm7, %xmm1
addss %xmm0, %xmm1
movaps %xmm8, %xmm0
mulss %xmm8, %xmm0
addss %xmm1, %xmm0
xorps %xmm12, %xmm12
ucomiss %xmm12, %xmm0
jb 0x248b
sqrtss %xmm0, %xmm0
jmp 0x24be
movaps %xmm7, -0x40(%rbp)
movss %xmm8, -0x18(%rbp)
movaps %xmm9, -0x30(%rbp)
movss %xmm10, -0x14(%rbp)
callq 0x21f0
xorps %xmm12, %xmm12
movss -0x14(%rbp), %xmm10
movaps -0x30(%rbp), %xmm9
movss -0x18(%rbp), %xmm8
movaps -0x40(%rbp), %xmm7
divss %xmm0, %xmm7
divss %xmm0, %xmm9
divss %xmm0, %xmm8
movss (%r14), %xmm1
movss 0x4(%r14), %xmm0
movaps %xmm9, %xmm2
mulss %xmm0, %xmm2
movaps %xmm7, %xmm4
mulss %xmm1, %xmm4
addss %xmm2, %xmm4
movss 0x8(%r14), %xmm2
movaps %xmm8, %xmm3
mulss %xmm2, %xmm3
addss %xmm4, %xmm3
movaps %xmm10, %xmm4
mulss %xmm10, %xmm4
movaps %xmm3, %xmm5
mulss %xmm3, %xmm5
movss 0x15af3(%rip), %xmm11   # 0x18008
movaps %xmm11, %xmm6
subss %xmm5, %xmm6
mulss %xmm4, %xmm6
subss %xmm6, %xmm11
ucomiss %xmm12, %xmm11
jbe 0x25d3
mulss %xmm3, %xmm1
mulss %xmm3, %xmm0
mulss %xmm3, %xmm2
subss %xmm1, %xmm7
subss %xmm0, %xmm9
subss %xmm2, %xmm8
mulss %xmm10, %xmm7
mulss %xmm10, %xmm9
mulss %xmm10, %xmm8
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm11
jb 0x256c
xorps %xmm0, %xmm0
sqrtss %xmm11, %xmm0
jmp 0x259f
movaps %xmm11, %xmm0
movaps %xmm7, -0x40(%rbp)
movss %xmm8, -0x18(%rbp)
movaps %xmm9, -0x30(%rbp)
movss %xmm11, -0x14(%rbp)
callq 0x21f0
movss -0x14(%rbp), %xmm11
movaps -0x30(%rbp), %xmm9
movss -0x18(%rbp), %xmm8
movaps -0x40(%rbp), %xmm7
movss (%r14), %xmm1
mulss %xmm0, %xmm1
movss 0x4(%r14), %xmm2
mulss %xmm0, %xmm2
mulss 0x8(%r14), %xmm0
subss %xmm0, %xmm8
subss %xmm1, %xmm7
subss %xmm2, %xmm9
unpcklps %xmm9, %xmm7            # xmm7 = xmm7[0],xmm9[0],xmm7[1],xmm9[1]
movlps %xmm7, (%rbx)
movss %xmm8, 0x8(%rbx)
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm11
seta %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/daltonbr[P]RayTracing/./src/hitable_list.h
// Function: hitable_list::hit(ray const&, float, float, hit_record&) const
bool hitable_list::hit(const ray& r, float t_min, float t_max, hit_record& rec) const
{
    hit_record temp_rec;
    bool hit_anything = false;
    double closest_so_far = t_max;
    for (int i = 0; i < list_size; i++)
    {
        if (list[i]->hit(r, t_min, closest_so_far, temp_rec))
        {
            hit_anything = true;
            closest_so_far = temp_rec.t;
            rec = temp_rec;
        }
    }
    return hit_anything;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm0, -0x2c(%rbp)
cmpl $0x0, 0x10(%rdi)
jle 0x2887
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
cvtss2sd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %rdi
xorps %xmm1, %xmm1
cvtsd2ss -0x38(%rbp), %xmm1
movq (%rdi), %rax
movq %r14, %rsi
movss -0x2c(%rbp), %xmm0
leaq -0x60(%rbp), %rdx
callq *(%rax)
testb %al, %al
je 0x2879
xorps %xmm0, %xmm0
cvtss2sd -0x60(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, 0x20(%rbx)
movups -0x60(%rbp), %xmm0
movups -0x50(%rbp), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movb $0x1, %r13b
incq %r12
movslq 0x10(%r15), %rax
cmpq %rax, %r12
jl 0x282d
jmp 0x288a
xorl %r13d, %r13d
andb $0x1, %r13b
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/daltonbr[P]RayTracing/./src/main.cpp
// Function: color(ray const&, hitable*, int)
vec3 color(const ray& r, hitable *world, int depth)
{
    hit_record rec;
    if (world->hit(r, 0.001, MAXFLOAT, rec))  // acne problem solved
    {
        ray scattered;
        vec3 attenuation;
        if (depth < 50 && rec.mat_ptr->scatter(r, rec, attenuation, scattered))
        {
            return attenuation * color(scattered, world, depth + 1);
        }
        else
        {
            return vec3(0, 0, 0);
        }
    }
    else
    {
        vec3 unit_direction = unit_vector(r.direction());
        float t = 0.5 * (unit_direction.y() + 1.0);
        // Lerping from white to blue in y
        return (1.0 - t) * vec3(1, 1, 1) + t * vec3(0.5, 0.7, 1.0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movss 0x112cc(%rip), %xmm0    # 0x1803c
movss 0x112c8(%rip), %xmm1    # 0x18040
leaq -0x80(%rbp), %rdx
movq %rsi, %rdi
movq %r15, %rsi
callq *(%rax)
testb %al, %al
je 0x6dec
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
cmpl $0x31, %ebx
jg 0x6e83
leaq -0x80(%rbp), %rdx
movq 0x20(%rdx), %rdi
movq (%rdi), %rax
leaq -0x24(%rbp), %rcx
leaq -0x58(%rbp), %r8
movq %r15, %rsi
callq *(%rax)
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
testb %al, %al
je 0x6e83
incl %ebx
leaq -0x58(%rbp), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x6d50
movss -0x24(%rbp), %xmm2
mulss %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
mulss -0x20(%rbp), %xmm0
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
mulss -0x1c(%rbp), %xmm1
jmp 0x6e83
movsd 0xc(%r15), %xmm1
movss 0x14(%r15), %xmm0
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
movaps %xmm3, %xmm2
mulss %xmm3, %xmm2
mulss %xmm1, %xmm1
addss %xmm2, %xmm1
mulss %xmm0, %xmm0
addss %xmm1, %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x6e24
sqrtss %xmm0, %xmm0
jmp 0x6e31
movaps %xmm3, -0x40(%rbp)
callq 0x21f0
movaps -0x40(%rbp), %xmm3
divss %xmm0, %xmm3
xorps %xmm0, %xmm0
cvtss2sd %xmm3, %xmm0
addsd 0x1342c(%rip), %xmm0    # 0x1a270
mulsd 0x1342c(%rip), %xmm0    # 0x1a278
cvtsd2ss %xmm0, %xmm0
movss 0x111b0(%rip), %xmm1    # 0x18008
subss %xmm0, %xmm1
movss 0x111cc(%rip), %xmm2    # 0x18030
mulss %xmm0, %xmm2
movss 0x111d4(%rip), %xmm3    # 0x18044
mulss %xmm0, %xmm3
addss %xmm1, %xmm2
addss %xmm1, %xmm3
unpcklps %xmm3, %xmm2            # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
addss %xmm0, %xmm1
movaps %xmm2, %xmm0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/daltonbr[P]RayTracing/./src/material.h
// Function: lambertian::scatter(ray const&, hit_record const&, vec3&, ray&) const
virtual bool scatter(const ray&  r_in, const hit_record& rec, vec3& attenuation, ray& scattered) const
    {
        vec3 target = rec.p + rec.normal + random_in_unit_sphere();
        scattered = ray(rec.p, target - rec.p);
        attenuation = albedo;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movss 0x4(%rdx), %xmm1
movss 0x8(%rdx), %xmm0
addss 0x10(%rdx), %xmm1
movaps %xmm1, -0x40(%rbp)
addss 0x14(%rdx), %xmm0
movss %xmm0, -0x28(%rbp)
movq %rdi, %r12
movss 0xc(%rdx), %xmm0
addss 0x18(%rdx), %xmm0
movss %xmm0, -0x24(%rbp)
callq 0x234c
movaps -0x40(%rbp), %xmm2
addss %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
addss -0x28(%rbp), %xmm0
addss -0x24(%rbp), %xmm1
subss 0x4(%r15), %xmm2
subss 0x8(%r15), %xmm0
subss 0xc(%r15), %xmm1
unpcklps %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movl 0xc(%r15), %eax
movq 0x4(%r15), %rcx
movq %rcx, (%r14)
movl %eax, 0x8(%r14)
movlps %xmm2, 0xc(%r14)
movss %xmm1, 0x14(%r14)
movl 0x10(%r12), %eax
movl %eax, 0x8(%rbx)
movq 0x8(%r12), %rax
movq %rax, (%rbx)
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::getAccountIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int User::getAccountIndex(string accountName) {
    for(int i = 0; i < accounts.size(); i++) {
        if(accounts[i].accountName.compare(accountName) == 0) {
            return i;
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rdi), %rdi
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq %rdi, 0x8(%r15)
je 0x470c
movq %rsi, %r14
movl $0x8, %r13d
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
addq %r13, %rdi
movq %r14, %rsi
callq 0x2040
testl %eax, %eax
je 0x4709
incq %r12
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
sarq $0x4, %rax
imulq %rbp, %rax
addq $0x30, %r13
cmpq %r12, %rax
ja 0x46da
jmp 0x470c
movl %r12d, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::deposit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
bool User::deposit(string accountName, double amount) {
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    if(amount <= 0) { return false; }
    accounts[index].balance += amount;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3450
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a8
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4777
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
setne %cl
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
setb %al
andb %cl, %al
je 0x47af
movapd %xmm1, %xmm0
movslq %ebp, %rcx
movq (%rbx), %rdx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addsd 0x28(%rdx,%rcx), %xmm0
movsd %xmm0, 0x28(%rdx,%rcx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x47d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::withdraw(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
bool User::withdraw(string accountName, double amount) {
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    if(amount <= 0 || amount > accounts[index].balance) { return false; }
    accounts[index].balance -= amount;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3450
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a8
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4835
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
setne %al
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm1, %xmm0
setb %cl
testb %al, %cl
je 0x4869
movslq %ebp, %rcx
movq (%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movsd 0x28(%rax,%rcx), %xmm0
ucomisd %xmm0, %xmm1
jbe 0x486d
xorl %eax, %eax
jmp 0x487e
addq %rcx, %rax
addq $0x28, %rax
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x48a3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::createAccount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::createAccount(string accountName) {
    if(!isAdmin()) return false;
    if(getAccountIndex(accountName) != -1) { return false; }
    account acc;
    acc.disabled = false;
    acc.isStudentPlan = false;
    acc.accountName = accountName;
    acc.balance = 0.00;
    cout << endl << "Account Balance is: 0.00" << endl;
    accounts.push_back(acc);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x490e
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x3450
movq %rbx, %rdi
movq %r15, %rsi
callq 0x46a8
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4909
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
je 0x491d
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movw $0x0, -0x18(%r15)
movq %r14, %rsi
callq 0x2140
movq $0x0, 0x48(%rsp)
movq 0x9672(%rip), %rdi      # 0xdfc8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq 0x9657(%rip), %rdi      # 0xdfc8
callq 0x2030
movq %rax, %rdi
callq 0x2180
movq %rax, %r14
leaq 0x5851(%rip), %rsi      # 0xa1d9
movl $0x18, %edx
movq %rax, %rdi
callq 0x2270
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x4cc4
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x49e0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2230
movb $0x1, %al
jmp 0x4910
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4a14
movq 0x10(%rsp), %rsi
jmp 0x4a0c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a14
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::disableAccount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::disableAccount(string accountName) {
    if(!isAdmin()) return false;
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    accounts[index].disabled = true;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x4a97
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3450
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a8
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a79
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
setne %al
je 0x4a99
movslq %ebp, %rax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movb $0x1, (%rcx,%rax)
movb $0x1, %al
jmp 0x4a99
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4abe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::isDisabled(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::isDisabled(string accountName) {
    if(!isAdmin()) return false;
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    return accounts[index].disabled;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x4b3b
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3450
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a8
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4b23
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
je 0x4b3b
movslq %ebp, %rax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
movb (%rcx,%rax), %al
jmp 0x4b3d
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4b62
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::deleteAccount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::deleteAccount(string accountName) {
    if(!isAdmin()) return false;
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    accounts.erase(accounts.begin() + index);
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x4be9
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3450
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a8
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4bc7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
setne %al
je 0x4beb
movslq %ebp, %rax
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x5026
movb $0x1, %al
jmp 0x4beb
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c10
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
// File: /workspace/github_cpp_makefile_star2_O1/Kyle-Alvares[P]SQA1/user.cpp
// Function: User::changePlan(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool User::changePlan(string accountName) {
    if(!isAdmin()) return false;
    int index = getAccountIndex(accountName);
    if(index == -1) { return false; }
    accounts[index].isStudentPlan = !accounts[index].isStudentPlan;
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0x80(%rdi)
jne 0x4c94
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x3450
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46a8
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4c75
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl $-0x1, %ebp
setne %al
je 0x4c96
movslq %ebp, %rax
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
xorb $0x1, 0x1(%rcx,%rax)
movb $0x1, %al
jmp 0x4c96
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4cbb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x23b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Kyle-Alvares[P]SQA1/request.cpp
// Function: req::askAccountName[abi:cxx11](User, int)
string req::askAccountName(User user, int valid)
{
    string accountName;
    cout << "Enter account name: ";
    cin >> accountName;
    while (user.getAccountIndex(accountName) == valid)
    {
        cerr << "Error: Invalid account name!" << endl;
        cout << "Enter account name: ";
        cin >> accountName;
    }
    return accountName;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, 0xc(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x4fae(%rip), %rdi      # 0xdfc8
leaq 0x170e(%rip), %rsi      # 0xa72f
movl $0x14, %edx
callq 0x2270
movq 0x4fa6(%rip), %rdi      # 0xdfd8
movq %rbx, %rsi
callq 0x22b0
leaq 0x28(%rsp), %rbp
leaq 0x18(%rsp), %r15
movq 0x4fa5(%rip), %r12      # 0xdff0
movq %rbp, 0x18(%rsp)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x3450
movq %r14, %rdi
movq %r15, %rsi
callq 0x46a8
movl %eax, %r13d
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x9087
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2230
cmpl 0xc(%rsp), %r13d
jne 0x90f6
movl $0x1c, %edx
movq %r12, %rdi
leaq 0x14d1(%rip), %rsi      # 0xa56e
callq 0x2270
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2200
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2180
movl $0x14, %edx
movq 0x4ef2(%rip), %rdi      # 0xdfc8
leaq 0x1652(%rip), %rsi      # 0xa72f
callq 0x2270
movq 0x4eef(%rip), %rdi      # 0xdfd8
movq %rbx, %rsi
callq 0x22b0
jmp 0x904b
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9126
movq %rax, %r14
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x9129
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x9129
movq %rax, %r14
movq (%rbx), %rdi
movq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x9141
movq (%rax), %rsi
incq %rsi
callq 0x2230
movq %r14, %rdi
callq 0x23b0