LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: ReadPar(char*, int&, int&, int&, int&, int&, int&, int&, int&)
int ReadPar(char filename[255], int &loci_size, int &predictor_size, int &cluster_size, int &bin_size, int &var_size, int &DH_num1, int &DH_num2, int &DH_num3)
{
	FILE *pFile;
	int param[8];
	pFile = fopen(filename, "rb");
	if (pFile != NULL)
	{
		std::cout << "Reading model parameter..." << std::endl;
		fread(param, sizeof(int), 8, pFile);
		loci_size = param[0];
		predictor_size = param[1];
		cluster_size = param[2];
		bin_size = param[3];
		var_size = param[4];
		DH_num1 = param[5];
		DH_num2 = param[6];
		DH_num3 = param[7];
		fclose(pFile);

	}
	else
	{
		std::cout << "Error! File " << filename << " not found!" << std::endl;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, -0x38(%rbp)
movq %r8, -0x30(%rbp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2e9f(%rip), %rsi      # 0x84ec
callq 0x2240
testq %rax, %rax
je 0x570f
movq %rax, %r15
movq 0x6973(%rip), %r14      # 0xbfd8
leaq 0x2e99(%rip), %rsi      # 0x8505
movl $0x1a, %edx
movq %r14, %rdi
callq 0x2230
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
leaq -0x60(%rbp), %r14
movl $0x4, %esi
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rcx
callq 0x22c0
movl (%r14), %eax
movl %eax, (%rbx)
movl 0x4(%r14), %eax
movl %eax, (%r13)
movl 0x8(%r14), %eax
movl %eax, (%r12)
movl 0xc(%r14), %eax
movq -0x30(%rbp), %rcx
movl %eax, (%rcx)
movl 0x10(%r14), %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
movl 0x14(%r14), %eax
movq 0x10(%rbp), %rcx
movl %eax, (%rcx)
movl 0x18(%r14), %eax
movq 0x18(%rbp), %rcx
movl %eax, (%rcx)
movl 0x1c(%r14), %eax
movq 0x20(%rbp), %rcx
movl %eax, (%rcx)
movq %r15, %rdi
callq 0x21f0
xorl %eax, %eax
jmp 0x57a2
movq 0x68c2(%rip), %rbx      # 0xbfd8
leaq 0x2db6(%rip), %rsi      # 0x84d3
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2230
testq %r14, %r14
je 0x574b
movq %r14, %rdi
callq 0x2100
movq 0x689a(%rip), %rdi      # 0xbfd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x2230
jmp 0x5762
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2360
leaq 0x2d77(%rip), %rsi      # 0x84e0
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2150
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: Regression(double**, double**, double**, int**, int, int, int)
void Regression(double **predictor, double **output, double **coef, int **predictor_idx, int var_length, int loci_length, int sample_size)
{
	for (int i = 0; i < loci_length; i++)
	{
		for (int j = 0; j < sample_size; j++)
		{
			output[j][i] = 0;
			for (int k = 0; k < var_length; k++)
			{
				output[j][i] += coef[k][i] * predictor[j][predictor_idx[k][i] - 1];               //index from 1 in library file.
			}

		}
	}
	return;
}

// Assembly:
testl %r9d, %r9d
jle 0x583e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r9d, %r9d
movl 0x10(%rbp), %r10d
movl %r8d, %r11d
xorl %ebx, %ebx
cmpl $0x0, 0x10(%rbp)
jle 0x582c
xorl %r14d, %r14d
movq (%rsi,%r14,8), %r15
movq $0x0, (%r15,%rbx,8)
testl %r8d, %r8d
jle 0x5824
movq (%rdi,%r14,8), %r12
movsd (%r15,%rbx,8), %xmm0
xorl %r13d, %r13d
movq (%rdx,%r13,8), %rax
movsd (%rax,%rbx,8), %xmm1
movq (%rcx,%r13,8), %rax
movslq (%rax,%rbx,4), %rax
mulsd -0x8(%r12,%rax,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%r15,%rbx,8)
incq %r13
cmpq %r13, %r11
jne 0x57fa
incq %r14
cmpq %r10, %r14
jne 0x57dc
incq %rbx
cmpq %r9, %rbx
jne 0x57d3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/WeiqiangZhou[P]BIRD/source/predict_function.cpp
// Function: ModelAverage(double**, double**, double**, double**, double**, int**, int, int)
void ModelAverage(double **output, double **DH_pre1, double **DH_pre2, double **DH_pre3, double **dis_matrix, int **DH_cluster, int loci_length, int sample_size)
{
	double weight;
	for (int i = 0; i < loci_length; i++)
	{
		for (int j = 0; j < sample_size; j++)
		{
			weight = dis_matrix[0][i] + dis_matrix[1][i] + dis_matrix[2][i] + 1;
			output[j][i] = (output[j][i] + DH_pre1[j][DH_cluster[0][i] - 1] * dis_matrix[0][i] + DH_pre2[j][DH_cluster[1][i] - 1] * dis_matrix[1][i] + DH_pre3[j][DH_cluster[2][i] - 1] * dis_matrix[2][i]) / weight ;               //index from 1 in library file.
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, -0x38(%rbp)
movq %r8, -0x30(%rbp)
movl 0x10(%rbp), %eax
testl %eax, %eax
jle 0x591e
movl %eax, %eax
movq %rax, -0x40(%rbp)
movl 0x18(%rbp), %r8d
xorl %ebx, %ebx
movsd 0x279d(%rip), %xmm0     # 0x8010
cmpl $0x0, 0x18(%rbp)
jle 0x5911
movq -0x30(%rbp), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
movq 0x10(%rax), %r12
movq -0x38(%rbp), %r9
movq (%r9), %rax
movq 0x8(%r9), %r10
movslq (%rax,%rbx,4), %r13
movslq (%r10,%rbx,4), %rax
movq 0x10(%r9), %r10
movslq (%r10,%rbx,4), %r10
xorl %r11d, %r11d
movsd (%r14,%rbx,8), %xmm1
movsd (%r15,%rbx,8), %xmm2
movsd (%r12,%rbx,8), %xmm3
movq (%rsi,%r11,8), %r9
movapd %xmm1, %xmm4
mulsd -0x8(%r9,%r13,8), %xmm1
movq (%rdx,%r11,8), %r9
addsd %xmm2, %xmm4
mulsd -0x8(%r9,%rax,8), %xmm2
movq (%rcx,%r11,8), %r9
addsd %xmm3, %xmm4
mulsd -0x8(%r9,%r10,8), %xmm3
movq (%rdi,%r11,8), %r9
addsd %xmm0, %xmm4
addsd (%r9,%rbx,8), %xmm1
addsd %xmm1, %xmm2
addsd %xmm2, %xmm3
divsd %xmm4, %xmm3
movsd %xmm3, (%r9,%rbx,8)
incq %r11
cmpq %r11, %r8
jne 0x58aa
incq %rbx
cmpq -0x40(%rbp), %rbx
jne 0x5873
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ahupowerdns[P]mcounter/./mcounter-single.hh
// Function: UnsharedCounterParent::get()
uint64_t UnsharedCounterParent::get()
{
  uint64_t ret=d_formerChildren;
  std::lock_guard<std::mutex> l(d_mutex);
  for(const auto& c : d_children) {
    ret += c->d_value;
  }
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movq 0x38(%rdi), %rbx
leaq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0x21d0
testl %eax, %eax
jne 0x244e
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x243d
movq 0x8(%rax), %rcx
addq (%rcx), %rbx
movq (%rax), %rax
jmp 0x242c
movq %r14, %rdi
callq 0x2100
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/point.cc
// Function: main
int main()
{
	cout << 10.0 << endl;         // prints 10
	cout << showpoint << 10.0     // prints 10.0000
	     << noshowpoint << endl;  // revert to default format 
	
	cout << 10.0 << endl;  // prints 10

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x2dfe(%rip), %rbx      # 0x3fd8
movsd 0xe26(%rip), %xmm0      # 0x2008
movq %rbx, %rdi
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x400, 0x18(%rbx,%rax) # imm = 0x400
movq %rbx, %rdi
movsd 0xdda(%rip), %xmm0      # 0x2008
callq 0x1080
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rcx
andl $0xfffffbff, 0x18(%r14,%rcx) # imm = 0xFFFFFBFF
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
movq %rbx, %rdi
movsd 0xd93(%rip), %xmm0      # 0x2008
callq 0x1080
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/rsync_upload.c
// Function: adler32
unsigned int adler32(unsigned char *data, unsigned int len)
{
	unsigned short a = 1, b = 0;
	unsigned int i;

	// Process each byte of the data in order
	for (i = 0; i < len; i++)
	{
		a = (a + data[i]) % MOD_ADLER;
		b = (b + a) % MOD_ADLER;
	}

	return (b << 16) | a;
}

// Assembly:
testl %esi, %esi
je 0x13f5
movl %esi, %ecx
movl $0x1, %r8d
xorl %edx, %edx
movl $0x80078071, %esi       # imm = 0x80078071
xorl %eax, %eax
movzbl (%rdi,%rdx), %r9d
addl %r8d, %r9d
movl %r9d, %r8d
imulq %rsi, %r9
shrq $0x2f, %r9
imull $0xfff1, %r9d, %r9d     # imm = 0xFFF1
subl %r9d, %r8d
addl %r8d, %eax
movq %rax, %r9
imulq %rsi, %r9
shrq $0x2f, %r9
imull $0xfff1, %r9d, %r9d     # imm = 0xFFF1
subl %r9d, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x13b1
shll $0x10, %eax
orl %r8d, %eax
retq
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/rsync_upload.c
// Function: Recv
int Recv(SOCKET sock, char *buffer, unsigned int size, int flag)
{
	unsigned int num_read = 0;

	while (num_read < size && num_read >= 0)
	{
		int ret = 0;

		ret = recv(sock, &buffer[num_read], size - num_read, flag);
		if (ret > 0)
		{
			num_read += ret;
			if (size > RECV_PROGRESS)
			{
				printf("Recv %d of %d\r", num_read, size);
			}
		}
		else
		{
			return ret;
		}
	}
	if (size > RECV_PROGRESS)
	{
		printf("\r\n");
	}
	return num_read;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r15
movl %edi, %r13d
xorl %ebx, %ebx
movl %ebp, %edx
subl %ebx, %edx
jbe 0x1865
movl %ebx, %esi
addq %r15, %rsi
movl %r13d, %edi
movl %r14d, %ecx
callq 0x1040
movq %rax, %r12
testl %r12d, %r12d
jle 0x1859
addl %r12d, %ebx
cmpl $0x2001, %ebp           # imm = 0x2001
jb 0x185e
leaq 0x27b8(%rip), %rdi      # 0x4004
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
jmp 0x185e
movl %r12d, 0x4(%rsp)
testl %r12d, %r12d
jg 0x181c
jmp 0x187d
cmpl $0x2001, %ebp           # imm = 0x2001
jb 0x1879
leaq 0x2cfd(%rip), %rdi      # 0x4571
callq 0x1070
movl %ebx, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/rsync_upload.c
// Function: Send
int Send(SOCKET sock, char *buffer, int size, int flag)
{
	int num_sent = 0;

	while (num_sent < size && num_sent >= 0)
	{
		int ret = 0;

		ret = send(sock, &buffer[num_sent], size - num_sent, flag);
		if (ret > 0)
		{
			num_sent += ret;

			if (size > RECV_PROGRESS)
			{
				printf("Sent %d of %d\r", num_sent, size);
			}
		}
		else
		{
			return ret;
		}
	}
	if (size > RECV_PROGRESS)
	{
		printf("\r\n");
	}
	return num_sent;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r15
movl %edi, %r13d
xorl %ebx, %ebx
movl %ebp, %eax
subl %ebx, %eax
jle 0x18f4
movl %ebx, %esi
addq %r15, %rsi
movslq %eax, %rdx
movl %r13d, %edi
movl %r14d, %ecx
callq 0x10d0
movq %rax, %r12
testl %r12d, %r12d
jle 0x18e8
addl %r12d, %ebx
cmpl $0x2001, %ebp           # imm = 0x2001
jl 0x18ed
leaq 0x2738(%rip), %rdi      # 0x4013
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
jmp 0x18ed
movl %r12d, 0x4(%rsp)
testl %r12d, %r12d
jg 0x18a8
jmp 0x190c
cmpl $0x2001, %ebp           # imm = 0x2001
jl 0x1908
leaq 0x2c6e(%rip), %rdi      # 0x4571
callq 0x1070
movl %ebx, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/rsync_upload.c
// Function: write_file
int write_file(char *filename, const char *bytes, int size)
{
    FILE *fp = fopen(filename, "wb");
    int ret;
    
    if (fp == NULL)
    {
        perror("Unable to open file for writing");
        return -1;
    }
    
    ret = fwrite(bytes, sizeof(char), size, fp);
    
    if (ret != size)
    {
		perror("fwrite didnt write all data");
		fclose(fp);
        return -1;
    }
    fclose(fp);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
leaq 0x264b(%rip), %rsi      # 0x4025
callq 0x11b0
testq %rax, %rax
je 0x1a17
movq %rax, %rbx
movslq %ebp, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x1210
cmpl %r15d, %eax
jne 0x1a25
movq %rbx, %rdi
callq 0x10a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x260a(%rip), %rdi      # 0x4028
callq 0x11c0
jmp 0x1a39
leaq 0x261c(%rip), %rdi      # 0x4048
callq 0x11c0
movq %rbx, %rdi
callq 0x10a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1a0c
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/rsync_upload.c
// Function: assemble_download
int assemble_download(char *response, unsigned int rfile_size, char *data, unsigned int file_size, block_t *block_offset, int num_block, unsigned int block_size, char *diff, unsigned int diff_size)
{
	unsigned int diff_pos = 0;

	memset(response, 0, rfile_size);
	for (unsigned int i = 0; i < rfile_size; i++)
	{
		int skip = 0;

		// check if this byte is in a block
		for (int j = 0; j < num_block; j++)
		{
			if (i >= block_offset[j].offset && i < block_offset[j].offset + block_size)
			{
				// we are in this block, memcpy and skip to the end of this block
				memcpy(&response[i], &data[j * block_size], block_offset[j].length);
				i = block_offset[j].offset + block_size - 1;
				skip = 1;
				break;
			}
		}

		if (skip)
		{
			// restart again as we move passed a block
			continue;
		}

		// This byte comes from the downloaded pile
		response[i] = diff[diff_pos++];
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebx
movq %r8, %r14
movq %rdx, 0x20(%rsp)
movl %esi, %ebp
movl %esi, %edx
xorl %r15d, %r15d
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
callq 0x1100
testl %ebp, %ebp
je 0x1b5a
movl %ebp, %esi
movl %ebx, %edx
movl 0x60(%rsp), %r9d
testl %ebx, %ebx
setg 0x3(%rsp)
leal -0x1(%r9), %eax
movl %eax, 0x4(%rsp)
movslq %ebx, %rax
movq %rax, 0x10(%rsp)
movl %eax, %r12d
xorl %r13d, %r13d
movl %ebx, 0xc(%rsp)
movl %ebp, 0x8(%rsp)
testl %edx, %edx
jle 0x1ac4
movl (%r14), %eax
cmpl %eax, %r15d
setae %cl
addl %r9d, %eax
cmpl %eax, %r15d
setb %al
testb %al, %cl
je 0x1aca
xorl %ebp, %ebp
movb 0x3(%rsp), %bl
jmp 0x1af3
movb 0x3(%rsp), %bl
jmp 0x1b31
movl $0x1, %ebp
cmpq %rbp, %r12
je 0x1b29
movl (%r14,%rbp,8), %eax
incq %rbp
cmpl %eax, %r15d
jb 0x1acf
addl %r9d, %eax
cmpl %eax, %r15d
jae 0x1acf
decq %rbp
cmpq 0x10(%rsp), %rbp
setl %bl
movl %r15d, %edi
addq 0x18(%rsp), %rdi
movl %ebp, %esi
imull %r9d, %esi
addq 0x20(%rsp), %rsi
movl 0x4(%r14,%rbp,8), %edx
movq %r9, %r15
callq 0x1150
movq %r15, %r9
movl (%r14,%rbp,8), %r15d
addl 0x4(%rsp), %r15d
movl 0xc(%rsp), %edx
movl 0x8(%rsp), %esi
jmp 0x1b31
cmpq 0x10(%rsp), %rbp
setl %bl
testb %bl, %bl
jne 0x1b4e
movl %r13d, %eax
incl %r13d
movq 0x68(%rsp), %rcx
movb (%rcx,%rax), %al
movl %r15d, %ecx
movq 0x18(%rsp), %rdi
movb %al, (%rdi,%rcx)
incl %r15d
cmpl %esi, %r15d
jb 0x1aa2
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/akw0088[P]openssl/rsync_upload.c
// Function: StripChars
void StripChars(const char *in, char *out, char *stripc)
{
    while (*in)
    {
    	int flag = 0;

		int length = strlen(stripc);
		for(int i = 0; i < length; i++)
		{
			if (*in == stripc[i])
			{
				if (stripc[i] == '.' && strlen(in) == 4)
				{
					continue;
				}
				flag = 1;
				break;
			}
		}

		if (flag)
		{
			in++;
			continue;
		}
        *out++ = *in++;
    }
    *out = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0x2465
movq %rdx, %r14
movq %rdi, %r15
movq %r14, %rdi
callq 0x10c0
movq %rax, %r12
testl %r12d, %r12d
jle 0x2453
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movb (%r14,%r13), %al
cmpb %al, %bpl
jne 0x244b
cmpb $0x2e, %al
jne 0x2459
movq %r15, %rdi
callq 0x10c0
cmpq $0x4, %rax
jne 0x2459
incq %r13
cmpq %r13, %r12
jne 0x2430
movb %bpl, (%rbx)
incq %rbx
movb 0x1(%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0x2416
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/rsync_upload.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 3)
	{
		printf("Usage: rsync_upload filename port\r\n");
		return 0;
	}

#ifdef WIN32
	WSADATA		WSAData;

	WSAStartup(MAKEWORD(2, 0), &WSAData);
#endif

	unsigned short port = atoi(argv[2]);
	printf("Attempting to upload %s to client connecting on port %d\r\n", argv[1], (int)port);
	rsync_file_upload(argv[1], port);
	return 0;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jg 0x2cd5
leaq 0x1903(%rip), %rdi      # 0x45d1
callq 0x1070
jmp 0x2d03
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x11e0
movq 0x8(%rbx), %rsi
movzwl %ax, %ebp
leaq 0x15ec(%rip), %rdi      # 0x42db
movl %ebp, %edx
xorl %eax, %eax
callq 0x10e0
movq 0x8(%rbx), %rdi
movl %ebp, %esi
callq 0x2477
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/md5sum.c
// Function: md5sum
void md5sum(char *data, unsigned int size, char *hash)
{
	md5_state_t	state;
	md5_byte_t	digest[16];

	md5_init(&state);
	md5_append(&state, (const md5_byte_t *)data, size);
	md5_finish(&state, digest);

	sprintf(hash, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
		digest[0], digest[1], digest[2], digest[3],
		digest[4], digest[5], digest[6], digest[7],
		digest[8], digest[9], digest[10], digest[11],
		digest[12], digest[13], digest[14], digest[15]
	);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
movaps 0x18d4(%rip), %xmm0     # 0x4600
leaq 0x40(%rsp), %r14
movaps %xmm0, (%r14)
movabsq $0x1032547698badcfe, %rax # imm = 0x1032547698BADCFE
movq %rax, 0x10(%r14)
movq %r14, %rdi
callq 0x2e23
leaq 0x30(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f13
movzbl (%r15), %edx
movzbl 0x1(%r15), %ecx
movzbl 0x2(%r15), %r8d
movzbl 0x3(%r15), %r9d
movzbl 0x4(%r15), %eax
movq %rax, 0x28(%rsp)
movzbl 0x5(%r15), %eax
movq %rax, 0x20(%rsp)
movzbl 0x6(%r15), %eax
movq %rax, 0x18(%rsp)
movzbl 0x7(%r15), %eax
movq %rax, 0x10(%rsp)
movzbl 0x8(%r15), %eax
movq %rax, 0x8(%rsp)
movzbl 0x9(%r15), %ebp
movzbl 0xa(%r15), %r10d
movzbl 0xb(%r15), %r11d
movzbl 0xc(%r15), %r14d
movzbl 0xd(%r15), %r12d
movzbl 0xe(%r15), %r13d
movzbl 0xf(%r15), %r15d
leaq 0x1886(%rip), %rsi      # 0x4650
movq %rbx, %rdi
xorl %eax, %eax
pushq %r15
pushq %r13
pushq %r12
pushq %r14
pushq %r11
pushq %r10
pushq %rbp
pushq 0x40(%rsp)
pushq 0x50(%rsp)
pushq 0x60(%rsp)
pushq 0x70(%rsp)
pushq 0x80(%rsp)
callq 0x11f0
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/md5sum.c
// Function: md5_append
void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
{
    const md5_byte_t *p = data;
    int left = nbytes;
    int offset = (pms->count[0] >> 3) & 63;
    md5_word_t nbits = (md5_word_t)(nbytes << 3);

    if (nbytes <= 0)
	return;

    /* Update the message length. */
    pms->count[1] += nbytes >> 29;
    pms->count[0] += nbits;
    if (pms->count[0] < nbits)
	pms->count[1]++;

    /* Process an initial partial block. */
    if (offset) {
	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);

	memcpy(pms->buf + offset, p, copy);
	if (offset + copy < 64)
	    return;
	p += copy;
	left -= copy;
	md5_process(pms, pms->buf);
    }

    /* Process full blocks. */
    for (; left >= 64; p += 64, left -= 64)
	md5_process(pms, p);

    /* Process a final partial block. */
    if (left)
	memcpy(pms->buf, p, left);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
jle 0x2f04
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %ecx
movl %ecx, %r13d
shrl $0x3, %r13d
andl $0x3f, %r13d
movl %edx, %eax
shrl $0x1d, %eax
addl 0x4(%rdi), %eax
leal (,%r15,8), %edx
movl %eax, 0x4(%rdi)
addl %ecx, %edx
movl %edx, (%rdi)
jae 0x2e6b
incl %eax
movl %eax, 0x4(%r14)
testl %r13d, %r13d
je 0x2eb9
leal (%r15,%r13), %eax
movl $0x40, %r12d
subl %r13d, %r12d
cmpl $0x41, %eax
cmovll %r15d, %r12d
leaq (%r14,%r13), %rdi
addq $0x18, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1150
movl %r12d, %ebp
addl %r13d, %ebp
cmpl $0x40, %ebp
jl 0x2eb4
leaq 0x18(%r14), %rsi
addq %r12, %rbx
subl %r12d, %r15d
movq %r14, %rdi
callq 0x301b
cmpl $0x40, %ebp
jl 0x2f04
cmpl $0x40, %r15d
jl 0x2edd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x301b
addq $0x40, %rbx
leal -0x40(%r15), %eax
cmpl $0x7f, %r15d
movl %eax, %r15d
jg 0x2ebf
jmp 0x2ee0
movl %r15d, %eax
testl %eax, %eax
je 0x2f04
addq $0x18, %r14
movslq %eax, %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1150
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/md5sum.c
// Function: md5_finish
void md5_finish(md5_state_t *pms, md5_byte_t digest[16])
{
    static const md5_byte_t pad[64] = {
	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    md5_byte_t data[8];
    int i;

    /* Save the length before padding. */
    for (i = 0; i < 8; ++i)
	data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
    /* Pad to 56 bytes mod 64. */
    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
    /* Append the length. */
    md5_append(pms, data, 8);
    for (i = 0; i < 16; ++i)
	digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movdqa 0x16eb(%rip), %xmm0     # 0x4610
xorl %eax, %eax
movdqa 0x16f1(%rip), %xmm1     # 0x4620
movaps 0x16fa(%rip), %xmm2     # 0x4630
movdqa 0x1702(%rip), %xmm3     # 0x4640
movd (%r14,%rax), %xmm4
pshufd $0x0, %xmm4, %xmm4      # xmm4 = xmm4[0,0,0,0]
movdqa %xmm0, %xmm5
pslld $0x3, %xmm5
pand %xmm1, %xmm5
pshuflw $0xfe, %xmm5, %xmm6     # xmm6 = xmm5[2,3,3,3,4,5,6,7]
movdqa %xmm4, %xmm7
psrld %xmm6, %xmm7
pshuflw $0x54, %xmm5, %xmm6     # xmm6 = xmm5[0,1,1,1,4,5,6,7]
movdqa %xmm4, %xmm8
psrld %xmm6, %xmm8
punpcklqdq %xmm7, %xmm8    # xmm8 = xmm8[0],xmm7[0]
pshufd $0xee, %xmm5, %xmm5     # xmm5 = xmm5[2,3,2,3]
pshuflw $0xfe, %xmm5, %xmm6     # xmm6 = xmm5[2,3,3,3,4,5,6,7]
movdqa %xmm4, %xmm7
psrld %xmm6, %xmm7
pshuflw $0x54, %xmm5, %xmm5     # xmm5 = xmm5[0,1,1,1,4,5,6,7]
psrld %xmm5, %xmm4
punpckhqdq %xmm7, %xmm4    # xmm4 = xmm4[1],xmm7[1]
shufps $0xcc, %xmm4, %xmm8     # xmm8 = xmm8[0,3],xmm4[0,3]
andps %xmm2, %xmm8
packuswb %xmm8, %xmm8
packuswb %xmm8, %xmm8
movd %xmm8, (%rsp,%rax)
addq $0x4, %rax
paddd %xmm3, %xmm0
cmpq $0x8, %rax
jne 0x2f3e
movl (%r14), %eax
shrl $0x3, %eax
movl $0x37, %edx
subl %eax, %edx
andl $0x3f, %edx
incl %edx
leaq 0x16ca(%rip), %rsi      # 0x46a0
movq %r14, %rdi
callq 0x2e23
movq %rsp, %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x2e23
xorl %eax, %eax
xorl %edx, %edx
movl %edx, %ecx
andl $-0x4, %ecx
movl 0x8(%r14,%rcx), %esi
movl %eax, %ecx
andb $0x18, %cl
shrl %cl, %esi
movb %sil, (%rbx,%rdx)
incq %rdx
addl $0x8, %eax
cmpq $0x10, %rdx
jne 0x2ff2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/0918nobita[P]algorithm/polynomial2.cc
// Function: main
int main() {
  int X0, N;
  std::cin >> X0 >> N;
  std::vector<int> A(N);

  for (int i = 0; i < N; i++) {
    std::cin >> A[i];
  }

  if (N < 1) {
    std::cout << 0 << std::endl;
  } else {
    int S = A[N - 1];

    for (int i = N - 1; i >= 1; i--) {
      S = S * X0 + A[i - 1];
    }

    std::cout << S << std::endl;
  }
  return EXIT_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0x2d84(%rip), %rdi      # 0x3fe0
leaq 0x14(%rsp), %rsi
callq 0x1070
leaq 0x10(%rsp), %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1070
movslq (%rbx), %rsi
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x13a0
movl (%rbx), %edx
testl %edx, %edx
jle 0x12bc
xorl %r14d, %r14d
movq 0x2d48(%rip), %rbx      # 0x3fe0
xorl %r15d, %r15d
movq 0x18(%rsp), %rsi
addq %r14, %rsi
movq %rbx, %rdi
callq 0x1070
incq %r15
movslq 0x10(%rsp), %rdx
addq $0x4, %r14
cmpq %rdx, %r15
jl 0x129b
testl %edx, %edx
jle 0x131f
movq 0x18(%rsp), %rax
movl %edx, %ecx
movl -0x4(%rax,%rcx,4), %esi
cmpl $0x1, %edx
je 0x12e7
movl 0x14(%rsp), %edx
incq %rcx
imull %edx, %esi
addl -0xc(%rax,%rcx,4), %esi
decq %rcx
cmpq $0x2, %rcx
jg 0x12d7
movq 0x2ce2(%rip), %rdi      # 0x3fd0
callq 0x10f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
jmp 0x1357
movq 0x2caa(%rip), %rdi      # 0x3fd0
xorl %esi, %esi
callq 0x10f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1080
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x136e
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x137e
jmp 0x137e
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1398
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10d0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/././include/assert.hpp
// Function: print_prompt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<void ()> const&)
void print_prompt(string prompt, const function<void()>& callback){
    char boolean = 'N';
    cout << prompt << " [Y/N] (Default N) : ";
    cin >> boolean;
    if(boolean == 'Y' || boolean == 'y'){
        callback();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq -0x11(%rbp), %r14
movb $0x4e, (%r14)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x1e588(%rip), %rdi     # 0x22f78
callq 0x4320
leaq 0x1560c(%rip), %rsi     # 0x1a008
movl $0x15, %edx
movq %rax, %rdi
callq 0x4320
movq 0x1e5b0(%rip), %rdi     # 0x22fc0
movq %r14, %rsi
callq 0x4370
movb (%r14), %al
andb $-0x21, %al
cmpb $0x59, %al
jne 0x4a2e
cmpq $0x0, 0x10(%rbx)
je 0x4a37
movq %rbx, %rdi
callq *0x18(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x4130
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/././dep/rang.hpp
// Function: std::enable_if<std::is_same<rang::fg, rang::style>::value || std::is_same<rang::fg, rang::fg>::value || std::is_same<rang::fg, rang::bg>::value || std::is_same<rang::fg, rang::fgB>::value || std::is_same<rang::fg, rang::bgB>::value, std::ostream&>::type rang::operator<<<rang::fg>(std::ostream&, rang::fg)
inline rang_implementation::enableStd<T> operator<<(std::ostream &os,
                                                    const T value)
{
    const control option = rang_implementation::controlMode();
    switch (option) {
        case control::Auto:
            return rang_implementation::supportsColor()
                && rang_implementation::isTerminal(os.rdbuf())
              ? rang_implementation::setColor(os, value)
              : os;
        case control::Force: return rang_implementation::setColor(os, value);
        default: return os;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movl 0x13fa3(%rip), %eax     # 0x23280
cmpl $0x2, %eax
je 0xf312
cmpl $0x1, %eax
jne 0xf348
movb 0x13ffb(%rip), %al      # 0x232e8
testb %al, %al
je 0xf354
cmpb $0x1, 0x13fea(%rip)     # 0x232e2
jne 0xf348
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rbx,%rax), %rdi
callq 0xf68f
testb %al, %al
je 0xf348
leaq 0xb140(%rip), %rsi      # 0x1a459
movl $0x2, %edx
movq %rbx, %rdi
callq 0x4320
movq %rbx, %rdi
movl %r14d, %esi
callq 0x4460
movq %rax, %rbx
leaq 0xb79e(%rip), %rsi      # 0x1aad9
movl $0x1, %edx
movq %rax, %rdi
callq 0x4320
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x13f8d(%rip), %rdi     # 0x232e8
callq 0x44b0
testl %eax, %eax
je 0xf2f1
leaq -0x11(%rbp), %rdi
callq 0xf712
movb %al, 0x13f6f(%rip)      # 0x232e2
leaq 0x13f6e(%rip), %rdi     # 0x232e8
callq 0x41d0
jmp 0xf2f1
movq %rax, %rdi
callq 0xf38c
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/././dep/rang.hpp
// Function: rang::rang_implementation::isTerminal(std::basic_streambuf<char, std::char_traits<char>> const*)
inline bool isTerminal(const std::streambuf *osbuf) noexcept
    {
        using std::cerr;
        using std::clog;
        using std::cout;
#if defined(OS_LINUX) || defined(OS_MAC)
        if (osbuf == cout.rdbuf()) {
            static const bool cout_term = isatty(fileno(stdout)) != 0;
            return cout_term;
        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
            static const bool cerr_term = isatty(fileno(stderr)) != 0;
            return cerr_term;
        }
#elif defined(OS_WIN)
        if (osbuf == cout.rdbuf()) {
            static const bool cout_term
              = (_isatty(_fileno(stdout)) || isMsysPty(_fileno(stdout)));
            return cout_term;
        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
            static const bool cerr_term
              = (_isatty(_fileno(stderr)) || isMsysPty(_fileno(stderr)));
            return cerr_term;
        }
#endif
        return false;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x138de(%rip), %rax     # 0x22f78
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq %rdi, 0xe8(%rax,%rcx)
je 0xf6f1
movq 0x1392e(%rip), %rax     # 0x22fe0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq %rdi, 0xe8(%rax,%rcx)
je 0xf6df
movq 0x1386e(%rip), %rax     # 0x22f38
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpq %rdi, 0xe8(%rax,%rcx)
je 0xf6df
xorl %eax, %eax
jmp 0xf701
movb 0x13c23(%rip), %al      # 0x23308
testb %al, %al
je 0xf703
movb 0x13c11(%rip), %al      # 0x23300
jmp 0xf701
movb 0x13c01(%rip), %al      # 0x232f8
testb %al, %al
je 0xf70a
movb 0x13bef(%rip), %al      # 0x232f0
popq %rbp
retq
callq 0x4500
jmp 0xf6e9
callq 0x4542
jmp 0xf6fb
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/User.cpp
// Function: validate_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static void validate_name(string name){
    if(name.length() > User::MaxNameLength){
        throw out_of_range("Name max character limit exceeded");
    }
    int i = 0;
    while(i < name.length()){
        if(isalpha(name[i])){
            i++;
        }else{
            throw invalid_name("Invalid Name: only standard english alphabets are allowed");
        };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rbx
leaq 0x136f8(%rip), %rax     # 0x232d0
movslq (%rax), %rax
cmpq %rax, %rbx
ja 0xfc41
testq %rbx, %rbx
je 0xfc01
movq (%rdi), %r14
xorl %r15d, %r15d
movsbl (%r14,%r15), %edi
callq 0x43f0
testl %eax, %eax
je 0xfc0c
incq %r15
cmpq %r15, %rbx
jne 0xfbeb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
leaq 0x13073(%rip), %rcx     # 0x22c90
movq %rcx, (%rax)
leaq 0xb84d(%rip), %rcx      # 0x1b474
movq %rcx, 0x8(%rax)
leaq 0x13036(%rip), %rsi     # 0x22c68
movq 0x1338f(%rip), %rdx     # 0x22fc8
movq %rax, %rdi
callq 0x4440
movl $0x10, %edi
callq 0x4170
movq %rax, %rbx
leaq 0xb7fd(%rip), %rsi      # 0x1b452
movq %rax, %rdi
callq 0x4080
movq 0x13344(%rip), %rsi     # 0x22fa8
movq 0x1331d(%rip), %rdx     # 0x22f88
movq %rbx, %rdi
callq 0x4440
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/Driver.cpp
// Function: operator<<(std::ostream&, Driver const&)
ostream& operator<<(ostream& output, const Driver& D){
    output << "\t{" <<
        "\n\t\tuuid : " << D.uuid <<
        "\n\t\tfirstname : " << D.firstname <<
        "\n\t\tlastname : " << D.lastname <<
        "\n\t\tdriving license number : " << D.driving_license_num <<
        "\n\t\tStatus : " << (D.status == IDLE ? "IDLE" : "ONSHIFT") <<
        "\n\t}" <<
        endl;
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb4b7(%rip), %rsi      # 0x1b4cc
movl $0x2, %edx
callq 0x4320
leaq 0xb4a9(%rip), %rsi      # 0x1b4cf
movl $0xa, %edx
movq %rbx, %rdi
callq 0x4320
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %rbx, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb48d(%rip), %rsi      # 0x1b4da
movl $0xf, %edx
movq %rax, %rdi
callq 0x4320
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb477(%rip), %rsi      # 0x1b4ea
movl $0xe, %edx
movq %rax, %rdi
callq 0x4320
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb45f(%rip), %rsi      # 0x1b4f9
movl $0x1c, %edx
movq %rax, %rdi
callq 0x4320
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb455(%rip), %rsi      # 0x1b516
movl $0xc, %edx
movq %rax, %rdi
callq 0x4320
xorl %eax, %eax
cmpl $0x1, 0x80(%r14)
setne %al
leaq 0xbb23(%rip), %rcx      # 0x1bc05
leaq 0xb8d4(%rip), %rsi      # 0x1b9bd
cmoveq %rcx, %rsi
leaq (%rax,%rax,2), %rdx
addq $0x4, %rdx
movq %r15, %rdi
callq 0x4320
leaq 0xb41f(%rip), %rsi      # 0x1b523
movl $0x3, %edx
movq %r15, %rdi
callq 0x4320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/Customer.cpp
// Function: operator<<(std::ostream&, Customer const&)
ostream& operator<<(ostream& output, const Customer& C){
    output << "\t{" <<
        "\n\t\tuuid : " << C.uuid <<
        "\n\t\tfirstname : " << C.firstname <<
        "\n\t\tlastname : " << C.lastname <<
        "\n\t\tbalance : " << C.balance <<
        "\n\t\tstatus : " << (C.status == IDLE ? "IDLE" : "ONSHIFT") <<
        "\n\t}" <<
        endl;
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb18e(%rip), %rsi      # 0x1b4cc
movl $0x2, %edx
callq 0x4320
leaq 0xb180(%rip), %rsi      # 0x1b4cf
movl $0xa, %edx
movq %rbx, %rdi
callq 0x4320
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %rbx, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb164(%rip), %rsi      # 0x1b4da
movl $0xf, %edx
movq %rax, %rdi
callq 0x4320
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb14e(%rip), %rsi      # 0x1b4ea
movl $0xe, %edx
movq %rax, %rdi
callq 0x4320
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xb164(%rip), %rsi      # 0x1b527
movl $0xd, %edx
movq %rax, %rdi
callq 0x4320
movl 0x60(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0xb14f(%rip), %rsi      # 0x1b535
movl $0xc, %edx
movq %rax, %rdi
callq 0x4320
xorl %eax, %eax
cmpl $0x1, 0x64(%r14)
setne %al
leaq 0xb801(%rip), %rcx      # 0x1bc05
leaq 0xb5b2(%rip), %rsi      # 0x1b9bd
cmoveq %rcx, %rsi
leaq (%rax,%rax,2), %rdx
addq $0x4, %rdx
movq %r15, %rdi
callq 0x4320
leaq 0xb0fd(%rip), %rsi      # 0x1b523
movl $0x3, %edx
movq %r15, %rdi
callq 0x4320
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/Shift.cpp
// Function: operator<<(std::ostream&, Shift const&)
ostream& operator<<(ostream& output, const Shift& S){
    output << "\t{" <<
        "\n\t\tcustomer uuid : " << S.customer_uuid <<
        "\n\t\tdriver in charge uuid : " << S.driver_in_charge_uuid <<
        "\n\t\ttaxi id : " << S.car_id <<
        "\n\t\ttaxi fare amount (per kilometer) : " << S.taxi_fare_amount <<
        "\n\t\tdriver waitin charges : " << S.waiting_charges <<
        "\n\t}" <<
        endl;
    return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xaab8(%rip), %rsi      # 0x1b4cc
movl $0x2, %edx
callq 0x4320
leaq 0xab42(%rip), %rsi      # 0x1b567
movl $0x13, %edx
movq %rbx, %rdi
callq 0x4320
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xab30(%rip), %rsi      # 0x1b57b
movl $0x1b, %edx
movq %rax, %rdi
callq 0x4320
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xab25(%rip), %rsi      # 0x1b597
movl $0xd, %edx
movq %rax, %rdi
callq 0x4320
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
movq %r15, %rdi
callq 0x4320
movq %rax, %r15
leaq 0xab0c(%rip), %rsi      # 0x1b5a5
movl $0x26, %edx
movq %rax, %rdi
callq 0x4320
movl 0x60(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r15
leaq 0xab10(%rip), %rsi      # 0x1b5cc
movl $0x1b, %edx
movq %rax, %rdi
callq 0x4320
movl 0x64(%r14), %esi
movq %r15, %rdi
callq 0x4460
movq %rax, %r14
leaq 0xaa44(%rip), %rsi      # 0x1b523
movl $0x3, %edx
movq %rax, %rdi
callq 0x4320
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::print_taxies()
void TaxiAgency::print_taxies(){
    cout << rang::fg::blue << "Taxies List:" << rang::fg::reset << endl;
    cout << "[" << endl;
    for(auto taxi: taxies){
        taxi.print();
    };
    cout << "]" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movq 0x108e3(%rip), %rbx     # 0x22f78
movq %rbx, %rdi
movl $0x22, %esi
callq 0xf2c6
movq %rax, %r15
leaq 0x9113(%rip), %rsi      # 0x1b7bf
movl $0xc, %edx
movq %rax, %rdi
callq 0x4320
movq %r15, %rdi
movl $0x27, %esi
callq 0xf2c6
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
leaq 0x7d63(%rip), %rsi      # 0x1a45a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
movq (%r14), %rbx
movq 0x8(%r14), %r15
cmpq %r15, %rbx
je 0x127bf
leaq -0x78(%rbp), %r14
leaq -0x68(%rbp), %r12
leaq -0x48(%rbp), %r13
movb (%rbx), %al
movb %al, -0x80(%rbp)
movq %r12, -0x78(%rbp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xf530
movq %r13, -0x58(%rbp)
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0xf530
movl 0x50(%rbx), %eax
movl %eax, 0x48(%r14)
movq 0x48(%rbx), %rax
movq %rax, 0x40(%r14)
movq 0x107e7(%rip), %rdi     # 0x22f78
leaq -0x80(%rbp), %rsi
callq 0x17f78
movq -0x58(%rbp), %rdi
cmpq %r13, %rdi
je 0x127a8
callq 0x4280
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x127b6
callq 0x4280
addq $0x58, %rbx
cmpq %r15, %rbx
jne 0x12747
leaq 0x9006(%rip), %rsi      # 0x1b7cc
movl $0x1, %edx
movq 0x107a6(%rip), %rbx     # 0x22f78
movq %rbx, %rdi
callq 0x4320
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x42a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41f0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x1282f
callq 0x4280
jmp 0x1282f
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x17842
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::retrieve_taxi_by_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
IndexInstance<Taxi> TaxiAgency::retrieve_taxi_by_id(string id){
    for(int i = 0; i < taxies.size(); i++){
        if(taxies[i].id == id){
            return {i, &taxies[i]};
        };
    };
    throw invalid_argument("Taxi with the id doesn't exist");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
setne %r12b
je 0x128c8
movq %rsi, %r15
sarq $0x3, %rcx
movabsq $0x2e8ba2e8ba2e8ba3, %rdi # imm = 0x2E8BA2E8BA2E8BA3
imulq %rcx, %rdi
movq 0x8(%rsi), %r13
cmpq $0x1, %rdi
movq %rdi, %r9
adcq $0x0, %r9
xorl %ebx, %ebx
movq %rdi, -0x38(%rbp)
movq %r9, -0x30(%rbp)
movq %rax, %r14
movq 0x10(%rax), %rdx
cmpq %r13, %rdx
jne 0x128b0
testq %rdx, %rdx
je 0x128ca
movq (%r15), %rsi
movq 0x8(%r14), %rdi
callq 0x42e0
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rdi
testl %eax, %eax
je 0x128ca
incq %rbx
cmpq %rbx, %rdi
seta %r12b
leaq 0x58(%r14), %rax
cmpq %rbx, %r9
jne 0x12887
movq %r9, %rbx
jmp 0x128ca
xorl %ebx, %ebx
testb $0x1, %r12b
je 0x128e4
movl %ebx, %eax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
movq %rax, %rbx
leaq 0x8ed6(%rip), %rsi      # 0x1b7ce
movq %rax, %rdi
callq 0x44d0
movq 0x106b1(%rip), %rsi     # 0x22fb8
movq 0x1068a(%rip), %rdx     # 0x22f98
movq %rbx, %rdi
callq 0x4440
movq %rax, %r14
movq %rbx, %rdi
callq 0x4220
movq %r14, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::add_taxi_by_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
IndexInstance<Taxi> TaxiAgency::add_taxi_by_id(string id, int num){
    IndexInstance<Taxi> taxi = retrieve_taxi_by_id(id);
    if(num < 0)
        throw invalid_argument("Invalid Number provided");
    if(taxi.data->number + num >= EachCarLimit)
        throw range_error("Number of a certain Taxi shouldn't increase beyond EachCarLimit.");
    taxi.data->number += num;
    taxi.data->available_number += num;
    return taxi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xf530
movq %r14, %rdi
movq %r15, %rsi
callq 0x12838
movl %eax, %r12d
movq %rdx, %r15
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12bfe
callq 0x4280
testl %ebx, %ebx
js 0x12c2e
movl 0x4c(%r15), %eax
addl %ebx, %eax
cmpl 0x80(%r14), %eax
jge 0x12c5a
movl %eax, 0x4c(%r15)
addl %ebx, 0x50(%r15)
movl %r12d, %eax
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x8c25(%rip), %rsi      # 0x1b867
movq %rax, %rdi
callq 0x44d0
movq 0x10367(%rip), %rsi     # 0x22fb8
movq 0x10340(%rip), %rdx     # 0x22f98
jmp 0x12c84
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x8c11(%rip), %rsi      # 0x1b87f
movq %rax, %rdi
callq 0x4450
movq 0x10323(%rip), %rsi     # 0x22fa0
movq 0x102e4(%rip), %rdx     # 0x22f68
movq %r14, %rdi
callq 0x4440
jmp 0x12c8e
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x12cac
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12cac
callq 0x4280
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O1/Karunika[P]Taxi_Agency_OODB/./src/TaxiAgency.cpp
// Function: TaxiAgency::remove_taxi_by_id(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
IndexInstance<Taxi> TaxiAgency::remove_taxi_by_id(string id, int num){;
    IndexInstance<Taxi> taxi = retrieve_taxi_by_id(id);
    if(num < 0)
        throw invalid_argument("Invalid Number provided");
    if(taxi.data->number - num < 0)
        throw range_error("Not enough taxies to remove.");
    taxi.data->number -= num;
    if(taxi.data->available_number != 0)
        taxi.data->available_number -= num;
    if(taxi.data->number == 0)
        taxies.erase(taxies.begin() + taxi.index);
    return taxi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xf530
movq %rbx, %rdi
movq %r15, %rsi
callq 0x12838
movl %eax, %r12d
movq %rdx, %r15
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12d0b
callq 0x4280
testl %r14d, %r14d
js 0x12d5a
movl 0x4c(%r15), %eax
movl %eax, %ecx
subl %r14d, %ecx
js 0x12d86
movl %ecx, 0x4c(%r15)
movl 0x50(%r15), %ecx
testl %ecx, %ecx
je 0x12d2e
subl %r14d, %ecx
movl %ecx, 0x50(%r15)
cmpl %r14d, %eax
jne 0x12d45
movslq %r12d, %rax
imulq $0x58, %rax, %rsi
addq (%rbx), %rsi
movq %rbx, %rdi
callq 0x18ae6
movl %r12d, %eax
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x8af9(%rip), %rsi      # 0x1b867
movq %rax, %rdi
callq 0x44d0
movq 0x1023b(%rip), %rsi     # 0x22fb8
movq 0x10214(%rip), %rdx     # 0x22f98
jmp 0x12db0
movl $0x10, %edi
callq 0x4170
movq %rax, %r14
leaq 0x8b26(%rip), %rsi      # 0x1b8c0
movq %rax, %rdi
callq 0x4450
movq 0x101f7(%rip), %rsi     # 0x22fa0
movq 0x101b8(%rip), %rdx     # 0x22f68
movq %r14, %rdi
callq 0x4440
jmp 0x12dba
movq %rax, %rbx
movq %r14, %rdi
callq 0x4220
jmp 0x12dd8
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x12dd8
callq 0x4280
movq %rbx, %rdi
callq 0x4490