LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jBlinden[P]private-codis/./socket.h
// Function: CSocket::SendLarge(unsigned char const*, unsigned long)
void SendLarge(const uint8_t* pBuf, uint64_t len) {
    int nBatches = (len + BLK_SIZE - 1) / BLK_SIZE;
    for (int i = 0; i < nBatches; i++) {
      int batchSize = BLK_SIZE;
      if (i == nBatches - 1) {
        batchSize = len % BLK_SIZE;
        if (batchSize == 0) {
          batchSize = BLK_SIZE;
        }
      }
      Send(pBuf + i * BLK_SIZE, batchSize);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x7ffffffe(%rdx), %rax
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movq %rdx, %rcx
xorl %edx, %edx
movq %rsi, %rbx
xorl %r12d, %r12d
divq %rdi
xorl %edx, %edx
movq %rax, %rsi
leal -0x1(%rax), %r8d
movq %rcx, %rax
divq %rdi
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
testq %rdx, %rdx
movq %rdx, %r15
cmovel %eax, %r15d
movl %esi, %eax
sarl $0x1f, %eax
imulq $0x7fffffff, %r8, %rbp  # imm = 0x7FFFFFFF
andnl %esi, %eax, %eax
imulq $0x7fffffff, %rax, %r13 # imm = 0x7FFFFFFF
cmpq %r12, %r13
je 0x4d40
cmpq %r12, %rbp
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
leaq (%rbx,%r12), %rsi
movq %r14, %rdi
cmovel %r15d, %edx
xorl %ecx, %ecx
callq 0x4e8c
addq $0x7fffffff, %r12       # imm = 0x7FFFFFFF
jmp 0x4d18
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jBlinden[P]private-codis/./socket.h
// Function: CSocket::Receive(void*, int, int)
int Receive(void* pBuf, int nLen, int nFlags = 0) {
    struct timespec start, stop;
    clock_gettime( CLOCK_REALTIME, &start);

    bytesReceived += nLen;

    char* p = (char*) pBuf;
    int n = nLen;
    int ret = 0;
    while (n > 0) {
      ret = recv(m_hSock, p, n, 0);
      if (ret < 0) {
        if (errno == EAGAIN) {
          cout << "socket recv eror: EAGAIN" << endl;
          usleep(200);
          continue;
        } else {
          cout << "socket recv error: " << errno << endl;
          
          clock_gettime( CLOCK_REALTIME, &stop);
          networkTime += (stop.tv_sec - start.tv_sec) * BILLION + stop.tv_nsec - start.tv_nsec;
          return ret;
        }
      } else if (ret == 0) {
        clock_gettime( CLOCK_REALTIME, &stop);
        networkTime += (stop.tv_sec - start.tv_sec) * BILLION + stop.tv_nsec - start.tv_nsec;
        return ret;
      }
      p += ret;
      n -= ret;
    }
    clock_gettime( CLOCK_REALTIME, &stop);
    networkTime += (stop.tv_sec - start.tv_sec) * BILLION + stop.tv_nsec - start.tv_nsec;
    return nLen;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
leaq 0x8(%rsp), %rsi
movq %rdi, %rbx
xorl %edi, %edi
movl %edx, %ebp
callq 0x2210
movslq %ebp, %rax
leaq 0x1561(%rip), %r13      # 0x62f3
movl %ebp, 0x4(%rsp)
addq %rax, 0x10(%rbx)
testl %ebp, %ebp
jle 0x4e66
movl %ebp, %ebp
movl (%rbx), %edi
movq %r15, %rsi
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x20e0
movq %rax, %r14
testl %r14d, %r14d
jns 0x4de8
callq 0x2040
cmpl $0xb, (%rax)
jne 0x4dfe
movq 0x420c(%rip), %rdi      # 0x8fd8
movq %r13, %rsi
callq 0x2250
movq %rax, %rdi
callq 0x2130
movl $0xc8, %edi
callq 0x2350
jmp 0x4da4
je 0x4e86
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
subl %r14d, %ebp
addq %rax, %r15
jmp 0x4d9a
movq 0x41d3(%rip), %rdi      # 0x8fd8
leaq 0x1500(%rip), %rsi      # 0x630c
movq %rax, %r12
callq 0x2250
movl (%r12), %esi
movq %rax, %rdi
callq 0x23d0
movq %rax, %rdi
callq 0x2130
leaq 0x18(%rsp), %r15
xorl %edi, %edi
movq %r15, %rsi
callq 0x2210
movq (%r15), %rax
subq 0x8(%rsp), %rax
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
addq 0x20(%rsp), %rax
subq 0x10(%rsp), %rax
addq %rax, 0x18(%rbx)
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rsp), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x2210
movq (%r14), %rax
movl 0x4(%rsp), %ecx
subq 0x8(%rsp), %rax
movl %ecx, %r14d
jmp 0x4e3f
xorl %r14d, %r14d
jmp 0x4e28
nop
// File: /workspace/github_cpp_makefile_star2_O2/jBlinden[P]private-codis/./socket.h
// Function: CSocket::Send(void const*, int, int)
int Send(const void* pBuf, int nLen, int nFlags = 0) {
    struct timespec start, stop;
    
    clock_gettime( CLOCK_REALTIME, &start);

    bytesSent += nLen;
    int ret = send(m_hSock, (char*)pBuf, nLen, nFlags);

    clock_gettime( CLOCK_REALTIME, &stop);
    networkTime += (stop.tv_sec - start.tv_sec) * BILLION + stop.tv_nsec - start.tv_nsec;

    return ret;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rsp), %r12
movq %rsi, %r15
movq %rdi, %rbx
movl %ecx, %ebp
movl %edx, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x2210
movslq %r14d, %rdx
movq %r15, %rsi
movl %ebp, %ecx
addq %rdx, 0x8(%rbx)
movl (%rbx), %edi
callq 0x2150
movq %rsp, %r15
movq %rax, %r14
xorl %edi, %edi
movq %r15, %rsi
callq 0x2210
movq (%r15), %rax
subq (%r12), %rax
imulq $0x3b9aca00, %rax, %rax # imm = 0x3B9ACA00
addq 0x8(%r15), %rax
subq 0x8(%r12), %rax
addq %rax, 0x18(%rbx)
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jBlinden[P]private-codis/util.cpp
// Function: AESContext::AESContext()
AESContext::AESContext() {
  FILE* f = fopen("/dev/urandom", "r");
  if (f == NULL) {
    throw "unable to open /dev/urandom";
  }

  uint32_t bytesRead = fread(keyBytes, 1, AES_KEY_LEN, f);
  if (bytesRead != AES_KEY_LEN) {
    throw "failed to initialize AES key";
  }

  fclose(f);

  AES_128_Key_Expansion(keyBytes, &key);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1430(%rip), %rdi      # 0x633f
leaq 0x1154(%rip), %rsi      # 0x606a
callq 0x22e0
testq %rax, %rax
je 0x4f55
leaq 0x100(%rbx), %r15
movq %rax, %r14
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %rax, %rcx
callq 0x2360
cmpl $0x10, %eax
jne 0x4f66
movq %r14, %rdi
callq 0x2260
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4f89
pushq $0x8
popq %rdi
callq 0x2140
leaq 0x13cc(%rip), %rcx      # 0x6330
jmp 0x4f75
pushq $0x8
popq %rdi
callq 0x2140
leaq 0x13d7(%rip), %rcx      # 0x634c
movq 0x404c(%rip), %rsi      # 0x8fc8
movq %rcx, (%rax)
movq %rax, %rdi
xorl %edx, %edx
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/jBlinden[P]private-codis/util.cpp
// Function: AESContext::FillBuffer(unsigned char*, unsigned int, unsigned long) const
void AESContext::FillBuffer(uint8_t* buf, uint32_t len, uint64_t tag) const {
  uint32_t nBlocks = len / sizeof(block);
  uint32_t bytesRemaining = len % sizeof(block);

  GetBlocks((block*) buf, nBlocks, tag);
  if (bytesRemaining != 0) {
    block lastBlock;
    GetBlock(lastBlock, tag, nBlocks);

    memcpy(buf + nBlocks * sizeof(block), &lastBlock, bytesRemaining);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r14d
shrl $0x4, %r14d
movl %edx, %ebp
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movl %r14d, %edx
callq 0x51b6
andl $0xf, %ebp
je 0x52bf
movq %rsp, %r13
movl %r14d, %ecx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x516e
shll $0x4, %r14d
movl %ebp, %edx
movq %r13, %rsi
addq %r14, %rbx
movq %rbx, %rdi
callq 0x21c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/superblocks[P]superblocks/set-cdc.cpp
// Function: Superblocks::init()
void Superblocks::init() {

  coin = "CDC"; 
	coin_name = "Cloudcoin";

	hash_length = 64;

	// normal (step 0)
	reward[0] = 50;

	// superblocks

	seed_type[1] = SEED_WITH_PREVIOUS_BLOCK_HASH;
	cutout_start[1] = 6;
	cutout_length[1] = 7;
	rnd_range_low[1] = 1;
	rnd_range_high[1] = 14400;
	luck_type[1] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[1] = 10000;
	luck_y[1] = 10011;
	reward[1] = 4400;

	luck_type[2] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[2] = 2000;
	luck_y[2] = 2031;
	reward[2] = 900;

	luck_type[3] = LUCK_WITH_MORE_THAN_X_AND_LESS_THAN_Y;
	luck_x[3] = 8000;
	luck_y[3] = 8101;
	reward[3] = 400;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
leaq 0xe04(%rip), %rsi       # 0x2b00
callq 0x1160
leaq 0x38(%rbx), %rdi
leaq 0xdf8(%rip), %rsi       # 0x2b04
callq 0x1160
movl $0x40, 0x58(%rbx)
movabsq $0x113000000032, %rax   # imm = 0x113000000032
movq %rax, 0x14c(%rbx)
movl $0x2, 0x60(%rbx)
movl $0x6, 0x70(%rbx)
movl $0x7, 0x80(%rbx)
movl $0x1, 0x90(%rbx)
movl $0x3840, 0xa0(%rbx)     # imm = 0x3840
movl $0x3, 0x120(%rbx)
movl $0x2710, 0x130(%rbx)    # imm = 0x2710
movl $0x271b, 0x140(%rbx)    # imm = 0x271B
movabsq $0x300000003, %rax      # imm = 0x300000003
movq %rax, 0x124(%rbx)
movabsq $0x1f40000007d0, %rax   # imm = 0x1F40000007D0
movq %rax, 0x134(%rbx)
movabsq $0x1fa5000007ef, %rax   # imm = 0x1FA5000007EF
movq %rax, 0x144(%rbx)
movabsq $0x19000000384, %rax    # imm = 0x19000000384
movq %rax, 0x154(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gty980218[P]ee450/hospitalC.cpp
// Function: main
int main(int argc, char *argv[]){
    if(argc!=4){
        fprintf(stderr,"Missing location,capacity or occupancy parameters!\n");
        exit(1);
    }

    int size=indice_map.size();
    Hospital hospital(atoi(argv[2]),atoi(argv[3]),init(atoi(argv[1])),atoi(argv[1]));
    //create socket 
	int sock;
	if((sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0){
        fprintf(stderr,"Create socket failed!\n");
        exit(1);
    }                                                       //SOCK_DGRAM for UDP
	//initialize address
	struct  sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;                          //use IPv4
	servaddr.sin_port = htons(32188);
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);           //0.0.0.0 stands for all IPs in local host,listening all NIC's ports 
    //bind
	if(bind(sock, (struct sockaddr*)& servaddr, sizeof(servaddr)) < 0){
        fprintf(stderr,"Binding failed,check the availability of port!\n");
        exit(1);
    }
    //send initialized occpation and capacity
    ready(sock,hospital);
    //waiting for client
    serve(sock,hospital);
    close(sock);
    
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
cmpl $0x4, %edi
jne 0x251b
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x2290
movl %eax, %r14d
movq 0x18(%rbx), %rdi
callq 0x2290
movl %eax, %r15d
movq 0x8(%rbx), %rdi
callq 0x2290
movl %eax, %edi
callq 0x258d
movq %rax, %r12
movq 0x8(%rbx), %rdi
callq 0x2290
movl %r14d, -0x38(%rbp)
movl %r15d, -0x34(%rbp)
movq %r12, -0x28(%rbp)
movl %eax, -0x30(%rbp)
pushq $0x2
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x20a0
testl %eax, %eax
jns 0x253f
movq 0x3acb(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x1b45(%rip), %rdi      # 0x405c
pushq $0x16
jmp 0x252e
movq 0x3ab6(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x1afc(%rip), %rdi      # 0x4028
pushq $0x33
popq %rsi
pushq $0x1
popq %rdx
callq 0x2310
pushq $0x1
popq %rdi
callq 0x2240
movl %eax, %ebx
leaq -0x48(%rbp), %rsi
andq $0x0, 0x8(%rsi)
movl $0xbc7d0002, %eax       # imm = 0xBC7D0002
movq %rax, (%rsi)
pushq $0x10
popq %rdx
movl %ebx, %edi
callq 0x2050
testl %eax, %eax
jns 0x2575
movq 0x3a71(%rip), %rax      # 0x5fd8
movq (%rax), %rcx
leaq 0x1b02(%rip), %rdi      # 0x4073
pushq $0x2f
jmp 0x252e
leaq -0x38(%rbp), %r14
movl %ebx, %edi
movq %r14, %rsi
callq 0x2779
movl %ebx, %edi
movq %r14, %rsi
callq 0x28e2
// File: /workspace/github_cpp_makefile_star2_O2/gty980218[P]ee450/hospitalC.cpp
// Function: ready(int, Hospital&)
void ready(int sock,Hospital& hospital){
    //initialize schedular's address
    struct sockaddr_in scheaddr;
    memset(&scheaddr, 0, sizeof(scheaddr));
    scheaddr.sin_family=AF_INET;
    scheaddr.sin_port=htons(33188);
    scheaddr.sin_addr.s_addr=inet_addr("127.0.0.1");
    socklen_t schelen=sizeof(scheaddr);

    //send occupancy and capability
    char buff[8]={0};
    stringstream ss;
    ss<<hospital.capacity<<" "<<hospital.occupancy<<endl;
    string str=ss.str();
    strcpy(buff,str.c_str());
    sendto(sock, buff, sizeof(buff), 0, (struct sockaddr*)&scheaddr, schelen);

    cout<<"Hospital C is up and running using UDP on port 32188"<<endl;
    cout<<"Hospital C has total capacity "<<hospital.capacity<<" and initial occupancy "<<hospital.occupancy<<endl;
    cout<<"------------------------------------------------------------------------------------------------"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %rbx
movl %edi, %r14d
andq $0x0, -0x28(%rbp)
movl $0xa4810002, -0x30(%rbp) # imm = 0xA4810002
leaq 0x1901(%rip), %rdi      # 0x40a3
callq 0x2200
movl %eax, -0x2c(%rbp)
andq $0x0, -0x20(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x2160
leaq -0x1c8(%rbp), %rdi
movl (%rbx), %esi
callq 0x22e0
leaq 0x1abf(%rip), %rsi      # 0x428f
movq %rax, %rdi
callq 0x21e0
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
callq 0x2120
leaq -0x1c0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x22b0
movq -0x50(%rbp), %rsi
leaq -0x20(%rbp), %r15
movq %r15, %rdi
callq 0x21d0
pushq $0x8
popq %rdx
leaq -0x30(%rbp), %r8
pushq $0x10
popq %r9
movl %r14d, %edi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x2040
movq 0x37a6(%rip), %rdi      # 0x5fd0
leaq 0x187c(%rip), %rsi      # 0x40ad
callq 0x21e0
movq %rax, %rdi
callq 0x2120
movq 0x378b(%rip), %rdi      # 0x5fd0
leaq 0x1896(%rip), %rsi      # 0x40e2
callq 0x21e0
movl (%rbx), %esi
movq %rax, %rdi
callq 0x22e0
leaq 0x189f(%rip), %rsi      # 0x4101
movq %rax, %rdi
callq 0x21e0
movl 0x4(%rbx), %esi
movq %rax, %rdi
callq 0x22e0
movq %rax, %rdi
callq 0x2120
movq 0x374c(%rip), %rdi      # 0x5fd0
leaq 0x188e(%rip), %rsi      # 0x4119
callq 0x21e0
movq %rax, %rdi
callq 0x2120
leaq -0x50(%rbp), %rdi
callq 0x2110
leaq -0x1d8(%rbp), %rdi
callq 0x2180
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x28bd
movq %rax, %rbx
jmp 0x28ce
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2110
leaq -0x1d8(%rbp), %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x22f0
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/ServerInfo.cpp
// Function: ServerInfo::setServer(int, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void	ServerInfo::setServer(int nb, int const &pos, std::string const &buf)
{
	typedef void (ServerInfo::*MemFuncPtr)(const char*);
	MemFuncPtr F[] = { &ServerInfo::setPort, &ServerInfo::setError, &ServerInfo::setNames, 
                        &ServerInfo::setMaxClientsBS, &ServerInfo::setHost };
                        
    const char *tmp = buf.c_str() + pos;
	int i = 0;

	while (isspace(tmp[i]))
        i++;
    
	(this->*F[nb])(tmp + i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %r15d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x50(%rbp)
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x30(%rbp)
leaq 0x7d(%rip), %rax        # 0x5a74
movq %rax, -0x70(%rbp)
leaq 0x1fa(%rip), %rax       # 0x5bfc
movq %rax, -0x60(%rbp)
leaq 0x2dd(%rip), %rax       # 0x5cea
movq %rax, -0x50(%rbp)
leaq 0x2e6(%rip), %rax       # 0x5cfe
movq %rax, -0x40(%rbp)
leaq 0x465(%rip), %rax       # 0x5e88
movq %rax, -0x30(%rbp)
movq (%rcx), %rax
movslq (%rdx), %rcx
leaq (%rcx,%rax), %r14
decq %r14
movsbl 0x1(%r14), %edi
incq %r14
callq 0x4060
testl %eax, %eax
jne 0x5a34
movslq %r15d, %rcx
shlq $0x4, %rcx
movq -0x70(%rbp,%rcx), %rax
addq -0x68(%rbp,%rcx), %rbx
testb $0x1, %al
je 0x5a62
movq (%rbx), %rcx
movq -0x1(%rcx,%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/ServerInfo.cpp
// Function: ServerInfo::setPort(char const*)
void ServerInfo::setPort(char const *p) 
{
    std::string cString = p;
    if (numberOfWords(p) != 1)
        throw std::runtime_error("Error : " + cString + " - put only one port to listen\n");
    
    cString = *wsTrim(cString);
    for (size_t i = 0; i < cString.size(); i++) 
		if (cString[i] < 48 || cString[i]  > 57)
			throw std::runtime_error("Error : " + cString + " - use only digit for listen\n");
    
    _port = atoi(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x4ec8
movq %r14, %rdi
callq 0x93dc
cmpq $0x1, %rax
jne 0x5b56
leaq -0x38(%rbp), %rdi
callq 0x947b
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x4270
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x5b38
movb (%rax,%rdx), %sil
addb $-0x3a, %sil
incq %rdx
cmpb $-0xb, %sil
ja 0x5ac5
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq 0xb594(%rip), %rsi      # 0x11081
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x5f8b
leaq 0xb5ae(%rip), %rdx      # 0x110af
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4f37
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4650
xorl %r15d, %r15d
movq 0x134c9(%rip), %rsi     # 0x18ff0
movq 0x1349a(%rip), %rdx     # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
jmp 0x5bb1
movq %r14, %rdi
callq 0x4600
movl %eax, (%rbx)
leaq -0x38(%rbp), %rdi
callq 0x47d8
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq 0xb519(%rip), %rsi      # 0x11081
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x5f8b
leaq 0xb56d(%rip), %rdx      # 0x110e9
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4f37
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4650
xorl %r15d, %r15d
movq 0x1344e(%rip), %rsi     # 0x18ff0
movq 0x1341f(%rip), %rdx     # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
jmp 0x5bbc
jmp 0x5bca
jmp 0x5be0
movq %rax, %r14
jmp 0x5beb
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x47d8
jmp 0x5bd0
movq %rax, %r14
movb $0x1, %r15b
leaq -0x78(%rbp), %rdi
callq 0x47d8
testb %r15b, %r15b
jne 0x5be3
jmp 0x5beb
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
leaq -0x38(%rbp), %rdi
callq 0x47d8
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/ServerInfo.cpp
// Function: ServerInfo::setMaxClientsBS(char const*)
void ServerInfo::setMaxClientsBS(char const *m)
{
    std::string cString = m;
    if (numberOfWords(m) != 1)
        throw std::runtime_error("Error : " + cString + " - put only one input for body size\n");
    
    cString = *wsTrim(cString);
    for (size_t i = 0; i < cString.size(); i++) 
		if (cString[i] < 48 || cString[i]  > 57)
			throw std::runtime_error("Error : " + cString + " - use only digit for listen\n");

    _max_cli_body = atoi(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x4ec8
movq %r14, %rdi
callq 0x93dc
cmpq $0x1, %rax
jne 0x5de1
leaq -0x38(%rbp), %rdi
callq 0x947b
leaq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x4270
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x5dc2
movb (%rax,%rdx), %sil
addb $-0x3a, %sil
incq %rdx
cmpb $-0xb, %sil
ja 0x5d4f
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq 0xb30a(%rip), %rsi      # 0x11081
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x5f8b
leaq 0xb324(%rip), %rdx      # 0x110af
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4f37
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4650
xorl %r15d, %r15d
movq 0x1323f(%rip), %rsi     # 0x18ff0
movq 0x13210(%rip), %rdx     # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
jmp 0x5e3c
movq %r14, %rdi
callq 0x4600
movl %eax, 0x60(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x47d8
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq 0xb28e(%rip), %rsi      # 0x11081
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x5f8b
leaq 0xb283(%rip), %rdx      # 0x1108a
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x4f37
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4650
xorl %r15d, %r15d
movq 0x131c3(%rip), %rsi     # 0x18ff0
movq 0x13194(%rip), %rdx     # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
jmp 0x5e47
jmp 0x5e55
jmp 0x5e6b
movq %rax, %r14
jmp 0x5e76
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x47d8
jmp 0x5e5b
movq %rax, %r14
movb $0x1, %r15b
leaq -0x78(%rbp), %rdi
callq 0x47d8
testb %r15b, %r15b
jne 0x5e6e
jmp 0x5e76
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
leaq -0x38(%rbp), %rdi
callq 0x47d8
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/FileParser.cpp
// Function: FileParser::FileParser(char const*, bool)
FileParser::FileParser(const char *filepath, bool s) : _bracket(0), _cli_srv(0), _filePath(filepath)
{
	#if DEBUG
		std::cout << "FileParser object trying to read file at path :|" << filepath << "|\n";
	#endif
	
	_file.open(filepath);
	parseRequestFile();
	(void)s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4490
leaq 0x218(%rbx), %rax
movq %rax, 0x208(%rbx)
andq $0x0, 0x210(%rbx)
xorl %eax, %eax
movb %al, 0x218(%rbx)
andl $0x0, 0x228(%rbx)
leaq 0x238(%rbx), %rcx
andl $0x0, 0x238(%rbx)
andq $0x0, 0x240(%rbx)
movq %rcx, 0x248(%rbx)
movq %rcx, 0x250(%rbx)
andq $0x0, 0x258(%rbx)
leaq 0x268(%rbx), %rcx
andl $0x0, 0x268(%rbx)
andq $0x0, 0x270(%rbx)
movq %rcx, 0x278(%rbx)
movq %rcx, 0x280(%rbx)
andq $0x0, 0x288(%rbx)
leaq 0x2a0(%rbx), %rcx
movq %rcx, 0x290(%rbx)
andq $0x0, 0x298(%rbx)
movb %al, 0x2a0(%rbx)
andq $0x0, 0x2b0(%rbx)
leaq 0x2b8(%rbx), %r15
leaq -0x29(%rbp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x4ec8
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42c0
movq %rbx, %rdi
callq 0x6744
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x66fb
movq %rax, %r14
movq %r15, %rdi
callq 0x47d8
leaq 0x208(%rbx), %r15
leaq 0x290(%rbx), %rdi
leaq 0x260(%rbx), %r12
leaq 0x230(%rbx), %r13
callq 0x47d8
movq %r12, %rdi
callq 0x6352
movq %r13, %rdi
callq 0x55a0
movq %r15, %rdi
callq 0x47d8
movq %rbx, %rdi
callq 0x4140
movq %r14, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/FileParser.cpp
// Function: FileParser::parseConfigFile()
void FileParser::parseConfigFile()
{
	// loop for each block server if there is something else, throw an error
	while (std::getline(_file, _buf)){
		
		if (!_buf.compare(0, 9, "server {")){
			_bracket = 0;
			bracketRegulator(_bracket, _buf);
			newServer();
		}
		else if (!_buf.compare(0, 1, "}") || !_buf.compare(0, 2, ""))
			continue;
		else throw std::runtime_error(errParseMessage("error line : ", _buf.c_str(), " not a good name for server block\n")); // ERREUR 
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x208(%rdi), %rbx
leaq 0x228(%rdi), %r15
leaq 0xa6f9(%rip), %r12      # 0x11109
pushq $0x9
popq %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6a90
movq %rbx, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x4550
testl %eax, %eax
je 0x6a73
movq %rbx, %rdi
xorl %esi, %esi
pushq $0x1
popq %rdx
leaq 0xa6c2(%rip), %rcx      # 0x11112
callq 0x4550
testl %eax, %eax
je 0x6a14
movq %rbx, %rdi
xorl %esi, %esi
pushq $0x2
popq %rdx
leaq 0xac92(%rip), %rcx      # 0x116fa
callq 0x4550
testl %eax, %eax
je 0x6a14
jmp 0x6a9f
andl $0x0, 0x228(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x92bc
movq %r14, %rdi
callq 0x6b10
jmp 0x6a14
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %r14
movq (%rbx), %rsi
leaq 0xa660(%rip), %rdi      # 0x11114
leaq 0xa667(%rip), %rdx      # 0x11122
callq 0x9320
movq %r14, %rdi
movq %rax, %rsi
callq 0x4650
movq 0x1251e(%rip), %rsi     # 0x18ff0
movq 0x124ef(%rip), %rdx     # 0x18fc8
movq %r14, %rdi
callq 0x46b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4330
movq %rbx, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/FileParser.cpp
// Function: FileParser::addNewLocationToMap(Location*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FileParser::addNewLocationToMap(Location *loc, std::string const &name)
{
	std::map<std::string, Location>::iterator it = _m_loc.find(name);
	
	if (it == _m_loc.end())
		_m_loc.insert(std::pair<std::string, Location>(name, *loc));
	else
		throw std::runtime_error(errParseMessage("Error : location ", name.c_str(), " already exist\n"));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x260(%rdi), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7e84
addq $0x268, %r12            # imm = 0x268
cmpq %r12, %rax
jne 0x71c5
leaq -0x108(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7470
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7f0e
leaq -0x108(%rbp), %rdi
callq 0x74a6
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
movq (%r14), %rsi
leaq 0xa00f(%rip), %rdi      # 0x111e9
leaq 0xa01a(%rip), %rdx      # 0x111fb
callq 0x9320
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4650
movq 0x11df8(%rip), %rsi     # 0x18ff0
movq 0x11dc9(%rip), %rdx     # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
jmp 0x7223
movq %rax, %r14
leaq -0x108(%rbp), %rdi
callq 0x74a6
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/FileParser.cpp
// Function: FileParser::addNewServerToMap(ServerInfo&)
void FileParser::addNewServerToMap(ServerInfo &srv)
{
	int s_port = srv.getPort();
	srv.setSrvLocation()->insert(_m_loc.begin(), _m_loc.end());
	std::map<int, std::vector<ServerInfo> >::iterator it = _m_srv.find(s_port);
		
	if (it == _m_srv.end()){
		std::vector<ServerInfo> v_srv(1, srv);
		_m_srv.insert(std::pair<int, std::vector<ServerInfo> >(s_port, v_srv));
	}
	else
		it->second.push_back(srv);
	_m_loc.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x59a8
movl (%rax), %eax
leaq -0x2c(%rbp), %r12
movl %eax, (%r12)
movq %r14, %rdi
callq 0x5e96
movq 0x278(%rbx), %rsi
leaq 0x268(%rbx), %rdx
movq %rax, %rdi
callq 0x767a
leaq 0x230(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x79ba
leaq 0x238(%rbx), %rcx
cmpq %rcx, %rax
je 0x72a2
addq $0x28, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x7432
jmp 0x72ee
leaq -0x48(%rbp), %r12
pushq $0x1
popq %rsi
leaq -0x68(%rbp), %r13
movq %r12, %rdi
movq %r14, %rdx
movq %r13, %rcx
callq 0x73d2
movl -0x2c(%rbp), %eax
movl %eax, (%r13)
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x53b2
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x7ac0
movq %r14, %rdi
callq 0x5300
leaq -0x48(%rbp), %rdi
callq 0x5300
addq $0x260, %rbx            # imm = 0x260
movq %rbx, %rdi
callq 0x7e4c
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x5300
jmp 0x731c
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x5300
movq %rbx, %rdi
callq 0x46d0
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setLocation(int, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void	Location::setLocation(int nb, int const &pos, std::string const &buf)
{
	typedef void (Location::*MemFuncPtr)(const char*);
	MemFuncPtr F[] = { &Location::setMethods, &Location::setIndex,
						&Location::setUploadStore, &Location::setRoot, &Location::setCgiExe, 
						&Location::setAutoIndex, &Location::setRedirect};

	const char *tmp = buf.c_str() + pos;
	int i = 0;

	while (isspace(tmp[i]))
		i++;

	(this->*F[nb])(tmp + i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movq (%rcx), %rax
movslq (%rdx), %rcx
leaq (%rcx,%rax), %r14
decq %r14
movsbl 0x1(%r14), %edi
incq %r14
callq 0x4060
testl %eax, %eax
jne 0x8427
movslq %r15d, %rax
shlq $0x4, %rax
leaq 0x108da(%rip), %rcx     # 0x18d20
movq (%rax,%rcx), %rax
testb $0x1, %al
je 0x8456
movq (%rbx), %rcx
movq -0x1(%rcx,%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setUploadStore(char const*)
void Location::setUploadStore(char const *u) 
{
	std::string cString = u;
	if (numberOfWords(u) != 1)
		throw std::runtime_error("Error : " + std::string(cString) + " - put only one upload_path input\n");
	_upload_path = *wsTrim(cString);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x4ec8
movq %r14, %rdi
callq 0x93dc
cmpq $0x1, %rax
jne 0x8506
leaq -0x38(%rbp), %rdi
callq 0x947b
addq $0x28, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4270
leaq -0x38(%rbp), %rdi
callq 0x47d8
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4580
leaq 0x8b5c(%rip), %rsi      # 0x11081
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x4f60
leaq 0x8d30(%rip), %rdx      # 0x1126c
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4f37
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4650
xorl %r15d, %r15d
movq 0x10a8b(%rip), %rsi     # 0x18ff0
movq 0x10a5c(%rip), %rdx     # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x47d8
jmp 0x8588
movq %rax, %r14
movb $0x1, %r15b
leaq -0x98(%rbp), %rdi
callq 0x47d8
jmp 0x859c
movq %rax, %r14
movb $0x1, %r15b
leaq -0x78(%rbp), %rdi
callq 0x47d8
testb %r15b, %r15b
jne 0x85af
jmp 0x85bc
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
jmp 0x85bc
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x47d8
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setRoot(char const*)
void Location::setRoot(char const *r) 
{
	std::string cString = r;
	if (numberOfWords(r) != 1)
		throw std::runtime_error("Error : " + std::string(cString) + " - put only one root path\n");
	_root = *wsTrim(cString);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x4ec8
movq %r14, %rdi
callq 0x93dc
cmpq $0x1, %rax
jne 0x862e
leaq -0x38(%rbp), %rdi
callq 0x947b
addq $0x8, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4270
leaq -0x38(%rbp), %rdi
callq 0x47d8
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x4580
leaq 0x8a34(%rip), %rsi      # 0x11081
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x4f60
leaq 0x8bed(%rip), %rdx      # 0x11251
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x4f37
movb $0x1, %r15b
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x4650
xorl %r15d, %r15d
movq 0x10963(%rip), %rsi     # 0x18ff0
movq 0x10934(%rip), %rdx     # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x47d8
jmp 0x86b0
movq %rax, %r14
movb $0x1, %r15b
leaq -0x98(%rbp), %rdi
callq 0x47d8
jmp 0x86c4
movq %rax, %r14
movb $0x1, %r15b
leaq -0x78(%rbp), %rdi
callq 0x47d8
testb %r15b, %r15b
jne 0x86d7
jmp 0x86e4
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
jmp 0x86e4
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x47d8
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setCgiExe(char const*)
void Location::setCgiExe(char const *c) 
{
	std::vector<std::string> cgiTmp;
	setStringArray(c, cgiTmp);
	if (cgiTmp.size() != 2)
		throw std::runtime_error("Wrong cgi input in the config file\n"); 
	_cgi_exe.insert(std::pair<std::string, std::string>(cgiTmp[0], cgiTmp[1]));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rax, %rdi
callq 0x94ca
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rax
subq %rsi, %rax
cmpq $0x40, %rax
jne 0x876a
leaq 0x20(%rsi), %rdx
leaq -0x70(%rbp), %rdi
callq 0x8ca8
addq $0x98, %rbx
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x908e
leaq -0x70(%rbp), %rdi
callq 0x8cde
leaq -0x30(%rbp), %rdi
callq 0x5ef4
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %r14
leaq 0x8b33(%rip), %rsi      # 0x112af
movq %rax, %rdi
callq 0x41c0
movq 0x10865(%rip), %rsi     # 0x18ff0
movq 0x10836(%rip), %rdx     # 0x18fc8
movq %r14, %rdi
callq 0x46b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x4330
jmp 0x87ba
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x8cde
jmp 0x87ba
jmp 0x87b7
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x5ef4
movq %rbx, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setAutoIndex(char const*)
void Location::setAutoIndex(char const *i)
{
	std::string tmp(i);
	tmp = *wsTrim(tmp);
	if (tmp.compare("on") && tmp.compare("off"))
		throw std::runtime_error("Error autoIndex : " + std::string(i) + "isn't a good input\n");
	else if (!tmp.compare("on"))
		_autoindex = 1;
	else
		_autoindex = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r15
leaq -0x60(%rbp), %rdx
movq %r15, %rdi
callq 0x4ec8
movq %r15, %rdi
callq 0x947b
leaq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x4270
leaq 0x90d6(%rip), %rsi      # 0x118e3
leaq -0x40(%rbp), %rdi
callq 0x4170
testl %eax, %eax
je 0x882e
leaq 0x8ab2(%rip), %rsi      # 0x112d3
leaq -0x40(%rbp), %rdi
callq 0x4170
testl %eax, %eax
jne 0x885d
leaq 0x90ae(%rip), %rsi      # 0x118e3
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x4170
testl %eax, %eax
sete 0x4(%rbx)
movq %r14, %rdi
callq 0x47d8
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %r14, %rsi
callq 0x4ec8
leaq 0x8a58(%rip), %rsi      # 0x112d7
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x4f60
leaq 0x8a54(%rip), %rdx      # 0x112ea
leaq -0x60(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x4f37
movb $0x1, %r15b
leaq -0x60(%rbp), %rsi
movq %rbx, %rdi
callq 0x4650
xorl %r15d, %r15d
movq 0x10731(%rip), %rsi     # 0x18ff0
movq 0x10702(%rip), %rdx     # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x47d8
jmp 0x88e2
movq %rax, %r14
movb $0x1, %r15b
leaq -0xa0(%rbp), %rdi
callq 0x47d8
jmp 0x88f6
movq %rax, %r14
movb $0x1, %r15b
leaq -0x80(%rbp), %rdi
callq 0x47d8
testb %r15b, %r15b
jne 0x8909
jmp 0x8916
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
jmp 0x8916
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x47d8
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setRedirect(char const*)
void Location::setRedirect(char const *r) 
{
	std::vector<std::string> v;
	setStringArray(r, v);
	if (v.size() != 1)
		throw std::runtime_error("Error : " + std::string(r) + " - too many input for redirect\n");
	_redirect = v[0];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %r14, %rdi
callq 0x94ca
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rsi, %rax
cmpq $0x20, %rax
jne 0x8989
addq $0x48, %rbx
movq %rbx, %rdi
callq 0x4270
leaq -0x40(%rbp), %rdi
callq 0x5ef4
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
movq %r14, %rsi
callq 0x4ec8
leaq 0x86d6(%rip), %rsi      # 0x11081
leaq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x4f60
leaq 0x88d0(%rip), %rdx      # 0x1128f
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x4f37
movb $0x1, %r15b
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0x4650
xorl %r15d, %r15d
movq 0x10605(%rip), %rsi     # 0x18ff0
movq 0x105d6(%rip), %rdx     # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
movq %rax, %r14
leaq -0xa0(%rbp), %rdi
callq 0x47d8
jmp 0x8a11
movq %rax, %r14
movb $0x1, %r15b
leaq -0x80(%rbp), %rdi
callq 0x47d8
jmp 0x8a22
movq %rax, %r14
movb $0x1, %r15b
leaq -0x60(%rbp), %rdi
callq 0x47d8
testb %r15b, %r15b
jne 0x8a35
jmp 0x8a42
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
jmp 0x8a42
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x5ef4
movq %r14, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: cleanLineFromSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
int	cleanLineFromSpaces(std::string &buf)
{
	int i = 0;
	while (isspace(buf[i]))
		buf.erase(0, 1);

	if (buf.size()){
		i = buf.size() - 1;
		while (isspace(buf[i]))
			buf.erase(i, 1);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %r14
movq (%rbx), %r12
movsbl (%r12), %edi
callq 0x4060
testl %eax, %eax
je 0x927e
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x40f0
jmp 0x925e
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x92b1
decl %eax
movslq %eax, %r14
pushq $0x1
popq %r15
movsbl (%r12,%r14), %edi
callq 0x4060
testl %eax, %eax
je 0x92b1
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x40f0
movq (%rbx), %r12
jmp 0x9290
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: bracketRegulator(int&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int	bracketRegulator(int &bracket, std::string const &buf)
{
	size_t pos = -1; 
	while ( (pos = buf.find_first_of('{', pos + 1)) != std::string::npos) 
		bracket++;
	
	pos = -1;
	while ( (pos = buf.find_first_of('}', pos + 1)) != std::string::npos)
		bracket--;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %rax
pushq $0x7b
popq %r15
incq %rax
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x4540
cmpq $-0x1, %rax
je 0x92ef
incl (%r14)
jmp 0x92d3
pushq $-0x1
popq %rax
pushq $0x7d
popq %r15
incq %rax
movq %rbx, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x4540
cmpq $-0x1, %rax
je 0x9312
decl (%r14)
jmp 0x92f6
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: errParseMessage[abi:cxx11](char const*, char const*, char const*)
std::string const &errParseMessage(char const *begErrMsg, char const *errorToAdd, char const *endErrMsg)
{
	static std::string fullErrMsg;

	fullErrMsg.clear();
	fullErrMsg = begErrMsg;
	fullErrMsg += errorToAdd;
	fullErrMsg += endErrMsg;

	return fullErrMsg;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb 0x1010e(%rip), %al      # 0x19448
testb %al, %al
je 0x9384
andq $0x0, 0x100ea(%rip)     # 0x19430
leaq 0x100db(%rip), %r12     # 0x19428
movq 0x100d4(%rip), %rax     # 0x19428
movb $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x4780
movq %r12, %rdi
movq %r14, %rsi
callq 0x4770
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4770
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x100bd(%rip), %rdi     # 0x19448
callq 0x4730
testl %eax, %eax
je 0x933e
leaq 0x1009d(%rip), %rax     # 0x19438
movq %rax, 0x10086(%rip)     # 0x19428
leaq 0x1007f(%rip), %rsi     # 0x19428
andq $0x0, 0x1007f(%rip)     # 0x19430
movb $0x0, 0x10080(%rip)     # 0x19438
movq 0xfbf9(%rip), %rdi      # 0x18fb8
leaq 0x1002a(%rip), %rdx     # 0x193f0
callq 0x43a0
leaq 0x10076(%rip), %rdi     # 0x19448
callq 0x42d0
jmp 0x933e
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: numberOfWords(char const*)
size_t numberOfWords(char const *buf)
{
	int word = 0, index = 0;
	while (buf[index] != '\0'){
		while (isspace(buf[index]))
			index++;
		int tmp = index;
		while (isalnum(buf[index]) || ispunct(buf[index]))
			index++;
		if (tmp !=  index)
			word++;
	}
	return word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x1(%rdi), %rax
movq %rax, -0x38(%rbp)
xorl %r12d, %r12d
xorl %eax, %eax
movslq %r12d, %r12
cmpb $0x0, (%rbx,%r12)
je 0x946a
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
leaq (%rax,%r12), %rcx
decq %r12
movq %rcx, %r15
movb 0x1(%rbx,%r12), %r14b
movsbl %r14b, %edi
callq 0x4060
incq %r12
leaq 0x1(%r15), %rcx
testl %eax, %eax
jne 0x9415
xorl %r13d, %r13d
movsbl %r14b, %r14d
movl %r14d, %edi
callq 0x4450
testl %eax, %eax
jne 0x9450
movl %r14d, %edi
callq 0x4790
testl %eax, %eax
je 0x945b
movb (%r15), %r14b
decq %r13
incq %r15
jmp 0x9434
cmpq $0x1, %r13
movl -0x2c(%rbp), %eax
sbbl $-0x1, %eax
subq %r13, %r12
jmp 0x93fd
movl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: wsTrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string *wsTrim(std::string &buf)
{
    if (buf.empty())
        return &buf;
    for (std::string::iterator it = buf.end(); it != buf.begin(); --it)
        if (isspace(*it))
            buf.erase(it);            
    return &buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x94bc
movq (%rbx), %r15
addq %r15, %r14
cmpq %r15, %r14
je 0x94bc
movsbl (%r14), %edi
callq 0x4060
testl %eax, %eax
je 0x94b7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4500
movq (%rbx), %r15
decq %r14
jmp 0x9497
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/parser/parserUtils.cpp
// Function: setStringArray(char const*, 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>>>>&)
void setStringArray(char const *n, std::vector<std::string> &v) 
{
    char *tmp = strdup(n);
    char *token = strtok(tmp, "\t\v\f\r ");

    while (token){
		
        v.push_back(token);
        token = strtok(NULL, "\t\v\f\r ");
    }
    free(tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
callq 0x4740
movq %rax, %r14
leaq 0x7eb8(%rip), %r15      # 0x113a5
movq %rax, %rdi
movq %r15, %rsi
callq 0x4610
leaq -0x50(%rbp), %r12
leaq -0x29(%rbp), %r13
testq %rax, %rax
je 0x9532
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x4ec8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x955e
movq %r12, %rdi
callq 0x47d8
xorl %edi, %edi
movq %r15, %rsi
callq 0x4610
jmp 0x9500
movq %r14, %rdi
callq 0x44c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x47d8
movq %rbx, %rdi
callq 0x46d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/server/HttpServer.cpp
// Function: swap(HttpServer&, HttpServer&)
void swap(HttpServer& a, HttpServer& b)
{
	std::swap(a._serverSocks, b._serverSocks);
	std::swap(a._clientSocks, b._clientSocks);
	std::swap(a._readFds, b._readFds);
	std::swap(a._writeFds, b._writeFds);
	std::swap(a._nbReadyFds, b._nbReadyFds);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa846
leaq 0x18(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0xa86e
leaq 0x30(%r14), %rax
leaq 0x30(%rbx), %rdx
pushq $0x10
popq %r8
leaq -0x90(%rbp), %r9
movq %r8, %rcx
movq %r9, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r8, %rcx
movq %rax, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r8, %rcx
movq %rdx, %rdi
movq %r9, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl $0xb0, %eax
leaq (%r14,%rax), %rdx
addq %rbx, %rax
movq %r8, %rcx
movq %r9, %rdi
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r8, %rcx
movq %rdx, %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r8, %rcx
movq %rax, %rdi
movq %r9, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl 0x130(%r14), %eax
movl 0x130(%rbx), %ecx
movl %ecx, 0x130(%r14)
movl %eax, 0x130(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/llefranc[P]42_webserv/srcs/server/HttpServer.cpp
// Function: HttpServer::etablishConnection(std::map<int, std::vector<ServerInfo, std::allocator<ServerInfo>>, std::less<int>, std::allocator<std::pair<int const, std::vector<ServerInfo, std::allocator<ServerInfo>>>>>&)
void HttpServer::etablishConnection(std::map<int, std::vector<ServerInfo> >& mSrv)
{
	struct timeval tv;

	while (true)
	{
		tv.tv_sec = MAX_SEC_TIMEOUT;
		tv.tv_usec = MAX_USEC_TIMEOUT;

		// Setting readFd with all passive accept sockets and all clients previously connected
		FD_ZERO(&_readFds);
		FD_ZERO(&_writeFds);
		
		addSocketsToReadFdSet<ServerSocket>(_serverSocks);
		addSocketsToReadFdSet<ClientSocket>(_clientSocks);
		addSocketsToWriteFdSet<ClientSocket>(_clientSocks);

		// Waiting for incoming connections on server sockets / client sockets
		if ((_nbReadyFds = select(FD_SETSIZE, &_readFds, &_writeFds, NULL, &tv)) < 0)
			throw std::runtime_error("Fatal error: select function failed\n");
		else if (!_nbReadyFds)
			throw std::runtime_error("Webserv timeout\n");

		// Send responses to clients
		sendToClients();
		// If a passive socket was activated, creates a new client connection
		connectNewClients(mSrv);
		// Receive from client
		requestHandler();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rdi), %r15
leaq 0xb0(%rdi), %r12
leaq 0x18(%rdi), %r13
movq $0x3e8, -0x38(%rbp)     # imm = 0x3E8
andq $0x0, -0x30(%rbp)
pushq $0x6
popq %rax
cmpq $0x16, %rax
je 0x996e
andq $0x0, (%r14,%rax,8)
incq %rax
jmp 0x995e
pushq $0x16
popq %rax
cmpq $0x26, %rax
je 0x9981
andq $0x0, (%r14,%rax,8)
incq %rax
jmp 0x9971
movq %r14, %rdi
movq %r14, %rsi
callq 0xa296
movq %r14, %rdi
movq %r13, %rsi
callq 0xa2fc
movq %r14, %rdi
movq %r13, %rsi
callq 0xa362
movl $0x400, %edi            # imm = 0x400
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
leaq -0x38(%rbp), %r8
callq 0x4410
movl %eax, 0x130(%r14)
testl %eax, %eax
js 0x99e5
je 0x9a01
movq %r14, %rdi
callq 0x9a46
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9dba
movq %r14, %rdi
callq 0x9fac
jmp 0x994e
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq 0x79c9(%rip), %rsi      # 0x113c0
movq %rax, %rdi
callq 0x41c0
jmp 0x9a1b
pushq $0x10
popq %rdi
callq 0x4220
movq %rax, %rbx
leaq 0x79d2(%rip), %rsi      # 0x113e5
movq %rax, %rdi
callq 0x41c0
movq 0xf5ce(%rip), %rsi      # 0x18ff0
movq 0xf59f(%rip), %rdx      # 0x18fc8
movq %rbx, %rdi
callq 0x46b0
jmp 0x9a33
movq %rax, %r14
movq %rbx, %rdi
callq 0x4330
movq %r14, %rdi
callq 0x46d0