LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: jBlinden[P]private-codis/protocol.cpp
// Function: ReadInReceiverOTsFSM2(std::basic_ifstream<char, std::char_traits<char>>&, ProtocolArgs)
ReceiverOTCorrelation** ReadInReceiverOTsFSM2(ifstream &in, struct ProtocolArgs args)
{
  args.alloc_OT = true;
  ReceiverOTCorrelation** FSM2 = new ReceiverOTCorrelation *[args.FSM2_rounds];
  for (int i = 0; i < args.FSM2_rounds; i++)
  {
    FSM2[i] = new ReceiverOTCorrelation(in, bits_FSM2);
  }
  return FSM2;
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x1, 0x28(%rsi)
movl 0xc(%rsi), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0xc(%rcx), %eax
jae 0x7a26
movl $0x130, %edi            # imm = 0x130
callq 0x32c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rsi
movl $0x6, %edx
callq 0x5de0
jmp 0x79ec
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x79b8
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x3270
jmp 0x7a30
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3460
nopw (%rax,%rax)
// File: jBlinden[P]private-codis/protocol.cpp
// Function: ReadInEntry(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int)
uint32_t* ReadInEntry(ifstream& in, uint32_t C){
  string line;
  getline(in, line, '\n');

  istringstream f(line);
  string element;

  uint32_t* entry = new uint32_t[C];
  uint32_t i = 0;

  while (getline(f, element, ',')){
    entry[i] = (uint32_t) atoi(element.c_str());
    i += 1;
  }

  return entry;
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x210(%rsp)
movl %esi, 0x20c(%rsp)
leaq 0x1e8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x33c0
movq 0x20(%rsp), %rsi
movq 0x210(%rsp), %rdi
movl $0xa, %edx
callq 0x34a0
jmp 0x7ac1
leaq 0x58(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
movl $0x8, %edx
callq 0x3430
jmp 0x7ada
leaq 0x38(%rsp), %rdi
callq 0x33c0
movl 0x20c(%rsp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x3030
movq %rax, 0x18(%rsp)
jmp 0x7afd
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl $0x2c, %edx
callq 0x34a0
movq %rax, 0x10(%rsp)
jmp 0x7b2a
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3350
movb %al, 0xf(%rsp)
jmp 0x7b44
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x7b4e
jmp 0x7bbb
leaq 0x38(%rsp), %rdi
callq 0x3120
movq %rax, %rdi
callq 0x3410
movl %eax, %edx
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x7b0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
jmp 0x7bf1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1e0(%rsp)
movl %eax, 0x1dc(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x31a0
leaq 0x58(%rsp), %rdi
callq 0x3140
jmp 0x7bf1
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x31a0
leaq 0x58(%rsp), %rdi
callq 0x3140
leaq 0x1e8(%rsp), %rdi
callq 0x31a0
movq (%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
retq
leaq 0x1e8(%rsp), %rdi
callq 0x31a0
movq 0x1e0(%rsp), %rdi
callq 0x3460
nopl (%rax,%rax)
// File: jBlinden[P]private-codis/protocol.cpp
// Function: ReadInDB(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int, unsigned int)
uint32_t** ReadInDB(ifstream& in, uint32_t N, uint32_t C){
  uint32_t **db = new uint32_t *[N];
  for (int i = 0; i < N; i++)
  {
    db[i] = ReadInEntry(in, C);
  }
  return db;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl 0x1c(%rsp), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x7c89
movq 0x20(%rsp), %rdi
movl 0x18(%rsp), %esi
callq 0x7a80
movq %rax, %rdx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x7c53
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: jBlinden[P]private-codis/./socket.h
// Function: CSocket::Socket()
uint8_t Socket() {
    uint8_t success = false;
    uint8_t bOptVal = true;
    int bOptLen = sizeof(uint8_t);
    
    Close();

    success = (m_hSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) != INVALID_SOCKET; 
    
    return success;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movb $0x0, 0xf(%rsp)
movb $0x1, 0xe(%rsp)
movl $0x1, 0x8(%rsp)
callq 0x5480
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x30b0
movq (%rsp), %rcx
movl %eax, (%rcx)
cmpl $-0x1, %eax
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: jBlinden[P]private-codis/./socket.h
// Function: CSocket::Bind(unsigned short, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
uint8_t Bind(uint16_t nPort=0, string ip = "") {
    // Bind the socket to its port
    sockaddr_in sockAddr;
    memset(&sockAddr,0,sizeof(sockAddr));
    sockAddr.sin_family = AF_INET;

    if( ip != "" ) {
      int on = 1;
      setsockopt(m_hSock, SOL_SOCKET, SO_REUSEADDR, (const char*) &on, sizeof(on));

      sockAddr.sin_addr.s_addr = inet_addr(ip.c_str());

      if (sockAddr.sin_addr.s_addr == INADDR_NONE) {
        hostent* phost;
        phost = gethostbyname(ip.c_str());
        if (phost != NULL) {
          sockAddr.sin_addr.s_addr = ((in_addr*)phost->h_addr)->s_addr;
        }
        else {
          return 0;
        }
      }
    }
    else {
      sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    }
    
    sockAddr.sin_port = htons(nPort);

    return ::bind(m_hSock, (sockaddr *) &sockAddr, sizeof(sockaddr_in)) >= 0; 
  }

// Assembly:
subq $0x58, %rsp
movq %rdx, 0x10(%rsp)
movw %si, %ax
movq %rdi, 0x48(%rsp)
movw %ax, 0x46(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3170
movq 0x10(%rsp), %rdi
movw $0x2, 0x28(%rsp)
leaq 0x2041(%rip), %rsi      # 0xa12a
callq 0x8590
testb $0x1, %al
jne 0x80f7
jmp 0x817b
movq 0x8(%rsp), %rax
movl $0x1, 0x24(%rsp)
movl (%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq 0x24(%rsp), %rcx
movl $0x4, %r8d
callq 0x3480
movq 0x10(%rsp), %rdi
callq 0x3120
movq %rax, %rdi
callq 0x32d0
movl %eax, 0x2c(%rsp)
cmpl $-0x1, 0x2c(%rsp)
jne 0x8179
movq 0x10(%rsp), %rdi
callq 0x3120
movq %rax, %rdi
callq 0x3330
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x8170
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0x2c(%rsp)
jmp 0x8177
movb $0x0, 0x57(%rsp)
jmp 0x81ba
jmp 0x8179
jmp 0x8186
xorl %edi, %edi
callq 0x31f0
movl %eax, 0x2c(%rsp)
movzwl 0x46(%rsp), %edi
callq 0x3060
movw %ax, %cx
movq 0x8(%rsp), %rax
movw %cx, 0x2a(%rsp)
movl (%rax), %edi
leaq 0x28(%rsp), %rsi
movl $0x10, %edx
callq 0x3070
cmpl $0x0, %eax
setge %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jBlinden[P]private-codis/./socket.h
// Function: CSocket::Connect(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned short, int)
uint8_t Connect(string ip, uint16_t port, int32_t lTOSMilisec = -1) {
    sockaddr_in sockAddr;
    memset(&sockAddr,0,sizeof(sockAddr));
    sockAddr.sin_family = AF_INET;
    sockAddr.sin_addr.s_addr = inet_addr(ip.c_str());

    if (sockAddr.sin_addr.s_addr == INADDR_NONE) {
      hostent* lphost;
      lphost = gethostbyname(ip.c_str());
      if (lphost != NULL) {
        sockAddr.sin_addr.s_addr = ((in_addr*)lphost->h_addr)->s_addr;
      }
      else {
        return 0;
      }
    }

    sockAddr.sin_port = htons(port);
  
    timeval tv;
    socklen_t len;
    
    if (lTOSMilisec > 0) {
      tv.tv_sec = lTOSMilisec/1000;
      tv.tv_usec = (lTOSMilisec%1000)*1000;
  
      setsockopt(m_hSock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
    }

    int ret = connect(m_hSock, (sockaddr*)&sockAddr, sizeof(sockAddr));
    
    if (ret >= 0 && lTOSMilisec > 0) {
      tv.tv_sec = 100000; 
      tv.tv_usec = 0;

      setsockopt(m_hSock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
    }

    return ret >= 0;
  }

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x10(%rsp)
movw %dx, %ax
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movw %ax, 0x4e(%rsp)
movl %ecx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x3170
movq 0x10(%rsp), %rdi
movw $0x2, 0x38(%rsp)
callq 0x3120
movq %rax, %rdi
callq 0x32d0
movl %eax, 0x3c(%rsp)
cmpl $-0x1, 0x3c(%rsp)
jne 0x832d
movq 0x10(%rsp), %rdi
callq 0x3120
movq %rax, %rdi
callq 0x3330
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x8321
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
jmp 0x832b
movb $0x0, 0x67(%rsp)
jmp 0x83fa
jmp 0x832d
movzwl 0x4e(%rsp), %edi
callq 0x3060
movw %ax, 0x3a(%rsp)
cmpl $0x0, 0x48(%rsp)
jle 0x8391
movl 0x48(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
cltq
movq %rax, 0x20(%rsp)
movl 0x48(%rsp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
movq 0x8(%rsp), %rax
imull $0x3e8, %edx, %ecx      # imm = 0x3E8
movslq %ecx, %rcx
movq %rcx, 0x28(%rsp)
movl (%rax), %edi
movl $0x1, %esi
movl $0x14, %edx
leaq 0x20(%rsp), %rcx
movl $0x10, %r8d
callq 0x3480
movq 0x8(%rsp), %rax
movl (%rax), %edi
leaq 0x38(%rsp), %rsi
movl $0x10, %edx
callq 0x3210
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x18(%rsp)
jl 0x83ec
cmpl $0x0, 0x48(%rsp)
jle 0x83ec
movq 0x8(%rsp), %rax
movq $0x186a0, 0x20(%rsp)    # imm = 0x186A0
movq $0x0, 0x28(%rsp)
movl (%rax), %edi
movl $0x1, %esi
movl $0x14, %edx
leaq 0x20(%rsp), %rcx
movl $0x10, %r8d
callq 0x3480
cmpl $0x0, 0x18(%rsp)
setge %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movb 0x67(%rsp), %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jBlinden[P]private-codis/./socket.h
// Function: CSocket::ReceiveLarge(unsigned char*, unsigned long)
void ReceiveLarge(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;
        }
      }
      Receive(pBuf + i * BLK_SIZE, batchSize);
    }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
addq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
subq $0x1, %rax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x84c8
movl $0x7fffffff, 0x14(%rsp) # imm = 0x7FFFFFFF
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8499
movq 0x20(%rsp), %rax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x8497
movl $0x7fffffff, 0x14(%rsp) # imm = 0x7FFFFFFF
jmp 0x8499
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
imull $0x7fffffff, 0x18(%rsp), %eax # imm = 0x7FFFFFFF
cltq
addq %rax, %rsi
movl 0x14(%rsp), %edx
xorl %ecx, %ecx
callq 0x85f0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x8452
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
addq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
subq $0x1, %rax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x8588
movl $0x7fffffff, 0x14(%rsp) # imm = 0x7FFFFFFF
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8559
movq 0x20(%rsp), %rax
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x8557
movl $0x7fffffff, 0x14(%rsp) # imm = 0x7FFFFFFF
jmp 0x8559
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
imull $0x7fffffff, 0x18(%rsp), %eax # imm = 0x7FFFFFFF
cltq
addq %rax, %rsi
movl 0x14(%rsp), %edx
xorl %ecx, %ecx
callq 0x87e0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x8512
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
xorl %edi, %edi
leaq 0x20(%rsp), %rsi
callq 0x3250
movq (%rsp), %rax
movslq 0x34(%rsp), %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movl (%rax), %edi
movq 0x38(%rsp), %rsi
movslq 0x34(%rsp), %rdx
movl 0x30(%rsp), %ecx
callq 0x3160
movl %eax, 0xc(%rsp)
xorl %edi, %edi
leaq 0x10(%rsp), %rsi
callq 0x3250
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
subq 0x20(%rsp), %rcx
imulq $0x3b9aca00, %rcx, %rcx # imm = 0x3B9ACA00
addq 0x18(%rsp), %rcx
subq 0x28(%rsp), %rcx
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x1aa5(%rip), %rdi      # 0xa33f
leaq 0x17c9(%rip), %rsi      # 0xa06a
callq 0x3340
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x88da
movl $0x8, %edi
callq 0x3150
movq %rax, %rdi
leaq 0x1a69(%rip), %rax      # 0xa330
movq %rax, (%rdi)
movq 0x46f7(%rip), %rsi      # 0xcfc8
xorl %eax, %eax
movl %eax, %edx
callq 0x3440
movq 0x8(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq 0x18(%rsp), %rcx
movl $0x1, %esi
movl $0x10, %edx
callq 0x33e0
movl %eax, 0x14(%rsp)
cmpl $0x10, 0x14(%rsp)
je 0x892c
movl $0x8, %edi
callq 0x3150
movq %rax, %rdi
leaq 0x1a33(%rip), %rax      # 0xa34c
movq %rax, (%rdi)
movq 0x46a5(%rip), %rsi      # 0xcfc8
xorl %eax, %eax
movl %eax, %edx
callq 0x3440
movq 0x18(%rsp), %rdi
callq 0x32b0
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x8950
addq $0x28, %rsp
retq
nop
// File: jBlinden[P]private-codis/./aes.h
// Function: AES_ecb_encrypt_blk(long long vector[2]*, AESKey const*)
static inline void AES_ecb_encrypt_blk(block *blk, const AESKey *key) {
    unsigned j, rnds = ROUNDS(key);
    const __m128i *sched = ((__m128i *) (key->rd_key));
    *blk = _mm_xor_si128(*blk, sched[0]);
    for (j = 1; j < rnds; ++j) {
        *blk = _mm_aesenc_si128(*blk, sched[j]);
    }
    *blk = _mm_aesenclast_si128(*blk, sched[j]);
}

// Assembly:
pushq %rax
movq %rdi, -0x68(%rsp)
movq %rsi, -0x70(%rsp)
movq -0x70(%rsp), %rax
movl 0xf0(%rax), %eax
movl %eax, -0x78(%rsp)
movq -0x70(%rsp), %rax
movq %rax, -0x80(%rsp)
movq -0x68(%rsp), %rax
vmovdqa (%rax), %xmm1
movq -0x80(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, -0x50(%rsp)
vmovdqa %xmm0, -0x60(%rsp)
vmovdqa -0x50(%rsp), %xmm0
vpxor -0x60(%rsp), %xmm0, %xmm0
movq -0x68(%rsp), %rax
vmovdqa %xmm0, (%rax)
movl $0x1, -0x74(%rsp)
movl -0x74(%rsp), %eax
cmpl -0x78(%rsp), %eax
jae 0x9a59
movq -0x68(%rsp), %rax
vmovdqa (%rax), %xmm1
movq -0x80(%rsp), %rax
movl -0x74(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, -0x30(%rsp)
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x30(%rsp), %xmm0
vmovdqa -0x40(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
movq -0x68(%rsp), %rax
vmovdqa %xmm0, (%rax)
movl -0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rsp)
jmp 0x99ff
movq -0x68(%rsp), %rax
vmovdqa (%rax), %xmm1
movq -0x80(%rsp), %rax
movl -0x74(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, -0x10(%rsp)
vmovdqa %xmm0, -0x20(%rsp)
vmovdqa -0x10(%rsp), %xmm0
vmovdqa -0x20(%rsp), %xmm1
vaesenclast %xmm1, %xmm0, %xmm0
movq -0x68(%rsp), %rax
vmovdqa %xmm0, (%rax)
popq %rax
retq
nop
// File: jBlinden[P]private-codis/./aes.h
// Function: AES_ecb_encrypt_blks(long long vector[2]*, int, AESKey const*)
static inline void AES_ecb_encrypt_blks(block *blks, int nblks, const AESKey *key) {
    unsigned j, rnds = ROUNDS(key);
    const __m128i *sched = ((__m128i *) (key->rd_key));
    for (int i = 0; i < nblks; ++i)
        blks[i] = _mm_xor_si128(blks[i], sched[0]);
    for (j = 1; j < rnds; ++j)
        for (int i = 0; i < nblks; ++i)
            blks[i] = _mm_aesenc_si128(blks[i], sched[j]);
    for (int i = 0; i < nblks; ++i)
        blks[i] = _mm_aesenclast_si128(blks[i], sched[j]);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, -0x48(%rsp)
movl %esi, -0x4c(%rsp)
movq %rdx, -0x58(%rsp)
movq -0x58(%rsp), %rax
movl 0xf0(%rax), %eax
movl %eax, -0x60(%rsp)
movq -0x58(%rsp), %rax
movq %rax, -0x68(%rsp)
movl $0x0, -0x6c(%rsp)
movl -0x6c(%rsp), %eax
cmpl -0x4c(%rsp), %eax
jge 0x9c25
movq -0x48(%rsp), %rax
movslq -0x6c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movq -0x68(%rsp), %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, -0x30(%rsp)
vmovdqa %xmm0, -0x40(%rsp)
vmovdqa -0x30(%rsp), %xmm0
vpxor -0x40(%rsp), %xmm0, %xmm0
movq -0x48(%rsp), %rax
movslq -0x6c(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl -0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rsp)
jmp 0x9bc3
movl $0x1, -0x5c(%rsp)
movl -0x5c(%rsp), %eax
cmpl -0x60(%rsp), %eax
jae 0x9cc7
movl $0x0, -0x70(%rsp)
movl -0x70(%rsp), %eax
cmpl -0x4c(%rsp), %eax
jge 0x9cb5
movq -0x48(%rsp), %rax
movslq -0x70(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movq -0x68(%rsp), %rax
movl -0x5c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, -0x10(%rsp)
vmovdqa %xmm0, -0x20(%rsp)
vmovdqa -0x10(%rsp), %xmm0
vmovdqa -0x20(%rsp), %xmm1
vaesenc %xmm1, %xmm0, %xmm0
movq -0x48(%rsp), %rax
movslq -0x70(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl -0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rsp)
jmp 0x9c43
jmp 0x9cb7
movl -0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rsp)
jmp 0x9c2d
movl $0x0, -0x74(%rsp)
movl -0x74(%rsp), %eax
cmpl -0x4c(%rsp), %eax
jge 0x9d3f
movq -0x48(%rsp), %rax
movslq -0x74(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movq -0x68(%rsp), %rax
movl -0x5c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x10(%rsp)
vmovdqa %xmm0, (%rsp)
vmovdqa 0x10(%rsp), %xmm0
vmovdqa (%rsp), %xmm1
vaesenclast %xmm1, %xmm0, %xmm0
movq -0x48(%rsp), %rax
movslq -0x74(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl -0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rsp)
jmp 0x9ccf
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x34(%rsp), %eax
shrq $0x4, %rax
movl %eax, 0x24(%rsp)
movl 0x34(%rsp), %eax
andq $0xf, %rax
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rsi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %rcx
callq 0x9aa0
cmpl $0x0, 0x20(%rsp)
je 0x9ddd
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %eax
movl %eax, %ecx
leaq 0x10(%rsp), %rsi
callq 0x98f0
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %eax
shlq $0x4, %rax
addq %rax, %rdi
movl 0x20(%rsp), %eax
movl %eax, %edx
leaq 0x10(%rsp), %rsi
callq 0x3200
addq $0x48, %rsp
retq
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x18, %rdi
leaq 0xcd1(%rip), %rsi       # 0x4b00
callq 0x21c0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
leaq 0xcc1(%rip), %rsi       # 0x4b04
callq 0x21c0
movq -0x10(%rbp), %rax
movl $0x40, 0x58(%rax)
movl $0x32, 0x14c(%rax)
movl $0x2, 0x60(%rax)
movl $0x6, 0x70(%rax)
movl $0x7, 0x80(%rax)
movl $0x1, 0x90(%rax)
movl $0x3840, 0xa0(%rax)     # imm = 0x3840
movl $0x3, 0x120(%rax)
movl $0x2710, 0x130(%rax)    # imm = 0x2710
movl $0x271b, 0x140(%rax)    # imm = 0x271B
movl $0x1130, 0x150(%rax)    # imm = 0x1130
movl $0x3, 0x124(%rax)
movl $0x7d0, 0x134(%rax)     # imm = 0x7D0
movl $0x7ef, 0x144(%rax)     # imm = 0x7EF
movl $0x384, 0x154(%rax)     # imm = 0x384
movl $0x3, 0x128(%rax)
movl $0x1f40, 0x138(%rax)    # imm = 0x1F40
movl $0x1fa5, 0x148(%rax)    # imm = 0x1FA5
movl $0x190, 0x158(%rax)     # imm = 0x190
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x260e
movq 0x69e5(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
leaq 0x3a23(%rip), %rsi      # 0x6020
movb $0x0, %al
callq 0x2360
movl $0x1, %edi
callq 0x2300
leaq 0x6c43(%rip), %rdi      # 0x9258
callq 0x3e60
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x23a0
movl %eax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x23a0
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movl %eax, %edi
callq 0x2740
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23a0
movl -0x58(%rbp), %esi
movl -0x54(%rbp), %edx
movq -0x50(%rbp), %rcx
movl %eax, %r8d
leaq -0x30(%rbp), %rdi
callq 0x35f0
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x20b0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x26b0
movq 0x6943(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
leaq 0x39b5(%rip), %rsi      # 0x6054
movb $0x0, %al
callq 0x2360
movl $0x1, %edi
callq 0x2300
leaq -0x44(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2130
movw $0x2, -0x44(%rbp)
movl $0x7dbc, %edi           # imm = 0x7DBC
callq 0x2040
movw %ax, -0x42(%rbp)
xorl %edi, %edi
callq 0x21d0
movl %eax, -0x40(%rbp)
movl -0x34(%rbp), %edi
leaq -0x44(%rbp), %rsi
movl $0x10, %edx
callq 0x2060
cmpl $0x0, %eax
jge 0x2716
movq 0x68dd(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
leaq 0x3966(%rip), %rsi      # 0x606b
movb $0x0, %al
callq 0x2360
movl $0x1, %edi
callq 0x2300
movl -0x34(%rbp), %edi
leaq -0x30(%rbp), %rsi
callq 0x2bc0
movl -0x34(%rbp), %edi
leaq -0x30(%rbp), %rsi
callq 0x2e30
movl -0x34(%rbp), %edi
callq 0x2430
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: gty980218[P]ee450/hospitalC.cpp
// Function: Hospital::Hospital(int, int, Dist_list*, int)
Hospital::Hospital(int capacity,int occupancy,Dist_list *dist_list,int location){
    this->capacity=capacity;
    this->occupancy=occupancy;
    this->dist_list=dist_list;
    this->location=location;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x52e0
leaq 0x104(%rip), %rax       # 0x8f00
movq %rax, -0x70(%rbp)
leaq 0x469(%rip), %rax       # 0x9270
movq %rax, -0x60(%rbp)
leaq 0x5ee(%rip), %rax       # 0x9400
movq %rax, -0x50(%rbp)
leaq 0x613(%rip), %rax       # 0x9430
movq %rax, -0x40(%rbp)
leaq 0x978(%rip), %rax       # 0x97a0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x5240
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movl $0x0, -0x7c(%rbp)
movq -0x78(%rbp), %rax
movslq -0x7c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5090
cmpl $0x0, %eax
je 0x8e6b
movl -0x7c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x7c(%rbp)
jmp 0x8e4a
movq -0x88(%rbp), %rcx
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
movq -0x70(%rbp,%rdx), %rax
movq %rax, -0x98(%rbp)
movq -0x68(%rbp,%rdx), %rdx
addq %rdx, %rcx
movq %rcx, -0x90(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x8ec1
movq -0x98(%rbp), %rcx
movq -0x90(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0xa0(%rbp)
jmp 0x8ecf
movq -0x98(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq -0x78(%rbp), %rsi
movslq -0x7c(%rbp), %rcx
addq %rcx, %rsi
callq *%rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x5610
movq -0x48(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movq %rdi, -0x68(%rbp)
callq 0x5770
movq -0x48(%rbp), %rdi
movl $0x0, 0x228(%rdi)
addq $0x230, %rdi            # imm = 0x230
movq %rdi, -0x60(%rbp)
callq 0x6490
movq -0x48(%rbp), %rdi
addq $0x260, %rdi            # imm = 0x260
movq %rdi, -0x58(%rbp)
callq 0x9810
movq -0x48(%rbp), %rdi
addq $0x290, %rdi            # imm = 0x290
movq %rdi, -0x50(%rbp)
callq 0x5770
movq -0x48(%rbp), %rax
movq $0x0, 0x2b0(%rax)
addq $0x2b8, %rax            # imm = 0x2B8
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x58f0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x63e0
jmp 0xb236
leaq -0x12(%rbp), %rdi
callq 0x55c0
movq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x5360
jmp 0xb253
movq -0x70(%rbp), %rdi
callq 0xb2d0
jmp 0xb25e
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x55c0
jmp 0xb290
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5a08
movq -0x50(%rbp), %rdi
callq 0x5a08
movq -0x58(%rbp), %rdi
callq 0x9a40
movq -0x60(%rbp), %rdi
callq 0x67b0
movq -0x68(%rbp), %rdi
callq 0x5a08
movq -0x48(%rbp), %rdi
callq 0x5180
movq -0x20(%rbp), %rdi
callq 0x58e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x208, %rsi            # imm = 0x208
callq 0x50f0
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x56a0
testb $0x1, %al
jne 0xb6bf
jmp 0xb7e1
movq -0x20(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
xorl %eax, %eax
movl %eax, %esi
movl $0x9, %edx
leaq 0x17a2f(%rip), %rcx     # 0x23109
callq 0x5710
cmpl $0x0, %eax
jne 0xb716
movq -0x20(%rbp), %rsi
movl $0x0, 0x228(%rsi)
movq %rsi, %rdi
addq $0x228, %rdi            # imm = 0x228
addq $0x208, %rsi            # imm = 0x208
callq 0x121d0
movq -0x20(%rbp), %rdi
callq 0xb840
jmp 0xb7dc
movq -0x20(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
leaq 0x179e1(%rip), %rcx     # 0x23112
callq 0x5710
cmpl $0x0, %eax
je 0xb760
movq -0x20(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
leaq 0x17fb6(%rip), %rcx     # 0x2370c
callq 0x5710
cmpl $0x0, %eax
jne 0xb765
jmp 0xb694
movl $0x10, %edi
callq 0x5290
movq -0x20(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x208, %rdi            # imm = 0x208
callq 0x5240
movq %rax, %rsi
leaq 0x17987(%rip), %rdi     # 0x23114
leaq 0x1798e(%rip), %rdx     # 0x23122
callq 0x12260
movq %rax, -0x28(%rbp)
jmp 0xb79f
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x5830
jmp 0xb7ae
movq -0x30(%rbp), %rdi
movq 0x25837(%rip), %rsi     # 0x30ff0
movq 0x25808(%rip), %rdx     # 0x30fc8
callq 0x58a0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x53f0
jmp 0xb7e7
jmp 0xb694
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x58e0
// File: 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
subq $0x170, %rsp            # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x138(%rbp)
addq $0x260, %rdi            # imm = 0x260
movq -0x18(%rbp), %rsi
callq 0xcbf0
movq -0x138(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x260, %rdi            # imm = 0x260
callq 0xc990
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xcc20
testb $0x1, %al
jne 0xc493
jmp 0xc532
movq -0x138(%rbp), %rax
addq $0x260, %rax            # imm = 0x260
movq %rax, -0x158(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x110(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0xcc90
movq -0x158(%rbp), %rdi
movq -0x150(%rbp), %rsi
callq 0xcc50
movb %dl, -0x141(%rbp)
movq %rax, -0x140(%rbp)
jmp 0xc4e4
movb -0x141(%rbp), %al
movq -0x140(%rbp), %rcx
movq %rcx, -0x130(%rbp)
movb %al, -0x128(%rbp)
leaq -0x110(%rbp), %rdi
callq 0xccf0
jmp 0xc5ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x110(%rbp), %rdi
callq 0xccf0
jmp 0xc5c3
movl $0x10, %edi
callq 0x5290
movq %rax, -0x168(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5240
movq %rax, %rsi
leaq 0x16c93(%rip), %rdi     # 0x231e9
leaq 0x16c9e(%rip), %rdx     # 0x231fb
callq 0x12260
movq %rax, -0x160(%rbp)
jmp 0xc56b
movq -0x160(%rbp), %rsi
movq -0x168(%rbp), %rdi
callq 0x5830
jmp 0xc580
movq -0x168(%rbp), %rdi
movq 0x24a62(%rip), %rsi     # 0x30ff0
movq 0x24a33(%rip), %rdx     # 0x30fc8
callq 0x58a0
movq -0x168(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
callq 0x53f0
jmp 0xc5c3
addq $0x170, %rsp            # imm = 0x170
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0x58e0
nop
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d70
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x97d0
movq -0xa0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
addq $0x260, %rdi            # imm = 0x260
callq 0xc960
movq -0xa0(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x260, %rdi            # imm = 0x260
callq 0xc990
movq -0xa8(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc920
movq -0xa0(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
leaq -0x14(%rbp), %rsi
callq 0xc9c0
movq -0xa0(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x230, %rdi            # imm = 0x230
callq 0x6570
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc9f0
testb $0x1, %al
jne 0xc696
jmp 0xc79d
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xca20
movq -0xb8(%rbp), %rdx
movq -0xb0(%rbp), %rcx
leaq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0xca40
jmp 0xc6cf
leaq -0x51(%rbp), %rdi
callq 0x76e0
movq -0xa0(%rbp), %rax
addq $0x230, %rax            # imm = 0x230
movq %rax, -0xc0(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x14(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xcb00
jmp 0xc702
movq -0xc0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xcac0
movb %dl, -0xc9(%rbp)
movq %rax, -0xc8(%rbp)
jmp 0xc724
movb -0xc9(%rbp), %al
movq -0xc8(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movb %al, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xcb40
leaq -0x50(%rbp), %rdi
callq 0x71f0
jmp 0xc7b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x76e0
jmp 0xc7d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xc792
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xcb40
leaq -0x50(%rbp), %rdi
callq 0x71f0
jmp 0xc7d2
leaq -0x30(%rbp), %rdi
callq 0x6610
movq %rax, %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xcb60
movq -0xa0(%rbp), %rdi
addq $0x260, %rdi            # imm = 0x260
callq 0xcbd0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x58e0
nopl (%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x90(%rbp), %rdi
leaq 0x2135d(%rip), %rsi     # 0x30d00
movl $0x70, %edx
callq 0x5450
movq -0x20(%rbp), %rdi
callq 0x5240
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x9c(%rbp)
movq -0x98(%rbp), %rax
movslq -0x9c(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x5090
cmpl $0x0, %eax
je 0xf9fe
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0xf9d1
movq -0xa8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
movq -0x90(%rbp,%rdx), %rax
movq %rax, -0xb8(%rbp)
movq -0x88(%rbp,%rdx), %rdx
addq %rdx, %rcx
movq %rcx, -0xb0(%rbp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0xfa5a
movq -0xb8(%rbp), %rcx
movq -0xb0(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, -0xc0(%rbp)
jmp 0xfa68
movq -0xb8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xc0(%rbp), %rax
movq -0x98(%rbp), %rsi
movslq -0x9c(%rbp), %rcx
addq %rcx, %rsi
callq *%rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: llefranc[P]42_webserv/srcs/parser/LocationObj.cpp
// Function: Location::setMethods(char const*)
void Location::setMethods(char const *n) 
{
	_allow_methd.clear();
	setStringArray(n, _allow_methd);
	const char *method_checking[] = { "POST", "GET", "HEAD", "DELETE"};
	for (size_t i = 0; i < _allow_methd.size(); i++){
		for (size_t j = 0; j < 4; j++){
			if (!strcmp(method_checking[j], _allow_methd[i].c_str()))
				break;
			if (j == 4)
				throw std::runtime_error("Error : method " + std::string(_allow_methd[i]) + " is not accepted\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
addq $0x68, %rdi
callq 0x10af0
movq -0xb8(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x68, %rsi
callq 0x12490
movq 0x2128e(%rip), %rax     # 0x30d70
movq %rax, -0x30(%rbp)
movq 0x2128b(%rip), %rax     # 0x30d78
movq %rax, -0x28(%rbp)
movq 0x21288(%rip), %rax     # 0x30d80
movq %rax, -0x20(%rbp)
movq 0x21285(%rip), %rax     # 0x30d88
movq %rax, -0x18(%rbp)
movq $0x0, -0x38(%rbp)
movq -0xb8(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0xc0(%rbp)
addq $0x68, %rdi
callq 0xaa60
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jae 0xfcef
movq $0x0, -0x40(%rbp)
cmpq $0x4, -0x40(%rbp)
jae 0xfcdc
movq -0xb8(%rbp), %rdi
movq -0x40(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rax
movq %rax, -0xc8(%rbp)
addq $0x68, %rdi
movq -0x38(%rbp), %rsi
callq 0x10b10
movq %rax, %rdi
callq 0x5240
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0x5780
cmpl $0x0, %eax
jne 0xfb95
jmp 0xfcdc
cmpq $0x4, -0x40(%rbp)
jne 0xfcc9
movb $0x1, -0xad(%rbp)
movl $0x10, %edi
callq 0x5290
movq -0xb8(%rbp), %rdi
movq %rax, -0xd0(%rbp)
addq $0x68, %rdi
movq -0x38(%rbp), %rsi
callq 0x10b10
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
callq 0x5250
jmp 0xfbdd
leaq 0x136b0(%rip), %rsi     # 0x23294
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
callq 0x6700
jmp 0xfbf6
leaq 0x136a7(%rip), %rdx     # 0x232a4
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x66b0
jmp 0xfc0c
movq -0xd0(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x5830
jmp 0xfc1e
movq -0xd0(%rbp), %rdi
movb $0x0, -0xad(%rbp)
movq 0x213bd(%rip), %rsi     # 0x30ff0
movq 0x2138e(%rip), %rdx     # 0x30fc8
callq 0x58a0
jmp 0xfd04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xfcb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xfca4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xfc9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5a08
leaq -0x80(%rbp), %rdi
callq 0x5a08
leaq -0xa0(%rbp), %rdi
callq 0x5a08
testb $0x1, -0xad(%rbp)
jne 0xfcbb
jmp 0xfcc7
movq -0xd0(%rbp), %rdi
callq 0x53f0
jmp 0xfcf8
jmp 0xfccb
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0xfb45
jmp 0xfcde
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0xfb0f
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x58e0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x58f0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x63e0
jmp 0xfd92
leaq -0x31(%rbp), %rdi
callq 0x55c0
movq -0x10(%rbp), %rdi
callq 0x12310
movq %rax, -0xd0(%rbp)
jmp 0xfdad
movq -0xd0(%rbp), %rax
cmpq $0x1, %rax
je 0xfef0
movb $0x1, -0xa9(%rbp)
movl $0x10, %edi
callq 0x5290
movq %rax, -0xd8(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5250
jmp 0xfde8
leaq 0x13292(%rip), %rsi     # 0x23081
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x6700
jmp 0xfe04
leaq 0x13461(%rip), %rdx     # 0x2326c
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x66b0
jmp 0xfe1d
movq -0xd8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5830
jmp 0xfe2f
movq -0xd8(%rbp), %rdi
movb $0x0, -0xa9(%rbp)
movq 0x211ac(%rip), %rsi     # 0x30ff0
movq 0x2117d(%rip), %rdx     # 0x30fc8
callq 0x58a0
jmp 0xff3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x55c0
jmp 0xff36
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xff2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xfed7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xfecb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xfebf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5a08
leaq -0x88(%rbp), %rdi
callq 0x5a08
leaq -0xa8(%rbp), %rdi
callq 0x5a08
testb $0x1, -0xa9(%rbp)
jne 0xfee2
jmp 0xfeee
movq -0xd8(%rbp), %rdi
callq 0x53f0
jmp 0xff2d
leaq -0x30(%rbp), %rdi
callq 0x123e0
movq %rax, -0xe0(%rbp)
jmp 0xff02
movq -0xe0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
addq $0x28, %rdi
callq 0x5060
jmp 0xff1b
leaq -0x30(%rbp), %rdi
callq 0x5a08
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x5a08
movq -0x40(%rbp), %rdi
callq 0x58e0
nop
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x58f0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x63e0
jmp 0xff92
leaq -0x31(%rbp), %rdi
callq 0x55c0
movq -0x10(%rbp), %rdi
callq 0x12310
movq %rax, -0xd0(%rbp)
jmp 0xffad
movq -0xd0(%rbp), %rax
cmpq $0x1, %rax
je 0x100f0
movb $0x1, -0xa9(%rbp)
movl $0x10, %edi
callq 0x5290
movq %rax, -0xd8(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5250
jmp 0xffe8
leaq 0x13092(%rip), %rsi     # 0x23081
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rdx
callq 0x6700
jmp 0x10004
leaq 0x13246(%rip), %rdx     # 0x23251
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x66b0
jmp 0x1001d
movq -0xd8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x5830
jmp 0x1002f
movq -0xd8(%rbp), %rdi
movb $0x0, -0xa9(%rbp)
movq 0x20fac(%rip), %rsi     # 0x30ff0
movq 0x20f7d(%rip), %rdx     # 0x30fc8
callq 0x58a0
jmp 0x1013f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x55c0
jmp 0x10136
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1012d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x100d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x100cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x100bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5a08
leaq -0x88(%rbp), %rdi
callq 0x5a08
leaq -0xa8(%rbp), %rdi
callq 0x5a08
testb $0x1, -0xa9(%rbp)
jne 0x100e2
jmp 0x100ee
movq -0xd8(%rbp), %rdi
callq 0x53f0
jmp 0x1012d
leaq -0x30(%rbp), %rdi
callq 0x123e0
movq %rax, -0xe0(%rbp)
jmp 0x10102
movq -0xe0(%rbp), %rsi
movq -0xc8(%rbp), %rdi
addq $0x8, %rdi
callq 0x5060
jmp 0x1011b
leaq -0x30(%rbp), %rdi
callq 0x5a08
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x5a08
movq -0x40(%rbp), %rdi
callq 0x58e0
nop