LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jasperandrew[P]cs350-project2/./lab7.h
// Function: cat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void cat(string filename)
{		
		int inode_num = getInodeNum(filename);
		if(inode_num == -1){
			cout << "File '" << filename << "' does not exist!\n";
			return;
		}
		inode file_inode = readInode(inode_num);
		for(int i = 0; i < MAX_FILE_BLOCKS; i++){
			if(file_inode.datablocks[i]){
				readData(file_inode.datablocks[i]);
				printf("%.*s", BLOCK_SZ, block_buffer);
			}else{
				break;
			}
		}
		cout << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x350, %rsp            # imm = 0x350
movq %rdi, %rsi
movq %rsi, -0x348(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x30f0
leaq -0x30(%rbp), %rdi
callq 0x44c0
movl %eax, -0x33c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3170
movl -0x33c(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
jne 0x525f
movq 0x7d98(%rip), %rdi      # 0xcfc8
leaq 0x3e82(%rip), %rsi      # 0x90b9
callq 0x3220
movq -0x348(%rbp), %rsi
movq %rax, %rdi
callq 0x31f0
movq %rax, %rdi
leaq 0x3e6b(%rip), %rsi      # 0x90c0
callq 0x3220
jmp 0x52ec
movl -0xc(%rbp), %esi
leaq -0x334(%rbp), %rdi
callq 0x40d0
movl $0x0, -0x338(%rbp)
cmpl $0x80, -0x338(%rbp)
jge 0x52d9
movslq -0x338(%rbp), %rax
cmpl $0x0, -0x230(%rbp,%rax,4)
je 0x52c4
movslq -0x338(%rbp), %rax
movl -0x230(%rbp,%rax,4), %edi
callq 0x42f0
leaq 0x3e62(%rip), %rdi      # 0x9111
movl $0x400, %esi            # imm = 0x400
leaq 0x107fe5(%rip), %rdx    # 0x10d2a0
movb $0x0, %al
callq 0x3050
jmp 0x52c6
jmp 0x52d9
jmp 0x52c8
movl -0x338(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x338(%rbp)
jmp 0x5278
movq 0x7ce8(%rip), %rdi      # 0xcfc8
movq 0x7cd1(%rip), %rsi      # 0xcfb8
callq 0x3250
addq $0x350, %rsp            # imm = 0x350
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jasperandrew[P]cs350-project2/./classes.cpp
// Function: WriteBuffer::WriteBuffer()
WriteBuffer::WriteBuffer(){
    num_blocks = 0;
    inode_counter = 0;
    for(int i = 0; i < 8; i++){
        seg_summary[i] = new Block(3);
        addBlock(seg_summary[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, 0x2000(%rax)
movl $0x0, 0x2004(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x5a3c
movl $0x1f10, %edi           # imm = 0x1F10
callq 0x3240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0x3, %esi
callq 0x6b10
jmp 0x59f5
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rcx
movslq -0xc(%rbp), %rax
movq %rcx, 0x2008(%rdi,%rax,8)
movslq -0xc(%rbp), %rax
movq 0x2008(%rdi,%rax,8), %rsi
callq 0x4a60
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x59cf
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x3200
jmp 0x5a42
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3430
nopl (%rax,%rax)
// File: jasperandrew[P]cs350-project2/lab7.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
vector<string> &split(const string &s, char delim, vector<string> &elems) {
    stringstream ss(s);
    string item;
    while(getline(ss, item, delim)){
        elems.push_back(item);
    }
    return elems;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1d8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x6c00
movq -0x1d8(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
callq 0x33b0
leaq -0x1c0(%rbp), %rdi
callq 0x3330
movsbl -0x9(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3460
movq %rax, -0x1e0(%rbp)
jmp 0x5e14
movq -0x1e0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32c0
movb %al, -0x1e1(%rbp)
jmp 0x5e32
movb -0x1e1(%rbp), %al
testb $0x1, %al
jne 0x5e3e
jmp 0x5e7e
movq -0x18(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x7140
jmp 0x5e50
jmp 0x5df4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3170
leaq -0x1a0(%rbp), %rdi
callq 0x31a0
jmp 0x5eb1
movq -0x18(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x3170
leaq -0x1a0(%rbp), %rdi
callq 0x31a0
movq -0x1f0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x3430
nopl (%rax)
// File: jasperandrew[P]cs350-project2/./lab7.h
// Function: Block::Block(int)
Block(int t){
            type = t;
            if(type == 0)
                for(int i = 0; i < BLOCK_SZ; i++) data[i] = 0;
            else if(type == 2)
                for(int i = 0; i < BLOCK_SZ/4; i++) block_data[i] = 0;
            else if(type == 3){
               seg_inodes.size=0; 
               for(int i = 0; i < BLOCK_SZ/8; i++){ 
                   seg_sum_arr[i].inode_number = 0;
                   seg_sum_arr[i].block_number = 0;
               }
            }
            num_blocks = 0;
						//initInode(&inode_data);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jne 0x6b5a
movl $0x0, -0x10(%rbp)
cmpl $0x400, -0x10(%rbp)     # imm = 0x400
jge 0x6b55
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, 0x4(%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6b34
jmp 0x6bed
movq -0x20(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x6b93
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x6b91
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl $0x0, 0x708(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6b6a
jmp 0x6beb
movq -0x20(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x6be9
movq -0x20(%rbp), %rax
movl $0x0, 0xf0c(%rax)
movl $0x0, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jge 0x6be7
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl $0x0, 0xb0c(%rax,%rcx,8)
movslq -0x18(%rbp), %rcx
movl $0x0, 0xb10(%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6bb1
jmp 0x6be9
jmp 0x6beb
jmp 0x6bed
movq -0x20(%rbp), %rax
movl $0x0, 0xb08(%rax)
popq %rbp
retq
nopl (%rax)
// File: jasperandrew[P]cs350-project2/./lab7.h
// Function: Block::writeToSegment()
void writeToSegment(){
            if(type == 0)
                memcpy(mem_segment+(mem_segment_idx++ * BLOCK_SZ), data, BLOCK_SZ);
            else if(type == 1)
                memcpy(mem_segment+(mem_segment_idx++ * BLOCK_SZ), &inode_data, sizeof(inode));
            else if(type == 2)
                memcpy(mem_segment+(mem_segment_idx++ * BLOCK_SZ), block_data, BLOCK_SZ);
            else if(type ==3)
                memcpy(mem_segment+(mem_segment_idx++ * BLOCK_SZ), seg_sum_arr, BLOCK_SZ);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, (%rax)
jne 0x6fa0
movq -0x10(%rbp), %rsi
movl 0x10631d(%rip), %eax    # 0x10d290
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x106312(%rip)    # 0x10d290
shll $0xa, %eax
cltq
leaq 0x6306(%rip), %rdi      # 0xd290
addq %rax, %rdi
addq $0x4, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x31c0
jmp 0x7067
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6fe3
movq -0x10(%rbp), %rsi
movl 0x1062dd(%rip), %eax    # 0x10d290
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1062d2(%rip)    # 0x10d290
shll $0xa, %eax
cltq
leaq 0x62c6(%rip), %rdi      # 0xd290
addq %rax, %rdi
addq $0x404, %rsi            # imm = 0x404
movl $0x304, %edx            # imm = 0x304
callq 0x31c0
jmp 0x7065
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x7023
movq -0x10(%rbp), %rsi
movl 0x10629a(%rip), %eax    # 0x10d290
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x10628f(%rip)    # 0x10d290
shll $0xa, %eax
cltq
leaq 0x6283(%rip), %rdi      # 0xd290
addq %rax, %rdi
addq $0x708, %rsi            # imm = 0x708
movl $0x400, %edx            # imm = 0x400
callq 0x31c0
jmp 0x7063
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x7061
movq -0x10(%rbp), %rsi
movl 0x10625a(%rip), %eax    # 0x10d290
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x10624f(%rip)    # 0x10d290
shll $0xa, %eax
cltq
leaq 0x6243(%rip), %rdi      # 0xd290
addq %rax, %rdi
addq $0xb0c, %rsi            # imm = 0xB0C
movl $0x400, %edx            # imm = 0x400
callq 0x31c0
jmp 0x7063
jmp 0x7065
jmp 0x7067
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: meh[P]ela/tests/custom.cpp
// Function: main
int
main (void)
{
	return amirite("custom", {
		{"access", []{
			RGB<float> a(1.0, 0.5, 0.0);

			amiequal(1.0, a[0]);
			amiequal(0.5, a[1]);
			amiequal(0.0, a[2]);
		}},

		{"assign", []{
			ela::column_vector<float, 3> a { 1.0, 0.5, 0.0 };
			RGB<float> b = a * 2;

			amiequal(2.0, b[0]);
			amiequal(1.0, b[1]);
			amiequal(0.0, b[2]);
		}},
	});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x2320
movq -0x100(%rbp), %rdx
leaq 0x6a2f(%rip), %rsi      # 0xa0bf
leaq -0x28(%rbp), %rdi
callq 0x2260
jmp 0x369b
leaq -0xe8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
leaq 0x6a16(%rip), %rsi      # 0xa0c6
leaq -0xf1(%rbp), %rdx
callq 0x38c0
jmp 0x36be
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
leaq 0x69fa(%rip), %rsi      # 0xa0cd
leaq -0xf2(%rbp), %rdx
callq 0x3950
jmp 0x36e1
leaq -0xe8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x2, -0x60(%rbp)
leaq -0xf3(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x5c70
movq -0x108(%rbp), %rcx
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x5c90
jmp 0x3721
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x31d0
movl %eax, -0x10c(%rbp)
jmp 0x3736
movl -0x10c(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5a80
leaq -0xf3(%rbp), %rdi
callq 0x5d10
leaq -0xe8(%rbp), %rax
movq %rax, -0x120(%rbp)
addq $0x80, %rax
movq %rax, -0x118(%rbp)
movq -0x118(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0x128(%rbp)
callq 0x5c40
movq -0x120(%rbp), %rcx
movq -0x128(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x118(%rbp)
jne 0x376f
leaq -0x28(%rbp), %rdi
callq 0x2100
leaq -0x29(%rbp), %rdi
callq 0x2200
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x38ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movq -0xf0(%rbp), %rax
leaq -0xe8(%rbp), %rcx
cmpq %rax, %rcx
movq %rax, -0x130(%rbp)
je 0x3826
movq -0x130(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0x138(%rbp)
callq 0x5c40
movq -0x138(%rbp), %rax
leaq -0xe8(%rbp), %rcx
cmpq %rcx, %rax
movq %rax, -0x130(%rbp)
jne 0x37f5
jmp 0x38a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x384b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5a80
leaq -0xf3(%rbp), %rdi
callq 0x5d10
leaq -0xe8(%rbp), %rax
movq %rax, -0x148(%rbp)
addq $0x80, %rax
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0x150(%rbp)
callq 0x5c40
movq -0x148(%rbp), %rcx
movq -0x150(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x140(%rbp)
jne 0x3872
jmp 0x38a5
leaq -0x28(%rbp), %rdi
callq 0x2100
leaq -0x29(%rbp), %rdi
callq 0x2200
movq -0x38(%rbp), %rdi
callq 0x2310
// File: dhruvbhargava[P]microTP/src/HttpMethods.cpp
// Function: format(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
std::string format(std::string http_template, int value)
{
    std::string val = std::to_string(value);
    std::string http_template_end = HTTP_OK_KEEP_ALIVE_END;
    std::string http_string = http_template+val+http_template_end;
    return http_string;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x3d00
leaq -0x59(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3400
movq -0x98(%rbp), %rdx
leaq 0x393c(%rip), %rsi      # 0x7004
leaq -0x58(%rbp), %rdi
callq 0x3e20
jmp 0x36d3
leaq -0x59(%rbp), %rdi
callq 0x32b0
movq -0xb0(%rbp), %rsi
movb $0x0, -0x6d(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x3f20
jmp 0x36f9
movq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x3ed0
jmp 0x3712
leaq -0x90(%rbp), %rdi
callq 0x31a0
movb $0x1, -0x6d(%rbp)
testb $0x1, -0x6d(%rbp)
jne 0x3775
jmp 0x3769
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x32b0
jmp 0x37a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x3797
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x31a0
jmp 0x3797
movq -0xa8(%rbp), %rdi
callq 0x31a0
leaq -0x58(%rbp), %rdi
callq 0x31a0
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x31a0
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x68(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: dhruvbhargava[P]microTP/src/Parser.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
std::vector<std::string> split(std::string input, char split_token)
{
    std::stringstream inp(input);
    std::string temp;
    std::vector<std::string> tokenized_out;
    while (std::getline(inp, temp, split_token))
    {
        tokenized_out.push_back(temp);
    }
    return tokenized_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rsi, -0x1e8(%rbp)
movq %rdi, -0x1e0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x4bd0
movq -0x1e8(%rbp), %rsi
movl %eax, %edx
leaq -0x1a0(%rbp), %rdi
callq 0x33b0
leaq -0x1c0(%rbp), %rdi
callq 0x3340
movq -0x1e0(%rbp), %rdi
movb $0x0, -0x1c1(%rbp)
callq 0x4bf0
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x3420
movq %rax, -0x1f8(%rbp)
jmp 0x4553
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3320
movb %al, -0x1f9(%rbp)
jmp 0x4571
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x457d
jmp 0x45cc
movq -0x1e0(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x4c10
jmp 0x4592
jmp 0x4533
movq -0x1e0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
callq 0x4c80
leaq -0x1c0(%rbp), %rdi
callq 0x31a0
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
jmp 0x4610
movb $0x1, -0x1c1(%rbp)
testb $0x1, -0x1c1(%rbp)
jne 0x45e8
movq -0x1e0(%rbp), %rdi
callq 0x4c80
leaq -0x1c0(%rbp), %rdi
callq 0x31a0
leaq -0x1a0(%rbp), %rdi
callq 0x31d0
movq -0x1f0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1d0(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: dhruvbhargava[P]microTP/src/Server.cpp
// Function: HttpServer::HttpServer(char*, char*)
HttpServer::HttpServer(char *port, char *project_root)
{
    PORT_NUMBER = atoi(port);
    PROJECT_ROOT = project_root;
    std::cout << PORT_NUMBER << std::endl;
    socket_listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_listen_fd < 0)
    {
        std::cout << "couldn't open a socket!"
                  << "\n";
    }
    std::cout << "opened socket \n";
    bzero((char *)&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_port = htons(PORT_NUMBER);

    if (bind(socket_listen_fd, (sockaddr *)&server_addr, sizeof(server_addr)) < 0)
    {
        std::cout << "Binding Failed! "
                  << "\n";
        exit(1);
    }
    std::cout << "socket binded!" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3390
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x30(%rax)
movl 0x4(%rax), %esi
movq 0x3ff0(%rip), %rdi      # 0x9fd0
callq 0x33e0
movq %rax, %rdi
movq 0x3fd1(%rip), %rsi      # 0x9fc0
callq 0x3290
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30a0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, (%rax)
jge 0x6034
movq 0x3fb7(%rip), %rdi      # 0x9fd0
leaq 0x11e6(%rip), %rsi      # 0x7206
callq 0x3250
movq %rax, %rdi
leaq 0xff1(%rip), %rsi       # 0x7020
callq 0x3250
movq 0x3f95(%rip), %rdi      # 0x9fd0
leaq 0x11dc(%rip), %rsi      # 0x721e
callq 0x3250
movq -0x20(%rbp), %rdi
addq $0xc, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3170
movq -0x20(%rbp), %rax
movw $0x2, 0xc(%rax)
movl $0x0, 0x10(%rax)
movl 0x4(%rax), %eax
movzwl %ax, %edi
callq 0x3040
movq -0x20(%rbp), %rsi
movw %ax, 0xe(%rsi)
movl (%rsi), %edi
addq $0xc, %rsi
movl $0x10, %edx
callq 0x3050
cmpl $0x0, %eax
jge 0x60c0
movq 0x3f35(%rip), %rdi      # 0x9fd0
leaq 0x118c(%rip), %rsi      # 0x722e
callq 0x3250
movq %rax, %rdi
leaq 0xf6f(%rip), %rsi       # 0x7020
callq 0x3250
movl $0x1, %edi
callq 0x3300
movq 0x3f09(%rip), %rdi      # 0x9fd0
leaq 0x1171(%rip), %rsi      # 0x723f
callq 0x3250
movq %rax, %rdi
movq 0x3ee3(%rip), %rsi      # 0x9fc0
callq 0x3290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: dhruvbhargava[P]microTP/src/Server.cpp
// Function: HttpServer::startListen()
void HttpServer::startListen()
{
    socklen_t clielen = sizeof(client_addr);
    std::cout << "started Listening for requests\n";
    listen(socket_listen_fd, 5); //a waiting queue size of 5 will suffice since each client is being served by a different process
    pid_t pid = 1;
    while (1)
    {
        new_socket_fd = accept(socket_listen_fd, (sockaddr *)&client_addr, &clielen);
        pid = fork();
        if (pid == 0)
        {
            break;
        }
        std::cout << "Parent" << std::endl;
    }
    if (pid == 0)
    {
        while (1)
        {
            std::string requestBuffer = feedBuffer();
            requestResolver(requestBuffer);
        }
        close(new_socket_fd);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x10, -0xc(%rbp)
movq 0x3ebe(%rip), %rdi      # 0x9fd0
leaq 0x1135(%rip), %rsi      # 0x724e
callq 0x3250
movq -0x68(%rbp), %rax
movl (%rax), %edi
movl $0x5, %esi
callq 0x32e0
movl $0x1, -0x10(%rbp)
movq -0x68(%rbp), %rsi
movl (%rsi), %edi
addq $0x1c, %rsi
leaq -0xc(%rbp), %rdx
callq 0x30f0
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0x8(%rax)
callq 0x30c0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x6161
jmp 0x6185
movq 0x3e68(%rip), %rdi      # 0x9fd0
leaq 0x10ff(%rip), %rsi      # 0x726e
callq 0x3250
movq %rax, %rdi
movq 0x3e42(%rip), %rsi      # 0x9fc0
callq 0x3290
jmp 0x6135
cmpl $0x0, -0x10(%rbp)
jne 0x61fe
jmp 0x618d
movq -0x68(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x6210
movq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3140
jmp 0x61ad
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x6360
jmp 0x61bc
leaq -0x50(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0x618d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x61f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31a0
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0x6204
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: dhruvbhargava[P]microTP/src/Server.cpp
// Function: HttpServer::feedBuffer[abi:cxx11]()
std::string HttpServer::feedBuffer()
{
    char requestBuffer[62000];
    int index = 0;
    // std::cout << "buffer contains" << std::endl;
    // std::cout<<requestBuffer<<std::endl;
    while (true)
    {
        read(new_socket_fd, requestBuffer + index, 1);
        if (index > 2 && requestBuffer[index] == '\r' && requestBuffer[index - 2] == '\r')
        {

            break;
        }
        index++;
    }
    std::string reqBuff = requestBuffer;
    return reqBuff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf280, %rsp           # imm = 0xF280
movq %rdi, -0xf270(%rbp)
movq %rdi, %rax
movq %rax, -0xf268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf260(%rbp)
movl $0x0, -0xf244(%rbp)
movq -0xf260(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0xf240(%rbp), %rsi
movslq -0xf244(%rbp), %rax
addq %rax, %rsi
movl $0x1, %edx
callq 0x3350
cmpl $0x2, -0xf244(%rbp)
jle 0x62a5
movslq -0xf244(%rbp), %rax
movsbl -0xf240(%rbp,%rax), %eax
cmpl $0xd, %eax
jne 0x62a5
movl -0xf244(%rbp), %eax
subl $0x2, %eax
cltq
movsbl -0xf240(%rbp,%rax), %eax
cmpl $0xd, %eax
jne 0x62a5
jmp 0x62b6
movl -0xf244(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf244(%rbp)
jmp 0x6249
movb $0x0, -0xf245(%rbp)
leaq -0xf246(%rbp), %rdi
movq %rdi, -0xf278(%rbp)
callq 0x3400
movq -0xf270(%rbp), %rdi
movq -0xf278(%rbp), %rdx
leaq -0xf240(%rbp), %rsi
callq 0x3e20
jmp 0x62ec
leaq -0xf246(%rbp), %rdi
callq 0x32b0
movb $0x1, -0xf245(%rbp)
testb $0x1, -0xf245(%rbp)
jne 0x6336
jmp 0x632a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xf250(%rbp)
movl %eax, -0xf254(%rbp)
leaq -0xf246(%rbp), %rdi
callq 0x32b0
jmp 0x6346
movq -0xf270(%rbp), %rdi
callq 0x31a0
movq -0xf268(%rbp), %rax
addq $0xf280, %rsp           # imm = 0xF280
popq %rbp
retq
movq -0xf250(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: dhruvbhargava[P]microTP/src/Server.cpp
// Function: HttpServer::requestResolver(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void HttpServer::requestResolver(std::string requestBuffer)
{
    std::cout << std::endl;
    Request Header = parse(requestBuffer);
    std::cout << Header.request_method << std::endl;
    if (Header.request_method.compare("GET") == 0)
    {
        const char *req = Header.url.c_str();
        GET(req, false);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rsi, -0x138(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x140(%rbp)
movq 0x3c44(%rip), %rdi      # 0x9fd0
movq 0x3c2d(%rip), %rsi      # 0x9fc0
callq 0x3290
movq -0x138(%rbp), %rsi
leaq -0x110(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x3140
movq -0x130(%rbp), %rsi
leaq -0xf0(%rbp), %rdi
callq 0x4720
jmp 0x63c7
leaq -0x110(%rbp), %rdi
callq 0x31a0
movq 0x3bf6(%rip), %rdi      # 0x9fd0
leaq -0xf0(%rbp), %rsi
callq 0x3230
movq %rax, -0x148(%rbp)
jmp 0x63ef
movq -0x148(%rbp), %rdi
movq 0x3bc3(%rip), %rsi      # 0x9fc0
callq 0x3290
jmp 0x6404
leaq -0xf0(%rbp), %rdi
leaq 0xe63(%rip), %rsi       # 0x7275
callq 0x30e0
cmpl $0x0, %eax
jne 0x6488
leaq -0xd0(%rbp), %rdi
callq 0x3130
movq -0x140(%rbp), %rdi
movq %rax, -0x128(%rbp)
movq -0x128(%rbp), %rsi
xorl %edx, %edx
callq 0x37c0
jmp 0x6446
jmp 0x6488
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x31a0
jmp 0x649d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0xf0(%rbp), %rdi
callq 0x4eb0
jmp 0x649d
leaq -0xf0(%rbp), %rdi
callq 0x4eb0
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: dhruvbhargava[P]microTP/src/main.cpp
// Function: main
int main(int argc, char *argv[])
{
	if (argc<3){
		std::cout<<"no files to host"<<std::endl;
		exit(1);
	}
	char* port,*project_root;
	port = argv[1];
	project_root = argv[2];
	HttpServer server = HttpServer(port,project_root);
	server.startListen();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
jge 0x64f4
movq 0x3b01(%rip), %rdi      # 0x9fd0
leaq 0xda3(%rip), %rsi       # 0x7279
callq 0x3250
movq %rax, %rdi
movq 0x3adb(%rip), %rsi      # 0x9fc0
callq 0x3290
movl $0x1, %edi
callq 0x3300
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x160(%rbp), %rdi
callq 0x5fa0
leaq -0x160(%rbp), %rdi
callq 0x60f0
xorl %eax, %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
// File: fieryzig[P]GameServer/./Common/utils/FileUtils.h
// Function: fieryzig::GetStringFromFile[abi:cxx11](char const*)
string GetStringFromFile(const char* filename) {
    string ret = "";
    string line;
    ifstream file(filename,ios::in);
    if (!file.is_open()) {
        return ret;
    }
    while (!file.eof()) {
        getline(file,line);
        ret.append(line + '\n');
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x288(%rbp)
movq %rdi, %rax
movq %rax, -0x290(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x280(%rbp)
callq 0x23e0
movq -0x288(%rbp), %rdi
movq -0x280(%rbp), %rdx
leaq 0xe7e7(%rip), %rsi      # 0x10e44
callq 0x2320
jmp 0x2664
leaq -0x12(%rbp), %rdi
callq 0x2290
leaq -0x48(%rbp), %rdi
callq 0x2340
movq -0x10(%rbp), %rsi
leaq -0x250(%rbp), %rdi
movl $0x8, %edx
callq 0x2400
jmp 0x268d
leaq -0x250(%rbp), %rdi
callq 0x2390
movb %al, -0x291(%rbp)
jmp 0x26a1
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x26fc
jmp 0x26ad
movb $0x1, -0x11(%rbp)
movl $0x1, -0x254(%rbp)
jmp 0x27a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x2290
jmp 0x27fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x27c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x27bd
jmp 0x26fe
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x250(%rbp,%rax), %rdi
callq 0x2410
movb %al, -0x292(%rbp)
jmp 0x271e
movb -0x292(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x272c
jmp 0x2792
leaq -0x250(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2070
jmp 0x273e
leaq -0x278(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0xa, %edx
callq 0x39b0
jmp 0x2755
movq -0x288(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x2430
jmp 0x276a
leaq -0x278(%rbp), %rdi
callq 0x21a0
jmp 0x26fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x21a0
jmp 0x27bd
movb $0x1, -0x11(%rbp)
movl $0x1, -0x254(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x20a0
leaq -0x48(%rbp), %rdi
callq 0x21a0
testb $0x1, -0x11(%rbp)
jne 0x27ec
jmp 0x27e0
leaq -0x250(%rbp), %rdi
callq 0x20a0
leaq -0x48(%rbp), %rdi
callq 0x21a0
movq -0x288(%rbp), %rdi
callq 0x21a0
jmp 0x27fc
movq -0x288(%rbp), %rdi
callq 0x21a0
movq -0x290(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x23d0
nopw %cs:(%rax,%rax)
// File: fieryzig[P]GameServer/./Common/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::operator=(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>&)
GenericValue& operator=(GenericValue& rhs) RAPIDJSON_NOEXCEPT {
        RAPIDJSON_ASSERT(this != &rhs);
        this->~GenericValue();
        RawAssign(rhs);
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0x3e70
jmp 0x3e8f
leaq 0xc120(%rip), %rdi      # 0xff97
leaq 0xa2c4(%rip), %rsi      # 0xe142
movl $0x326, %edx            # imm = 0x326
leaq 0xc11a(%rip), %rcx      # 0xffa4
callq 0x21b0
movq -0x18(%rbp), %rdi
callq 0xa110
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa640
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: fieryzig[P]GameServer/./Common/rapidjson/include/rapidjson/internal/stack.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>* rapidjson::internal::Stack<rapidjson::CrtAllocator>::PushUnsafe<rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>>(unsigned long)
RAPIDJSON_FORCEINLINE T* PushUnsafe(size_t count = 1) {
        RAPIDJSON_ASSERT(stackTop_);
        RAPIDJSON_ASSERT(stackTop_ + sizeof(T) * count <= stackEnd_);
        T* ret = reinterpret_cast<T*>(stackTop_);
        stackTop_ += sizeof(T) * count;
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x80b1
jmp 0x80d0
leaq 0x65fe(%rip), %rdi      # 0xe6b6
leaq 0x622b(%rip), %rsi      # 0xe2ea
movl $0x81, %edx
leaq 0x65f5(%rip), %rcx      # 0xe6c0
callq 0x21b0
movq -0x20(%rbp), %rcx
movq 0x18(%rcx), %rax
movq -0x10(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
cmpq 0x20(%rcx), %rax
ja 0x80eb
jmp 0x810a
leaq 0x666f(%rip), %rdi      # 0xe761
leaq 0x61f1(%rip), %rsi      # 0xe2ea
movl $0x82, %edx
leaq 0x65bb(%rip), %rcx      # 0xe6c0
callq 0x21b0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: fieryzig[P]GameServer/./Common/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::GenericValue(rapidjson::Type)
explicit GenericValue(Type type) RAPIDJSON_NOEXCEPT : data_() {
        static const uint16_t defaultFlags[7] = {
            kNullFlag, kFalseFlag, kTrueFlag, kObjectFlag, kArrayFlag, kShortStringFlag,
            kNumberAnyFlag
        };
        RAPIDJSON_ASSERT(type <= kNumberType);
        data_.f.flags = defaultFlags[type];

        // Use ShortString to store empty string.
        if (type == kStringType)
            data_.ss.SetLength(0);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x2170
cmpl $0x6, -0xc(%rbp)
jg 0x957b
jmp 0x959a
leaq 0x5e2a(%rip), %rdi      # 0xf3ac
leaq 0x4bb9(%rip), %rsi      # 0xe142
movl $0x25d, %edx            # imm = 0x25D
leaq 0x5e2b(%rip), %rcx      # 0xf3c0
callq 0x21b0
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0x6eb6(%rip), %rcx      # 0x10460
movw (%rcx,%rdx,2), %cx
movw %cx, 0xe(%rax)
cmpl $0x5, -0xc(%rbp)
jne 0x95c3
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x91b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: fieryzig[P]GameServer/./Common/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::SetObjectRaw(rapidjson::GenericMember<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*, unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
        data_.f.flags = kObjectFlag;
        if (count) {
            Member* m = static_cast<Member*>(allocator.Malloc(count * sizeof(Member)));
            SetMembersPointer(m);
            std::memcpy(m, members, count * sizeof(Member));
        }
        else
            SetMembersPointer(0);
        data_.o.size = data_.o.capacity = count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movw $0x3, 0xe(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x9716
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
shlq $0x5, %rsi
callq 0x91d0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x9740
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
shlq $0x5, %rdx
callq 0x2200
jmp 0x9723
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9740
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: fieryzig[P]GameServer/./Common/rapidjson/include/rapidjson/document.h
// Function: rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>::SetArrayRaw(rapidjson::GenericValue<rapidjson::UTF8<char>, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>>*, unsigned int, rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator>&)
void SetArrayRaw(GenericValue* values, SizeType count, Allocator& allocator) {
        data_.f.flags = kArrayFlag;
        if (count) {
            GenericValue* e = static_cast<GenericValue*>(allocator.Malloc(count * sizeof(GenericValue)));
            SetElementsPointer(e);
            std::memcpy(e, values, count * sizeof(GenericValue));
        }
        else
            SetElementsPointer(0);
        data_.a.size = data_.a.capacity = count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movw $0x4, 0xe(%rax)
cmpl $0x0, -0x14(%rbp)
je 0x9886
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
shlq $0x4, %rsi
callq 0x91d0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x98b0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
shlq $0x4, %rdx
callq 0x2200
jmp 0x9893
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x98b0
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: fieryzig[P]GameServer/./Common/rapidjson/include/rapidjson/internal/stack.h
// Function: rapidjson::internal::Stack<rapidjson::CrtAllocator>::ShrinkToFit()
void ShrinkToFit() { 
        if (Empty()) {
            // If the stack is empty, completely deallocate the memory.
            Allocator::Free(stack_);
            stack_ = 0;
            stackTop_ = 0;
            stackEnd_ = 0;
        }
        else
            Resize(GetSize());
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x9fc0
testb $0x1, %al
jne 0x9f6f
jmp 0x9f9a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4f40
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
jmp 0x9faf
movq -0x10(%rbp), %rdi
callq 0x56f0
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x8200
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: fieryzig[P]GameServer/./Common/rapidjson/include/rapidjson/internal/strfunc.h
// Function: unsigned int rapidjson::internal::StrLen<char>(char const*)
inline SizeType StrLen(const Ch* s) {
    RAPIDJSON_ASSERT(s != 0);
    const Ch* p = s;
    while (*p) ++p;
    return SizeType(p - s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xa135
jmp 0xa154
leaq 0x508d(%rip), %rdi      # 0xf1c9
leaq 0x585d(%rip), %rsi      # 0xf9a0
movl $0x1f, %edx
leaq 0x5889(%rip), %rcx      # 0xf9d8
callq 0x21b0
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xa173
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa15c
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: fieryzig[P]GameServer/GateServer/main.cpp
// Function: main
int main()
{
    GateServer *gateServer = new GateServer();
    gateServer->SetConfig("gateConfig.json");
    gateServer->InitServer();
    while(1)
    {
        gateServer->Run();
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x198, %edi            # imm = 0x198
callq 0x2250
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x198, %edx            # imm = 0x198
callq 0x2170
movq -0x18(%rbp), %rdi
callq 0xc340
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
leaq 0x4afd(%rip), %rsi      # 0x10e18
callq *(%rax)
movq -0x10(%rbp), %rdi
callq 0xc660
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xc326
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: fieryzig[P]GameServer/Common/BaseServer/BaseServer.cpp
// Function: fieryzig::BaseServer::InitServer()
void BaseServer::InitServer()
    {
        epfd = epoll_create(256);
        listenfd = socket(AF_INET, SOCK_STREAM, 0);

        ev.data.fd = listenfd;
        ev.events = EPOLLIN;
        epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

        memset(&serveraddr, 0, sizeof(serveraddr));
        inet_aton(config->ip.c_str(), &(serveraddr.sin_addr));
        serveraddr.sin_port = htons(config->port);
        
        SetSocketOpt(listenfd);

        if (bind(listenfd, (sockaddr*)&serveraddr, sizeof(struct sockaddr)) == -1) {
            cout << "bind failed" << endl;
            exit(1);
        }
        listen(listenfd, 10);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x100, %edi            # imm = 0x100
callq 0x2420
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2090
movq -0x10(%rbp), %rcx
movl %eax, 0x14(%rcx)
movl 0x14(%rcx), %eax
movl %eax, 0x20(%rcx)
movl $0x1, 0x1c(%rcx)
movl 0x10(%rcx), %edi
movl 0x14(%rcx), %edx
addq $0x1c, %rcx
movl $0x1, %esi
callq 0x2330
movq -0x10(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
xorl %esi, %esi
movl $0x10, %edx
callq 0x2170
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x8, %rdi
callq 0x2110
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x128, %rsi            # imm = 0x128
addq $0x4, %rsi
callq 0x21d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rax), %eax
movzwl %ax, %edi
callq 0x2040
movq -0x10(%rbp), %rdi
movw %ax, 0x12a(%rdi)
movl 0x14(%rdi), %esi
callq 0xc790
movq -0x10(%rbp), %rsi
movl 0x14(%rsi), %edi
addq $0x128, %rsi            # imm = 0x128
movl $0x10, %edx
callq 0x2050
cmpl $-0x1, %eax
jne 0xc76e
movq 0xa88f(%rip), %rdi      # 0x16fd8
leaq 0x46d8(%rip), %rsi      # 0x10e28
callq 0x2240
movq %rax, %rdi
movq 0xa869(%rip), %rsi      # 0x16fc8
callq 0x2270
movl $0x1, %edi
callq 0x22d0
movq -0x10(%rbp), %rax
movl 0x14(%rax), %edi
movl $0xa, %esi
callq 0x22a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: fieryzig[P]GameServer/Common/Client/Client.cpp
// Function: fieryzig::Client::Recv()
int Client::Recv() 
{
//    if (recvbuf.remain() < 4) return 0;
    int ret = ::read(fd, recvbuf.getTail(), min(recvbuf.remain(),BUFSIZE-recvbuf.tail));
    if (ret == -1) return ret;
    recvbuf.push(ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl 0x2020(%rdi), %eax
movl %eax, -0x2c(%rbp)
callq 0xccc0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
callq 0xcd30
movq -0x38(%rbp), %rcx
movl %eax, -0x18(%rbp)
movl $0x1000, %eax           # imm = 0x1000
subl 0x1008(%rcx), %eax
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0xccf0
movl -0x2c(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq (%rax), %rdx
callq 0x2350
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0xc841
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc853
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xcd50
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: fieryzig[P]GameServer/Common/Client/Client.cpp
// Function: fieryzig::Client::hasMsg(fieryzig::PacketInfo*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Client::hasMsg(PacketInfo* ppi, string &content)
{
    if (recvbuf.count < 4) return false;
    int packetLen = recvbuf.getIntFromHead();

    if (recvbuf.count < packetLen) {
        return false;
    }
    recvbuf.pop(4);
    cout << "RECV PacketLen: " << packetLen << endl;

    int pi_size = sizeof(PacketInfo);
    recvbuf.copyFromHead(ppi, pi_size);
    recvbuf.pop(pi_size);

    int contentLen = ppi->contentLen;
    char conBuf[contentLen];
    recvbuf.copyFromHead(conBuf, contentLen);
    conBuf[contentLen] = '\0';
    content = conBuf;
    
    recvbuf.pop(contentLen);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpl $0x4, 0x100c(%rax)
jge 0xc88e
movb $0x0, -0x1(%rbp)
jmp 0xc97a
movq -0x48(%rbp), %rdi
callq 0xcd90
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, -0x24(%rbp)
movl 0x100c(%rax), %eax
cmpl -0x24(%rbp), %eax
jge 0xc8b4
movb $0x0, -0x1(%rbp)
jmp 0xc97a
movq -0x48(%rbp), %rdi
movl $0x4, %esi
callq 0xce00
movq 0xa70f(%rip), %rdi      # 0x16fd8
leaq 0x4564(%rip), %rsi      # 0x10e34
callq 0x2240
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x23c0
movq %rax, %rdi
movq 0xa6de(%rip), %rsi      # 0x16fc8
callq 0x2270
movq -0x48(%rbp), %rdi
movl $0x18, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movl -0x28(%rbp), %edx
callq 0xce50
movq -0x48(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0xce00
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rsi
subq %rcx, %rsi
movq %rsi, -0x50(%rbp)
movq %rsi, %rsp
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %edx
callq 0xce50
movq -0x50(%rbp), %rsi
movslq -0x2c(%rbp), %rax
movb $0x0, (%rsi,%rax)
movq -0x20(%rbp), %rdi
callq 0x2310
movq -0x48(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0xce00
movb $0x1, -0x1(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rsp
movb -0x1(%rbp), %al
andb $0x1, %al
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fieryzig[P]GameServer/Common/Client/Client.cpp
// Function: fieryzig::Client::Send(fieryzig::PacketInfo, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Client::Send(PacketInfo pi, string content)
{
    int tot_len = sizeof(pi) + content.length() + 4;
    unsigned int tmp = htonl(tot_len); 
    sendbuf.copyIntoTail((char*)&tmp ,4);
    sendbuf.push(4);
    sendbuf.copyIntoTail(&pi, sizeof(pi));
    sendbuf.push(sizeof(pi));
    sendbuf.copyIntoTail(content.c_str(), content.length());
    sendbuf.push(content.length());

    int ret = ::write(fd, sendbuf.getHead(), min(sendbuf.count, BUFSIZE-sendbuf.head));
    if (ret == -1) return -1;
    sendbuf.pop(ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, %rax
movq -0x50(%rbp), %rdi
leaq 0x10(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x2360
addq $0x18, %rax
addq $0x4, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x21e0
movq -0x40(%rbp), %rdi
movl %eax, -0x20(%rbp)
addq $0x1010, %rdi           # imm = 0x1010
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0xcf00
movq -0x40(%rbp), %rdi
addq $0x1010, %rdi           # imm = 0x1010
movl $0x4, %esi
callq 0xcd50
movq -0x68(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x1010, %rdi           # imm = 0x1010
movl $0x18, %edx
callq 0xcf00
movq -0x40(%rbp), %rdi
addq $0x1010, %rdi           # imm = 0x1010
movl $0x18, %esi
callq 0xcd50
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
addq $0x1010, %rax           # imm = 0x1010
movq %rax, -0x60(%rbp)
callq 0x2110
movq -0x50(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x2360
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl %eax, %edx
callq 0xcf00
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
addq $0x1010, %rax           # imm = 0x1010
movq %rax, -0x48(%rbp)
callq 0x2360
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0xcd50
movq -0x40(%rbp), %rdi
movl 0x2020(%rdi), %eax
movl %eax, -0x34(%rbp)
addq $0x1010, %rdi           # imm = 0x1010
callq 0xcfb0
movq -0x40(%rbp), %rcx
movq %rax, -0x30(%rbp)
movq %rcx, %rdi
addq $0x1010, %rdi           # imm = 0x1010
addq $0x100c, %rdi           # imm = 0x100C
movl $0x1000, %eax           # imm = 0x1000
subl 0x2014(%rcx), %eax
movl %eax, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0xccf0
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
movslq (%rax), %rdx
callq 0x20e0
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0xcaf1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xcb0a
movq -0x40(%rbp), %rdi
addq $0x1010, %rdi           # imm = 0x1010
movl -0x24(%rbp), %esi
callq 0xce00
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fieryzig[P]GameServer/Common/Client/Client.cpp
// Function: fieryzig::Client::debugPrint(char*, int)
void Client::debugPrint(char* ch, int sz)
{
    cout << "+++++++" << sz << "+++++++" << endl;
    for (int i = 0; i < sz; i++) {
        printf("%02x",*(ch+i)&0xFF);
        if ( i % 64 == 63 ) puts("");
    }
    cout << endl << "----------------" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq 0xa3de(%rip), %rdi      # 0x16fd8
leaq 0x4244(%rip), %rsi      # 0x10e45
callq 0x2240
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x23c0
movq %rax, %rdi
leaq 0x422a(%rip), %rsi      # 0x10e45
callq 0x2240
movq %rax, %rdi
movq 0xa39e(%rip), %rsi      # 0x16fc8
callq 0x2270
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xcc87
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %esi
andl $0xff, %esi
leaq 0x41f6(%rip), %rdi      # 0x10e4d
movb $0x0, %al
callq 0x2030
movl -0x18(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
cmpl $0x3f, %edx
jne 0xcc7a
leaq 0x41cf(%rip), %rdi      # 0x10e44
callq 0x2380
jmp 0xcc7c
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xcc36
movq 0xa34a(%rip), %rdi      # 0x16fd8
movq 0xa333(%rip), %rsi      # 0x16fc8
callq 0x2270
movq %rax, %rdi
leaq 0x41ae(%rip), %rsi      # 0x10e52
callq 0x2240
movq %rax, %rdi
movq 0xa315(%rip), %rsi      # 0x16fc8
callq 0x2270
addq $0x20, %rsp
popq %rbp
retq
nop
// File: fieryzig[P]GameServer/Common/Client/Client.h
// Function: fieryzig::Client::buffer_t::getIntFromHead()
inline int getIntFromHead() { //not check, check outside!
            char tmp[4];
            for ( int i = 0 ; i < 4 ; i++ ) tmp[i] = buffer[(head+i)%BUFSIZE];
            return ntohl(*(int*)tmp);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xcde3
movq -0x18(%rbp), %rax
movl 0x1004(%rax), %eax
addl -0x10(%rbp), %eax
movl $0x1000, %ecx           # imm = 0x1000
cltd
idivl %ecx
movq -0x18(%rbp), %rax
movslq %edx, %rcx
movb (%rax,%rcx), %cl
movslq -0x10(%rbp), %rax
movb %cl, -0xc(%rbp,%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xcdab
movl -0xc(%rbp), %edi
callq 0x22e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)