LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::serialize[abi:cxx11]()
std::string GameData::serialize() {
  //TODO send currently guessed characters too
  
  char data[1024];
  sprintf(data, "%d %s %d %d|", word_length, current_string, n_players, current_turn);
  std::string str(data);
  // std::cout<<"Serialized\t"<<str<<std::endl;
  return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x440(%rbp)
movq %rdi, %rax
movq %rax, -0x448(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movl (%rax), %edx
movl 0x18(%rax), %r8d
movl 0x1c(%rax), %r9d
leaq 0x2559(%rip), %rsi      # 0x80c9
xorl %eax, %eax
leaq -0x410(%rbp), %rdi
movq %rdi, -0x438(%rbp)
callq 0x3090
movb $0x0, -0x411(%rbp)
leaq -0x412(%rbp), %rdi
movq %rdi, -0x430(%rbp)
callq 0x3470
movq -0x440(%rbp), %rdi
movq -0x438(%rbp), %rsi
movq -0x430(%rbp), %rdx
callq 0x5f70
jmp 0x5bbb
leaq -0x412(%rbp), %rdi
callq 0x3330
movb $0x1, -0x411(%rbp)
testb $0x1, -0x411(%rbp)
jne 0x5c05
jmp 0x5bf9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x420(%rbp)
movl %eax, -0x424(%rbp)
leaq -0x412(%rbp), %rdi
callq 0x3330
jmp 0x5c15
movq -0x440(%rbp), %rdi
callq 0x31d0
movq -0x448(%rbp), %rax
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
movq -0x420(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
// File: milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::deserialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void GameData::deserialize(std::string req){
    char data[1024]={0};
    req.copy(data, req.size());
    sscanf(data, "%d %s %d %d|", &word_length, current_string, &n_players, &current_turn);
    // std::cout<<"Deserializing\t"<<req<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rsi, -0x428(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x31a0
movq -0x428(%rbp), %rdi
leaq -0x410(%rbp), %rax
movq %rax, -0x420(%rbp)
callq 0x31f0
movq -0x428(%rbp), %rdi
movq -0x420(%rbp), %rsi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3060
movq -0x418(%rbp), %rdx
leaq -0x410(%rbp), %rdi
movq %rdx, %rcx
addq $0x4, %rcx
movq %rdx, %r8
addq $0x18, %r8
movq %rdx, %r9
addq $0x1c, %r9
leaq 0x2403(%rip), %rsi      # 0x80c9
movb $0x0, %al
callq 0x32c0
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: milzar[P]Multiplayer-Hangman-Game/src/hangman/GameData.cpp
// Function: GameData::getRandomWord[abi:cxx11]()
std::string GameData::getRandomWord() {
    std::ifstream file("words.txt");
    std::string word;

    std::random_device rd;
    unsigned long rand_no = std::uniform_int_distribution<unsigned long>()(rd) % 367516;

    while(--rand_no) getline(file, word);
    getline(file, word);

    // Remove trailing newline char
    word.erase(word.length() - 1);
    std::cout<<"Root Word: "<<word<<std::endl;
    return word;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x15f0, %rsp           # imm = 0x15F0
movq %rdi, -0x15d0(%rbp)
movq %rdi, %rax
movq %rax, -0x15d8(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x23cf(%rip), %rsi      # 0x80d6
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x3490
movq -0x15d0(%rbp), %rdi
movb $0x0, -0x211(%rbp)
callq 0x33c0
leaq -0x15a0(%rbp), %rdi
callq 0x6020
jmp 0x5d39
leaq -0x15c8(%rbp), %rdi
callq 0x60c0
jmp 0x5d47
leaq -0x15c8(%rbp), %rdi
leaq -0x15a0(%rbp), %rsi
callq 0x60f0
movq %rax, -0x15e0(%rbp)
jmp 0x5d63
movq -0x15e0(%rbp), %rax
movl $0x59b9c, %ecx          # imm = 0x59B9C
xorl %edx, %edx
divq %rcx
movq %rdx, -0x15b8(%rbp)
movq -0x15b8(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x15b8(%rbp)
cmpq $0x0, %rax
je 0x5de4
movq -0x15d0(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x30a0
jmp 0x5da8
jmp 0x5d7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x15a8(%rbp)
movl %eax, -0x15ac(%rbp)
jmp 0x5eb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x15a8(%rbp)
movl %eax, -0x15ac(%rbp)
leaq -0x15a0(%rbp), %rdi
callq 0x6120
jmp 0x5eb1
movq -0x15d0(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x30a0
jmp 0x5df9
movq -0x15d0(%rbp), %rdi
callq 0x33f0
movq -0x15d0(%rbp), %rdi
movq %rax, %rsi
decq %rsi
movq $-0x1, %rdx
callq 0x30b0
jmp 0x5e20
movq 0x51b1(%rip), %rdi      # 0xafd8
leaq 0x22b2(%rip), %rsi      # 0x80e0
callq 0x32d0
movq %rax, -0x15e8(%rbp)
jmp 0x5e3c
movq -0x15d0(%rbp), %rsi
movq -0x15e8(%rbp), %rdi
callq 0x3280
movq %rax, -0x15f0(%rbp)
jmp 0x5e58
movq -0x15f0(%rbp), %rdi
movq 0x5162(%rip), %rsi      # 0xafc8
callq 0x3310
jmp 0x5e6d
movb $0x1, -0x211(%rbp)
leaq -0x15a0(%rbp), %rdi
callq 0x6120
testb $0x1, -0x211(%rbp)
jne 0x5e95
movq -0x15d0(%rbp), %rdi
callq 0x31d0
leaq -0x210(%rbp), %rdi
callq 0x30e0
movq -0x15d8(%rbp), %rax
addq $0x15f0, %rsp           # imm = 0x15F0
popq %rbp
retq
movq -0x15d0(%rbp), %rdi
callq 0x31d0
leaq -0x210(%rbp), %rdi
callq 0x30e0
movq -0x15a8(%rbp), %rdi
callq 0x3460
nopw %cs:(%rax,%rax)
nop
// File: milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Client::init(char const*, int)
void  Client::init(const char* serverIp , int port ){
      int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
      sockaddr_in socket_address;
      socket_address.sin_family = AF_INET;
      socket_address.sin_port = htons(port);
      socket_address.sin_addr.s_addr = inet_addr(serverIp);

      connect(socket_fd, (struct sockaddr *)&socket_address, sizeof(socket_address) );
      mastersocket = socket_fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30d0
movl %eax, -0x18(%rbp)
movw $0x2, -0x28(%rbp)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x3040
movw %ax, -0x26(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32f0
movl %eax, -0x24(%rbp)
movl -0x18(%rbp), %edi
leaq -0x28(%rbp), %rsi
movl $0x10, %edx
callq 0x3250
movq -0x30(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Client::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Client::init(std::string serverIp , int port ){
      char *IP;
      IP = (char*) malloc(serverIp.size());
      serverIp.copy(IP,serverIp.size());

      int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
      sockaddr_in socket_address;
      socket_address.sin_family = AF_INET;
      socket_address.sin_port = htons(port);
      socket_address.sin_addr.s_addr = inet_addr(IP);

      connect(socket_fd, (struct sockaddr *)&socket_address, sizeof(socket_address) );
      mastersocket = socket_fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x31f0
movq %rax, %rdi
callq 0x33a0
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x31f0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3060
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30d0
movl %eax, -0x24(%rbp)
movw $0x2, -0x34(%rbp)
movl -0x14(%rbp), %eax
movzwl %ax, %edi
callq 0x3040
movw %ax, -0x32(%rbp)
movq -0x20(%rbp), %rdi
callq 0x32f0
movl %eax, -0x30(%rbp)
movl -0x24(%rbp), %edi
leaq -0x34(%rbp), %rsi
movl $0x10, %edx
callq 0x3250
movq -0x40(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, (%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Client::forward(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Client::forward(std::string str){
    char data[1024]={0};
    str.copy(data, str.size());
    send(mastersocket, data,strlen(data),0);
    return str.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rsi, -0x418(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x430(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x31a0
movq -0x418(%rbp), %rdi
leaq -0x410(%rbp), %rax
movq %rax, -0x438(%rbp)
callq 0x31f0
movq -0x438(%rbp), %rsi
movq -0x418(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3060
movq -0x430(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x424(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3160
movl -0x424(%rbp), %edi
movq -0x420(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3180
movq -0x418(%rbp), %rdi
callq 0x31f0
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Client::forward(char const*)
int Client::forward(const char *str){
  char data[1024]={0};
  strcpy(data,str);
  send(mastersocket, data,strlen(data),0);
  return strlen(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x428(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x31a0
leaq -0x410(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3290
movq -0x428(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x41c(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x418(%rbp)
leaq -0x410(%rbp), %rdi
callq 0x3160
movl -0x41c(%rbp), %edi
movq -0x418(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3180
movq -0x10(%rbp), %rdi
callq 0x3160
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Server::init(int, int)
void Server::init(int port, int maxClients = 20){
      //CREATE SOCKET
      //So it is just an integer number that uniquely represents an opened file/socket in operating system
      int socket_fd = socket(AF_INET, SOCK_STREAM, 0); // creating socket
      //AF_INET (IPv4 protocol) , AF_INET6 (IPv6 protocol)
      //SOCK_STREAM: TCP(reliable, connection oriented)
      //SOCK_DGRAM: UDP(unreliable, connectionless)

      //Bind ip and port to socket
      sockaddr_in socket_address;
      socket_address.sin_family = AF_INET;
      socket_address.sin_addr.s_addr = htonl(INADDR_ANY);
      socket_address.sin_port = htons(port);         // this is the port number of running server
      bind(socket_fd, (sockaddr*)&socket_address , sizeof(socket_address));

      //LISTEN Socket
      listen(socket_fd , maxClients);
      //20 - max no of connections
      mastersocket = socket_fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x30d0
movl %eax, -0x14(%rbp)
movw $0x2, -0x24(%rbp)
xorl %edi, %edi
callq 0x3220
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movzwl %ax, %edi
callq 0x3040
movw %ax, -0x22(%rbp)
movl -0x14(%rbp), %edi
leaq -0x24(%rbp), %rsi
movl $0x10, %edx
callq 0x3070
movl -0x14(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x3360
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Server::forward(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Server::forward(int client, std::string str){
      char data[1024]={0};
      str.copy(data, str.size());
      send(client, data,strlen(data),0);
      return str.size();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdx, -0x428(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x31a0
movq -0x428(%rbp), %rdi
leaq -0x420(%rbp), %rax
movq %rax, -0x440(%rbp)
callq 0x31f0
movq -0x440(%rbp), %rsi
movq -0x428(%rbp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3060
movl -0xc(%rbp), %eax
movl %eax, -0x434(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x430(%rbp)
leaq -0x420(%rbp), %rdi
callq 0x3160
movl -0x434(%rbp), %edi
movq -0x430(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3180
movq -0x428(%rbp), %rdi
callq 0x31f0
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: Server::forward(int, char const*)
int Server::forward(int client, const char *str){
    char data[1024]={0};
    strcpy(data,str);
    send(client, data,strlen(data),0);
    return strlen(str);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x420(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x31a0
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3290
movl -0xc(%rbp), %eax
movl %eax, -0x42c(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x428(%rbp)
leaq -0x420(%rbp), %rdi
callq 0x3160
movl -0x42c(%rbp), %edi
movq -0x428(%rbp), %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x3180
movq -0x18(%rbp), %rdi
callq 0x3160
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: updateMaxFD(std::vector<Player, std::allocator<Player>>, int)
int updateMaxFD(std::vector<Player> clients, int maxfd){
    int x =maxfd;
    for(size_t i=0;i<clients.size();i++)
      x =std::max(x,clients[i].socket_id);
    return x;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x4640
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x6ede
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x46b0
movq %rax, %rsi
addq $0x20, %rsi
leaq -0x10(%rbp), %rdi
callq 0x7030
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6e91
movl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: milzar[P]Multiplayer-Hangman-Game/src/network/wrapper.cpp
// Function: initFdset(std::vector<Player, std::allocator<Player>>, int)
fd_set initFdset(std::vector<Player> clients, int master){
    fd_set temp;
    FD_ZERO(&temp);
    FD_SET(master,&temp);
    for(size_t i=0;i<clients.size();i++){
        if(clients[i].socket_id)
            FD_SET(clients[i].socket_id,&temp);
    }
    return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpq $0x10, %rax
jae 0x6f3d
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x6f1a
jmp 0x6f3f
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x40(%rbp), %rdx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
movq $0x0, -0x20(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x4640
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x701a
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x46b0
cmpl $0x0, 0x20(%rax)
je 0x7007
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x46b0
movq -0x38(%rbp), %rdi
movl 0x20(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x50(%rbp)
movq -0x20(%rbp), %rsi
callq 0x46b0
movl 0x20(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0x50(%rbp), %rdx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x7009
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6f82
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: tdv[P]boss/boss/examples/objects_as_params/main.cpp
// Function: MyNs::Impl::SimpleObject::SetObject(MyNs::IFaces::IInputObject*)
virtual Boss::RetCode BOSS_CALL SetObject(IFaces::IInputObject *obj)
      {
        if (!obj)
          return Boss::Status::InvalidArgument;
        Obj = obj;
        return Boss::Status::Ok;
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1813a
movl $0x5, 0x24(%rsp)
jmp 0x18155
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x18, %rdi
callq 0x18b10
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: tdv[P]boss/boss/examples/objects_as_params/main.cpp
// Function: MyNs::Impl::SimpleObject::CreateNewObject(MyNs::IFaces::IOutputObject**)
virtual Boss::RetCode BOSS_CALL CreateNewObject(IFaces::IOutputObject **obj)
      {
        try
        {
          auto NewInst = Boss::Base<OutputObject>::Create();
          return NewInst.QueryInterface(obj);
        }
        catch (...)
        {
        }
        return Boss::Status::Fail;
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x18c10
jmp 0x181da
movq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x18d00
movl %eax, 0x8(%rsp)
jmp 0x181ef
movl 0x8(%rsp), %eax
movl %eax, 0x34(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x18d50
jmp 0x18242
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x1822b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x18d50
movq 0x10(%rsp), %rdi
callq 0x1ab50
callq 0x1abc0
movl $0x2, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: printTable()
void printTable()
{
	cout << "Identifier\tFD\tHop Count\tIn Use?" << endl;
	cout << "----------------------------------------------------" << endl;
	for (int i = 0; i < table.size(); i++)
	{
		cout << table[i].identifier << "\t\t" << table[i].fd << "\t" << table[i].hop_count << "\t\t" << (table[i].in_use ? "Yes" : "No") << endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0xcc99(%rip), %rdi      # 0x10fc8
leaq 0x7cf6(%rip), %rsi      # 0xc02c
callq 0x3310
movq %rax, %rdi
movq 0xcc73(%rip), %rsi      # 0x10fb8
callq 0x3350
movq 0xcc77(%rip), %rdi      # 0x10fc8
leaq 0x7cf4(%rip), %rsi      # 0xc04c
callq 0x3310
movq %rax, %rdi
movq 0xcc51(%rip), %rsi      # 0x10fb8
callq 0x3350
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xcf66(%rip), %rdi      # 0x112e8
callq 0x6e90
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0x4474
movslq -0x4(%rbp), %rsi
leaq 0xcf46(%rip), %rdi      # 0x112e8
callq 0x6eb0
movl (%rax), %esi
movq 0xcc18(%rip), %rdi      # 0x10fc8
callq 0x34e0
movq %rax, %rdi
leaq 0x7cc2(%rip), %rsi      # 0xc081
callq 0x3310
movq %rax, -0x28(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0xcf15(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq -0x28(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x34e0
movq %rax, %rdi
leaq 0x7c94(%rip), %rsi      # 0xc082
callq 0x3310
movq %rax, -0x20(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0xcee6(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq -0x20(%rbp), %rdi
movl 0xc(%rax), %esi
callq 0x34e0
movq %rax, %rdi
leaq 0x7c64(%rip), %rsi      # 0xc081
callq 0x3310
movq %rax, -0x18(%rbp)
movslq -0x4(%rbp), %rsi
leaq 0xceb7(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq -0x18(%rbp), %rdi
movb 0x30(%rax), %cl
leaq 0x7c44(%rip), %rsi      # 0xc088
leaq 0x7c39(%rip), %rax      # 0xc084
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x3310
movq %rax, %rdi
movq 0xcb57(%rip), %rsi      # 0x10fb8
callq 0x3350
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x4373
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findRow(int)
int findRow(int id)
{
	for (int i = 0; i < table.size(); i++)
	{
		if (id == table[i].identifier)
		{
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xce47(%rip), %rdi      # 0x112e8
callq 0x6e90
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x44e7
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0xce25(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jne 0x44da
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x44ee
jmp 0x44dc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4492
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findRowByID_MinHopCount(int)
int findRowByID_MinHopCount(int id)
{
	int min_hop_count = 10000;
	int index = -1;
	for (int i = 0; i < table.size(); i++)
	{
		if (id == table[i].identifier)
		{
			if (table[i].hop_count < min_hop_count)
			{
				index = i;
				min_hop_count = table[i].hop_count;
			}
		}
	}
	return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x2710, -0x8(%rbp)     # imm = 0x2710
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xcdb9(%rip), %rdi      # 0x112e8
callq 0x6e90
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x45a6
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movslq -0x10(%rbp), %rsi
leaq 0xcd97(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
jne 0x4596
movslq -0x10(%rbp), %rsi
leaq 0xcd7d(%rip), %rdi      # 0x112e8
callq 0x6eb0
movl 0xc(%rax), %eax
cmpl -0x8(%rbp), %eax
jge 0x4594
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movslq -0x10(%rbp), %rsi
leaq 0xcd5f(%rip), %rdi      # 0x112e8
callq 0x6eb0
movl 0xc(%rax), %eax
movl %eax, -0x8(%rbp)
jmp 0x4596
jmp 0x4598
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4520
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findRowByFD(int)
int findRowByFD(int fd)
{
	for (int i = 0; i < table.size(); i++)
	{
		if (fd == table[i].fd)
		{
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xcd17(%rip), %rdi      # 0x112e8
callq 0x6e90
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x4618
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movslq -0xc(%rbp), %rsi
leaq 0xccf5(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jne 0x460b
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x461f
jmp 0x460d
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x45c2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findRowByFDAndID(int, int)
int findRowByFDAndID(int fd, int id)
{
	for (int i = 0; i < table.size(); i++)
	{
		if (fd == table[i].fd and id == table[i].identifier)
		{
			return i;
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xcc94(%rip), %rdi      # 0x112e8
callq 0x6e90
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x46bb
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movslq -0x10(%rbp), %rsi
leaq 0xcc72(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl 0x4(%rcx), %eax
jne 0x46ae
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movslq -0x10(%rbp), %rsi
leaq 0xcc51(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl (%rcx), %eax
jne 0x46ae
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x46c2
jmp 0x46b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4645
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findAllRowsByType(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> findAllRowsByType(string type)
{
	vector<int> returnTo;
	for (int i = 0; i < table.size(); i++)
	{
		if (table[i].type == type)
		{
			returnTo.push_back(i);
		}
	}
	return returnTo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x7ab0
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0xcbda(%rip), %rdi      # 0x112e8
callq 0x6e90
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x477a
movslq -0x18(%rbp), %rsi
leaq 0xcbbe(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rdi
callq 0x6e00
testb $0x1, %al
jne 0x4745
jmp 0x476d
movq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7ad0
jmp 0x4754
jmp 0x476d
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7b40
jmp 0x4797
jmp 0x476f
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x46ff
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x478d
movq -0x38(%rbp), %rdi
callq 0x7b40
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34f0
// File: SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: findAllRowsByFD(int)
vector<int> findAllRowsByFD(int fd)
{
	vector<int> returnTo;
	for (int i = 0; i < table.size(); i++)
	{
		if (fd == table[i].fd)
		{
			returnTo.push_back(i);
		}
	}
	return returnTo;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x7ab0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0xcb0f(%rip), %rdi      # 0x112e8
callq 0x6e90
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x4840
movl -0xc(%rbp), %eax
movl %eax, -0x44(%rbp)
movslq -0x14(%rbp), %rsi
leaq 0xcaed(%rip), %rdi      # 0x112e8
callq 0x6eb0
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl 0x4(%rcx), %eax
jne 0x4833
movq -0x38(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x7ad0
jmp 0x481a
jmp 0x4833
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7b40
jmp 0x485d
jmp 0x4835
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x47ca
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x4853
movq -0x38(%rbp), %rdi
callq 0x7b40
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34f0
nopw %cs:(%rax,%rax)
// File: SaadBazaz[P]RIP-Protocol-Simulation/ProxyRouter.cpp
// Function: fds_add(int*, int)
void fds_add(int fds[], int fd) //Add a file descriptor to the fds array
{
	int i = 0;
	for (; i < MAXFD; ++i)
	{
		if (fds[i] == -1)
		{
			fds[i] = fd;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x5f83
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x5f76
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x5f83
jmp 0x5f78
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x5f52
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: CopyBrink(bbrink_t*)
bbrink_t *CopyBrink (bbrink_t *other)
{
	bbrink_t *b;
	hlassume (b = (bbrink_t *)malloc (sizeof (bbrink_t)), assume_NoMemory);
	VectorCopy (other->direction, b->direction);
	VectorCopy (other->start, b->start);
	VectorCopy (other->stop, b->stop);
	b->numnodes = other->numnodes;
	b->nodes = new std::vector< bbrinknode_t >(*other->nodes);
	return b;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x60, %edi
callq 0x43e0
movq %rax, 0x18(%rsp)
testq %rax, %rax
setne %al
movzbl %al, %edi
movl $0x1, %esi
callq 0xbe90
movq 0x20(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movq 0x20(%rsp), %rax
movsd 0x38(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x38(%rax)
movq 0x20(%rsp), %rax
movsd 0x40(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x40(%rax)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x20(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x20(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq 0x20(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movq 0x20(%rsp), %rax
movsd 0x28(%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movq 0x20(%rsp), %rax
movl 0x48(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x48(%rax)
movl $0x18, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rsi
callq 0x19a20
jmp 0x12011
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x18, %esi
callq 0x4300
movq 0x10(%rsp), %rdi
callq 0x4520
nop
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: CreateBrink(double*, double*)
bbrink_t *CreateBrink (vec3_t start, vec3_t stop)
{
	bbrink_t *b;
	hlassume (b = (bbrink_t *)malloc (sizeof (bbrink_t)), assume_NoMemory);

	VectorCopy (start, b->start);
	VectorCopy (stop, b->stop);
	VectorSubtract (stop, start, b->direction);

	b->numnodes = 1;
	b->nodes = new std::vector< bbrinknode_t >;
	bbrinknode_t newnode;
	newnode.isleaf = true;
	newnode.clipnode = NULL;
	b->nodes->push_back (newnode);
	
	// CreateBrink must be followed by BrinkSplitClipnode
	return b;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl $0x60, %edi
callq 0x43e0
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbe90
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x40(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq 0x38(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movq 0x38(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
movq 0x40(%rsp), %rax
subsd (%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movq 0x38(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x40(%rsp), %rax
subsd 0x8(%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x38(%rax)
movq 0x38(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x40(%rsp), %rax
subsd 0x10(%rax), %xmm0
movq 0x30(%rsp), %rax
movsd %xmm0, 0x40(%rax)
movq 0x30(%rsp), %rax
movl $0x1, 0x48(%rax)
movl $0x18, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, (%rsp)
callq 0x19b80
movq (%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x50(%rax)
movb $0x1, 0x8(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
leaq 0x8(%rsp), %rsi
callq 0x19b90
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: PrintBrink(bbrink_t const*)
void PrintBrink (const bbrink_t *b)
{
	Log ("direction %f %f %f start %f %f %f stop %f %f %f\n", b->direction[0], b->direction[1], b->direction[2], b->start[0], b->start[1], b->start[2], b->stop[0], b->stop[1], b->stop[2]);
	Log ("numnodes %d\n", b->numnodes);
	for (int i = 0; i < b->numnodes; i++)
	{
		bbrinknode_t *n = &(*b->nodes)[i];
		if (n->isleaf)
		{
			Log ("leaf[%d] content %d\n", i, n->content);
		}
		else
		{
			Log ("node[%d]-[%d:%d] plane %f %f %f %f\n", i, n->children[0], n->children[1], n->plane->normal[0], n->plane->normal[1], n->plane->normal[2], n->plane->dist);
		}
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq 0x20(%rsp), %rax
movsd 0x38(%rax), %xmm1
movq 0x20(%rsp), %rax
movsd 0x40(%rax), %xmm2
movq 0x20(%rsp), %rax
movsd (%rax), %xmm3
movq 0x20(%rsp), %rax
movsd 0x8(%rax), %xmm4
movq 0x20(%rsp), %rax
movsd 0x10(%rax), %xmm5
movq 0x20(%rsp), %rax
movsd 0x18(%rax), %xmm6
movq 0x20(%rsp), %rax
movsd 0x20(%rax), %xmm7
movq 0x20(%rsp), %rax
movsd 0x28(%rax), %xmm8
leaq 0x2740e(%rip), %rdi     # 0x39678
movsd %xmm8, (%rsp)
movb $0x8, %al
callq 0xb060
movq 0x20(%rsp), %rax
movl 0x48(%rax), %esi
leaq 0x27423(%rip), %rdi     # 0x396a9
movb $0x0, %al
callq 0xb060
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jge 0x12350
movq 0x20(%rsp), %rax
movq 0x50(%rax), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x19c00
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x122e5
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rax
movl 0x18(%rax), %edx
leaq 0x273da(%rip), %rdi     # 0x396b6
movb $0x0, %al
callq 0xb060
jmp 0x1233e
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %edx
movq 0x10(%rsp), %rax
movl 0x14(%rax), %ecx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd (%rax), %xmm0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd 0x8(%rax), %xmm1
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd 0x10(%rax), %xmm2
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movsd 0x30(%rax), %xmm3
leaq 0x27394(%rip), %rdi     # 0x396cb
movb $0x4, %al
callq 0xb060
jmp 0x12340
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x12295
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: BrinkReplaceClipnode(bbrink_t*, bclipnode_s*, bclipnode_s*)
void BrinkReplaceClipnode (bbrink_t *b, bclipnode_t *prev, bclipnode_t *n)
{
	int found;
	int numfound = 0;
	for (int i = 0; i < b->numnodes; i++)
	{
		bbrinknode_t *node = &(*b->nodes)[i];
		if (node->isleaf && node->clipnode == prev)
		{
			found = i;
			numfound++;
		}
	}
	if (numfound == 0)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: couldn't find clipnode");
		hlassume (false, assume_first);
	}
	if (numfound > 1)
	{
		PrintOnce ("BrinkSplitClipnode: internal error: found more than one clipnode");
		hlassume (false, assume_first);
	}
	bbrinknode_t *node = &(*b->nodes)[found];
	node->clipnode = n;
	node->content = n->content;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jge 0x12605
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
movslq 0x14(%rsp), %rsi
callq 0x19c00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0x125f6
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
cmpq 0x28(%rsp), %rax
jne 0x125f6
movl 0x14(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x125f8
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x125a3
cmpl $0x0, 0x18(%rsp)
jne 0x12623
leaq 0x270dc(%rip), %rdi     # 0x396ef
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
cmpl $0x1, 0x18(%rsp)
jle 0x12641
leaq 0x270f9(%rip), %rdi     # 0x3972a
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x19c00
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movl 0x20(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreepoint(int&, bool)
btreepoint_t *AllocTreepoint (int &numobjects, bool infinite)
{
	numobjects++;
	btreepoint_t *tp = (btreepoint_t *)malloc (sizeof (btreepoint_t));
	hlassume (tp != NULL, assume_NoMemory);
	tp->edges = new btreeedge_l ();
	tp->infinite = infinite;
	return tp;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x40, %edi
callq 0x43e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbe90
movl $0x18, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x4180
movq 0x8(%rsp), %rdi
callq 0x19cc0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movb 0x1f(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreeedge(int&, bool)
btreeedge_t *AllocTreeedge (int &numobjects, bool infinite)
{
	numobjects++;
	btreeedge_t *te = (btreeedge_t *)malloc (sizeof (btreeedge_t));
	hlassume (te != NULL, assume_NoMemory);
	te->points[0].p = NULL;
	te->points[0].side = false;
	te->points[1].p = NULL;
	te->points[1].side = true;
	te->faces = new btreeface_l ();
	te->infinite = infinite;
	// should be followed by SetEdgePoints
	return te;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x48, %edi
callq 0x43e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbe90
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x18(%rax)
movl $0x18, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x4180
movq 0x8(%rsp), %rdi
callq 0x19cd0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movb 0x1f(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AttachPointToEdge(btreeedge_s*, btreepoint_s*, bool)
void AttachPointToEdge (btreeedge_t *te, btreepoint_t *tp, bool side)
{
	if (te->points[side].p)
	{
		PrintOnce ("AttachPointToEdge: internal error: point occupied.");
		hlassume (false, assume_first);
	}
	if (te->infinite && !tp->infinite)
	{
		PrintOnce ("AttachPointToEdge: internal error: attaching a finite object to an infinite object.");
		hlassume (false, assume_first);
	}
	te->points[side].p = tp;

	btreeedge_r er;
	er.e = te;
	er.side = side;
	tp->edges->push_back (er);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rax
movb 0x17(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x12829
leaq 0x26f7f(%rip), %rdi     # 0x39798
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x20(%rsp), %rax
testb $0x1, 0x20(%rax)
je 0x12856
movq 0x18(%rsp), %rax
testb $0x1, 0x18(%rax)
jne 0x12856
leaq 0x26f85(%rip), %rdi     # 0x397cb
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movb 0x17(%rsp), %dl
andb $0x1, %dl
movzbl %dl, %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq %rsp, %rsi
callq 0x19ce0
addq $0x28, %rsp
retq
nopl (%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreeface(int&, bool)
btreeface_t *AllocTreeface (int &numobjects, bool infinite)
{
	numobjects++;
	btreeface_t *tf = (btreeface_t *)malloc (sizeof (btreeface_t));
	hlassume (tf != NULL, assume_NoMemory);
	tf->edges = new btreeedge_l ();
	tf->leafs[0].l = NULL;
	tf->leafs[0].side = false;
	tf->leafs[1].l = NULL;
	tf->leafs[1].side = true;
	tf->infinite = infinite;
	return tf;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x48, %edi
callq 0x43e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbe90
movl $0x18, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x4180
movq 0x8(%rsp), %rdi
callq 0x19cc0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x28(%rax)
movb 0x1f(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AttachEdgeToFace(btreeface_s*, btreeedge_s*, int)
void AttachEdgeToFace (btreeface_t *tf, btreeedge_t *te, int side)
{
	if (tf->infinite && !te->infinite)
	{
		PrintOnce ("AttachEdgeToFace: internal error: attaching a finite object to an infinite object.");
		hlassume (false, assume_first);
	}
	btreeedge_r er;
	er.e = te;
	er.side = side;
	tf->edges->push_back (er);

	btreeface_r fr;
	fr.f = tf;
	fr.side = side;
	te->faces->push_back (fr);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x30(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x129df
movq 0x28(%rsp), %rax
testb $0x1, 0x20(%rax)
jne 0x129df
leaq 0x26e50(%rip), %rdi     # 0x3981f
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x24(%rsp)
setne %al
andb $0x1, %al
movb %al, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
leaq 0x10(%rsp), %rsi
callq 0x19ce0
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x24(%rsp)
setne %al
andb $0x1, %al
movb %al, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rdi
movq %rsp, %rsi
callq 0x19d20
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AttachFaceToLeaf(btreeleaf_s*, btreeface_s*, int)
void AttachFaceToLeaf (btreeleaf_t *tl, btreeface_t *tf, int side)
{
	if (tl->infinite && !tf->infinite)
	{
		PrintOnce ("AttachFaceToLeaf: internal error: attaching a finite object to an infinite object.");
		hlassume (false, assume_first);
	}
	btreeface_r fr;
	fr.f = tf;
	fr.side = side;
	tl->faces->push_back (fr);

	if (tf->leafs[side].l)
	{
		PrintOnce ("AttachFaceToLeaf: internal error: leaf occupied.");
		hlassume (false, assume_first);
	}
	tf->leafs[side].l = tl;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x12a7f
movq 0x18(%rsp), %rax
testb $0x1, 0x8(%rax)
jne 0x12a7f
leaq 0x26e03(%rip), %rdi     # 0x39872
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x14(%rsp)
setne %al
andb $0x1, %al
movb %al, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq %rsp, %rsi
callq 0x19d20
movq 0x18(%rsp), %rax
addq $0x10, %rax
movslq 0x14(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x12ad8
leaq 0x26dfd(%rip), %rdi     # 0x398c5
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
addq $0x10, %rax
movslq 0x14(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: AllocTreeleaf(int&, bool)
btreeleaf_t *AllocTreeleaf (int &numobjects, bool infinite)
{
	numobjects++;
	btreeleaf_t *tl = (btreeleaf_t *)malloc (sizeof (btreeleaf_t));
	hlassume (tl != NULL, assume_NoMemory);
	tl->faces = new btreeface_l ();
	tl->infinite = infinite;
	return tl;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x18, %edi
callq 0x43e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
setne %al
movzbl %al, %edi
andl $0x1, %edi
movl $0x1, %esi
callq 0xbe90
movl $0x18, %edi
callq 0x42f0
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x4180
movq 0x8(%rsp), %rdi
callq 0x19cd0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb 0x1f(%rsp), %cl
movq 0x10(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: GetPointFromEdge(btreeedge_s*, bool)
btreepoint_t *GetPointFromEdge (btreeedge_t *te, bool side)
{
	if (!te->points[side].p)
	{
		PrintOnce ("GetPointFromEdge: internal error: point not set.");
		hlassume (false, assume_first);
	}
	return te->points[side].p;
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movb 0xf(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0x13235
leaq 0x266d1(%rip), %rdi     # 0x398f6
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
movq 0x10(%rsp), %rax
movb 0xf(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FreeSlave[P]vhlt/hlbsp/brink.cpp
// Function: RemoveEdgeFromList(std::__cxx11::list<btreeedge_r, std::allocator<btreeedge_r>>*, btreeedge_s*, bool)
void RemoveEdgeFromList (btreeedge_l *el, btreeedge_t *te, bool side)
{
	btreeedge_l::iterator ei;
	for (ei = el->begin (); ei != el->end (); ei++)
	{
		if (ei->e == te && ei->side == side)
		{
			el->erase (ei);
			return; // only remove one copy if there are many (in order to preserve topological correctness)
		}
	}
	PrintOnce ("RemoveEdgeFromList: internal error: edge not found.");
	hlassume (false, assume_first);
}

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x19d60
movq 0x50(%rsp), %rdi
callq 0x19d80
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
callq 0x19dd0
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x19db0
testb $0x1, %al
jne 0x132bd
jmp 0x13338
leaq 0x38(%rsp), %rdi
callq 0x19e00
movq (%rax), %rax
cmpq 0x48(%rsp), %rax
jne 0x13320
leaq 0x38(%rsp), %rdi
callq 0x19e00
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x47(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x13320
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x19e70
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x19e20
movq %rax, 0x18(%rsp)
jmp 0x1334f
jmp 0x13322
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x19e90
movq %rax, 0x10(%rsp)
jmp 0x13299
leaq 0x265e8(%rip), %rdi     # 0x39927
movb $0x0, %al
callq 0xb840
xorl %esi, %esi
movl %esi, %edi
callq 0xbe90
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)