LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: socket_read_loop(int)
int socket_read_loop(int fd) {
  oscpkt::PacketReader pr;
  while (true) {
    int ret = read_osc(fd, &pr);
    if (ret < 0 || !pr.isOk()) {
      return -1;
    }
    oscpkt::Message* msg;
    for (msg = pr.popMessage(); msg; msg = pr.popMessage()) {
      //std::cout << *msg << std::endl;
      oscpkt::Message::ArgReader arg = msg->arg();
      int resp_id = -1;
      if (arg.isInt32()) {
        arg.popInt32(resp_id);
        if (msg->match("/done"))
          remove_pending(resp_id);
        handle_message(msg, &arg, resp_id);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movl %edi, %ebp
leaq 0x40(%rsp), %r14
movq %r14, 0x8(%r14)
movq %r14, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x0, 0x20(%r14)
movl %ebp, %edi
movq %r14, %rsi
callq 0x2a08
testl %eax, %eax
js 0x2b35
cmpl $0x0, 0x60(%rsp)
jne 0x2b35
movq 0x40(%rsp), %rax
movq 0x58(%rsp), %rcx
cmpq %r14, %rax
sete %dl
cmpq %r14, %rcx
sete %sil
orb %dl, %sil
jne 0x2aab
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
leaq 0x10(%rcx), %rbx
movq %rbx, 0x28(%rsp)
movl 0x88(%rcx), %esi
movl %esi, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
testl %esi, %esi
jne 0x2b1c
cmpq $0x0, 0x40(%rcx)
je 0x2b1c
movq 0x38(%rcx), %rcx
cmpb $0x69, (%rcx)
je 0x2b50
cmpq %r14, %rdx
sete %sil
cmpq %r14, %rax
je 0x2aab
movq %rdx, %rcx
testb %sil, %sil
je 0x2adc
jmp 0x2aab
leaq 0x40(%rsp), %rdi
callq 0x4512
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movl $0x69, %esi
callq 0x4d0a
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x34b0(%rip), %rsi      # 0x6024
leaq 0x34ae(%rip), %rdx      # 0x6029
leaq 0x8(%rsp), %rdi
callq 0x508e
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0x3b0a
movl 0x70(%rsp), %ebp
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2bb2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
testl %ebp, %ebp
jne 0x2bbf
movl 0x4(%rsp), %edi
callq 0x25c9
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2c01
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2bef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x2bef
jmp 0x2bec
jmp 0x2bec
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4512
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: parse_opts(options&, int, char**)
int parse_opts(options& options, int argc, char* argv[]) {

  int c = 0;

  static struct option long_options[] = {
    {"help",          0,    0,  'h'},
    {"version",       0,    0,  'v'},
    {"socket-path",   1,    0,  'S'},
    {"exec",          1,    0,  'e'},
    {"interactive",   0,    0,  'i'},
    {0,               0,    0,    0},
  };
  int long_index;
  while (c != -1) {
    c = getopt_long(argc, argv, "hve:S:i", long_options, &long_index);
    switch (c) {
    case 0:
      break;
    case 'h':
      print_usage(argv[0]);
      return 10;
      break;
    case 'v':
      print_version();
      return 10;
      break;
    case 'S':
      options.socket_path = std::string(optarg);
      break;
    case 'e':
      options.eval_commands.push_back(std::string(optarg));
      break;
    case 'i':
      options.interactive = true;
      break;
    }

  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x20(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x5e54(%rip), %r13      # 0x91e0
leaq 0x34(%rsp), %r15
leaq 0x8(%rsp), %r12
movl %ebp, %edi
movq %rbx, %rsi
leaq 0x2ea7(%rip), %rdx      # 0x6249
movq %r13, %rcx
movq %r15, %r8
callq 0x2310
cmpl $0x67, %eax
jg 0x33e6
cmpl $0x53, %eax
je 0x33f2
cmpl $0x65, %eax
jne 0x3449
movq 0x5bf9(%rip), %rax      # 0x8fc0
movq (%rax), %rsi
movq %r12, %rdi
leaq 0x7(%rsp), %rdx
callq 0x20c0
movq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x5282
jmp 0x3414
cmpl $0x69, %eax
jne 0x3439
movb $0x1, 0x38(%r14)
jmp 0x3396
movq 0x5bc7(%rip), %rax      # 0x8fc0
movq (%rax), %rsi
movq %r12, %rdi
leaq 0x7(%rsp), %rdx
callq 0x20c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2290
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3396
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x3396
cmpl $0x76, %eax
je 0x3460
cmpl $0x68, %eax
jne 0x3396
jmp 0x3456
cmpl $-0x1, %eax
jne 0x3396
xorl %eax, %eax
jmp 0x346a
movq (%rbx), %rdi
callq 0x3606
jmp 0x3465
callq 0x35be
movl $0xa, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3498
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: interactive_loop(int, int, std::istream&)
int interactive_loop(int sock, int start_id, std::istream& in) {
  bool keep_looping = true;
  char* buff = new char [1024];

  while (keep_looping) {
    in.getline(buff, 1024);

    char* trimmed = buff;
    while (trimmed < (buff+1024) && *trimmed && *trimmed == ' ')
      trimmed++;
    if (strncmp(trimmed, "quit", 4) == 0)
      break;

    osc_msg(sock, "/eval", start_id++, "s", trimmed);


    if (in.eof()) break;


  }

  delete[] buff;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movl %esi, %ebx
movl %edi, %ebp
movl $0x400, %edi            # imm = 0x400
callq 0x2030
movq %rax, %r15
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2210
movsbl %al, %ecx
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %r15, %rsi
callq 0x2380
leaq 0x400(%r15), %r14
xorl %eax, %eax
cmpb $0x20, (%r15,%rax)
jne 0x3504
incq %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x34f0
jmp 0x350a
movq %r15, %r14
addq %rax, %r14
leaq 0x2d40(%rip), %rsi      # 0x6251
movl $0x4, %edx
movq %r14, %rdi
callq 0x2100
testl %eax, %eax
je 0x3579
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b94(%rip), %rsi      # 0x60c6
leaq 0x2b92(%rip), %rdx      # 0x60cb
leaq 0x20(%rsp), %rdi
callq 0x508e
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2b78(%rip), %rsi      # 0x60cc
leaq 0x2b72(%rip), %rdx      # 0x60cd
movq %rsp, %rdi
callq 0x508e
leaq 0x20(%rsp), %rsi
movq %rsp, %rcx
movl %ebp, %edi
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2651
movq %r15, %rdi
callq 0x22a0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x359f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x359f
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x35b6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: print_usage(char*)
int print_usage(char* execname) {
  print_version();
  std::cout << "USAGE:\n";
  std::cout << "\t" << execname << " [OPTIONS]\n";
  std::cout << "\n";
  std::string help_text = ""\
                          "--help -h\n"\
                          "\tShow this message\n"\
                          "\n"\
                          "--version -v\n"\
                          "\tDisplay the version string\n"\
                          "\n"\
                          "--socket-path -S\n"\
                          "\tPath to the UNIX socket of MoltenGamepad\n"\
                          "\n"\
                          "--exec -e <command>\n"\
                          "\tSend command to MoltenGamepad\n"\
                          "\n"\
                          "--interactive -i <command>\n"\
                          "\tRead and send commands from standard input.\n"\
                          "\n"\
                          ;

  std::cout << help_text;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x35be
movq 0x59b2(%rip), %r14      # 0x8fd0
leaq 0x2ae2(%rip), %rsi      # 0x6107
movl $0x7, %edx
movq %r14, %rdi
callq 0x2260
leaq 0x2ad6(%rip), %rsi      # 0x610f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2260
testq %rbx, %rbx
je 0x3667
movq %rbx, %rdi
callq 0x20d0
movq 0x5976(%rip), %rdi      # 0x8fd0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2260
jmp 0x367f
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2320
movq 0x594a(%rip), %rbx      # 0x8fd0
leaq 0x2a84(%rip), %rsi      # 0x6111
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2260
leaq 0x2b7c(%rip), %rsi      # 0x621d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2260
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2a5f(%rip), %rsi      # 0x611d
leaq 0x2b59(%rip), %rdx      # 0x621e
movq %rsp, %r14
movq %r14, %rdi
callq 0x508e
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2260
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x36f5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x371a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, oscpkt::TimeTag)
Message &init(const std::string &addr, TimeTag tt = TimeTag::immediate()) {
    clear();
    address = addr; time_tag = tt;
    if (address.empty() || address[0] != '/') OSCPKT_SET_ERR(MALFORMED_ADDRESS_PATTERN);     
    return *this;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x3e26
leaq 0x8(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2130
movq %r15, (%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x38b1
movq (%r14), %rax
cmpb $0x2f, (%rax)
je 0x38be
cmpl $0x0, 0x78(%rbx)
jne 0x38be
movl $0x1, 0x78(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message::pushStr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Message &pushStr(const std::string &s) {
    assert(s.size() < 2147483647); // insane values are not welcome
    type_tags += TYPE_TAG_STRING;
    arguments.push_back(std::make_pair(storage.size(), s.size() + 1));
    strcpy(storage.getBytes(s.size()+1), s.c_str());
    return *this;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x7fffffff, 0x8(%rsi)  # imm = 0x7FFFFFFF
jae 0x39ba
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rdi
movl $0x73, %esi
callq 0x21d0
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
leaq 0x60(%rbx), %r15
movq 0x8(%r14), %rcx
incq %rcx
movq %rax, (%rsp)
movq %rcx, 0x8(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x3987
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x50(%rbx)
jmp 0x3993
leaq 0x48(%rbx), %rdi
movq %rsp, %rdx
callq 0x40a2
movq 0x8(%r14), %rsi
incq %rsi
movq %r15, %rdi
callq 0x4024
movq (%r14), %rsi
movq %rax, %rdi
callq 0x2200
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2930(%rip), %rdi      # 0x62f1
leaq 0x28e9(%rip), %rsi      # 0x62b1
leaq 0x2938(%rip), %rcx      # 0x6307
movl $0x193, %edx            # imm = 0x193
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::PacketWriter::addMessage(oscpkt::Message const&)
PacketWriter &addMessage(const Message &msg) {
    if (storage.size() != 0 && bundles.empty()) OSCPKT_SET_ERR(BUNDLE_REQUIRED_FOR_MULTI_MESSAGES);
    else msg.packMessage(storage, bundles.size()>0);
    if (!msg.isOk()) OSCPKT_SET_ERR(msg.getErr());
    return *this;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
je 0x3a09
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x3a10
cmpl $0x0, 0x30(%rbx)
jne 0x3a24
movl $0xa, 0x30(%rbx)
jmp 0x3a24
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x18(%rbx), %rsi
xorl %edx, %edx
cmpq %rax, %rcx
setne %dl
movq %r14, %rdi
callq 0x41e2
movl 0x78(%r14), %eax
testl %eax, %eax
je 0x3a35
cmpl $0x0, 0x30(%rbx)
jne 0x3a35
movl %eax, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::PacketReader::init(void const*, unsigned long)
void init(const void *ptr, size_t sz) {
    err = OK_NO_ERROR; messages.clear();
    if ((sz%4) == 0) { 
      parse((const char*)ptr, (const char *)ptr+sz, TimeTag::immediate());
    } else OSCPKT_SET_ERR(INVALID_PACKET_SIZE);
    it_messages = messages.begin();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, 0x20(%rdi)
callq 0x4512
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq $0x0, 0x10(%rbx)
testb $0x3, %r14b
je 0x3ae6
cmpl $0x0, 0x20(%rbx)
movq %rbx, %rax
jne 0x3aff
movl $0x9, 0x20(%rbx)
movq %rbx, %rax
jmp 0x3aff
addq %r15, %r14
movl $0x1, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4380
movq (%rbx), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message& oscpkt::Message::pushPod<int>(int, int)
Message &pushPod(int tag, POD v) {
    type_tags += (char)tag; 
    arguments.push_back(std::make_pair(storage.size(), sizeof(POD)));
    pod2bytes(v, storage.getBytes(sizeof(POD))); 
    return *this;
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rdi, %rbx
addq $0x28, %rdi
movsbl %sil, %esi
callq 0x21d0
leaq 0x60(%rbx), %r14
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
movq %rax, (%rsp)
movq $0x4, 0x8(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x3fe5
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x50(%rbx)
jmp 0x3ff1
leaq 0x48(%rbx), %rdi
movq %rsp, %rdx
callq 0x40a2
movl $0x4, %esi
movq %r14, %rdi
callq 0x4024
movd %ebp, %xmm0
pxor %xmm1, %xmm1
punpcklbw %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1],xmm0[2],xmm1[2],xmm0[3],xmm1[3],xmm0[4],xmm1[4],xmm0[5],xmm1[5],xmm0[6],xmm1[6],xmm0[7],xmm1[7]
pshuflw $0x1b, %xmm0, %xmm0     # xmm0 = xmm0[3,2,1,0,4,5,6,7]
packuswb %xmm0, %xmm0
movd %xmm0, (%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::PacketReader::parse(char const*, char const*, oscpkt::TimeTag)
void parse(const char *beg, const char *end, TimeTag time_tag) {
    assert(beg <= end && !err); assert(((end-beg)%4)==0);
    
    if (beg == end) return;
    if (*beg == '#') {
      /* it's a bundle */
      if (end - beg >= 20 
          && memcmp(beg, "#bundle\0", 8) == 0) {
        TimeTag time_tag2(bytes2pod<uint64_t>(beg+8));
        const char *pos = beg + 16;
        do {
          uint32_t sz = bytes2pod<uint32_t>(pos); pos += 4;
          if ((sz&3) != 0 || pos + sz > end || pos+sz < pos) {
            OSCPKT_SET_ERR(INVALID_BUNDLE);
          } else {
            parse(pos, pos+sz, time_tag2);
            pos += sz;
          }
        } while (!err && pos != end);
      } else {
        OSCPKT_SET_ERR(INVALID_BUNDLE);
      }
    } else {
      messages.push_back(Message(beg, end-beg, time_tag));
      if (!messages.back().isOk()) OSCPKT_SET_ERR(messages.back().getErr());
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
cmpq %rdx, %rsi
ja 0x44d7
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jne 0x44d7
movq %rdx, %r14
subq %rsi, %rdx
testb $0x3, %dl
jne 0x44e0
cmpq %r14, %rsi
je 0x44c7
cmpb $0x23, (%rsi)
jne 0x4433
movl $0x8, %ebp
cmpq $0x14, %rdx
jl 0x44c4
movabsq $0x656c646e756223, %rax # imm = 0x656C646E756223
cmpq %rax, (%rsi)
jne 0x44c4
movq 0x8(%rsi), %r15
bswapq %r15
addq $0x10, %rsi
movl (%rsi), %eax
bswapl %eax
testb $0x3, %al
jne 0x44c4
addq $0x4, %rsi
movl %eax, %r12d
addq %rsi, %r12
cmpq %r14, %r12
ja 0x44c4
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x4380
cmpl $0x0, 0x20(%rbx)
jne 0x44c7
movq %r12, %rsi
cmpq %r14, %r12
jne 0x43ef
jmp 0x44c7
movq %rsp, %r14
movq %r14, %rdi
callq 0x45ae
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4692
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x4463
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x447a
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4495
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x44b0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x8(%rbx), %rax
movl 0x88(%rax), %ebp
testl %ebp, %ebp
je 0x44c7
cmpl $0x0, 0x20(%rbx)
jne 0x44c7
movl %ebp, 0x20(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e62(%rip), %rdi      # 0x6340
jmp 0x44e7
leaq 0x1eb2(%rip), %rdi      # 0x6399
leaq 0x1dc3(%rip), %rsi      # 0x62b1
leaq 0x1e5e(%rip), %rcx      # 0x6353
movl $0x216, %edx            # imm = 0x216
callq 0x2150
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3a40
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message::getArgSize(int, char const*)
size_t getArgSize(int type, const char *p) {
    if (err) return 0;
    size_t sz = 0;
    assert(p >= storage.begin() && p <= storage.end());
    switch (type) {
      case TYPE_TAG_TRUE:
      case TYPE_TAG_FALSE: sz = 0; break;
      case TYPE_TAG_INT32: 
      case TYPE_TAG_FLOAT: sz = 4; break;
      case TYPE_TAG_INT64: 
      case TYPE_TAG_DOUBLE: sz = 8; break;
      case TYPE_TAG_STRING: {
        const char *q = (const char*)memchr(p, 0, storage.end()-p);
        if (!q) OSCPKT_SET_ERR(MALFORMED_ARGUMENTS);
        else sz = (q-p)+1;
      } break;
      case TYPE_TAG_BLOB: {
        if (p == storage.end()) { OSCPKT_SET_ERR(MALFORMED_ARGUMENTS); return 0; }
        sz = 4+bytes2pod<uint32_t>(p);
      } break;
      default: {
        OSCPKT_SET_ERR(UNHANDLED_TYPE_TAGS); return 0;
      } break;
    }
    if (p+sz > storage.end() || /* string or blob too large.. */
        p+sz < p /* or even blob so large that it did overflow */) { 
      OSCPKT_SET_ERR(MALFORMED_ARGUMENTS); return 0; 
    }
    if (!isZeroPaddingCorrect(p+sz)) { OSCPKT_SET_ERR(MALFORMED_ARGUMENTS); return 0; }
    return sz;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x78(%rdi)
jne 0x4ba5
movq %rdx, %r14
movq %rdi, %rbx
movq 0x60(%rdi), %rcx
movq 0x68(%rdi), %rax
xorl %r15d, %r15d
subq %rcx, %rax
cmovneq %rcx, %r15
cmpq %rdx, %r15
ja 0x4bc2
addq %rax, %r15
movq %r15, %rdx
subq %r14, %rdx
jb 0x4bc2
movl $0x4, %ecx
cmpl $0x61, %esi
jle 0x4aec
leal -0x62(%rsi), %eax
cmpl $0x7, %eax
ja 0x4b04
leaq 0x1528(%rip), %rdx      # 0x6004
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movl $0x8, %eax
jmp 0x4b35
xorl %eax, %eax
cmpl $0x46, %esi
je 0x4b35
cmpl $0x54, %esi
je 0x4b35
jmp 0x4ba2
movl $0x4, %eax
jmp 0x4b35
cmpl $0x73, %esi
jne 0x4ba2
movq %r14, %rdi
xorl %esi, %esi
callq 0x2240
testq %rax, %rax
je 0x4bad
subq %r14, %rax
incq %rax
jmp 0x4b35
cmpq %r14, %r15
je 0x4b9d
movl (%r14), %eax
bswapl %eax
addl $0x4, %eax
movl $0x3, %ecx
testq %rax, %rax
js 0x4ba2
addq %rax, %r14
movb $0x1, %dl
cmpq %r15, %r14
ja 0x4ba2
leaq 0x3(%r14), %rcx
andq $-0x4, %rcx
cmpq %rcx, %r14
jae 0x4ba7
cmpb $0x0, (%r14)
je 0x4b67
movl $0x3, %ecx
testb %dl, %dl
jne 0x4ba2
jmp 0x4ba5
incq %r14
movq %r14, %rsi
subq %rcx, %rsi
movq %r14, %rdi
testq %rsi, %rsi
je 0x4b84
leaq 0x1(%rdi), %r14
incq %rsi
cmpb $0x0, (%rdi)
je 0x4b70
xorl %esi, %esi
cmpq %rcx, %rdi
setb %dil
cmovbq %rsi, %rax
movl $0x3, %ecx
testb %dl, %dil
jne 0x4ba2
jmp 0x4ba7
movl $0x3, %ecx
movl %ecx, 0x78(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movl $0x3, 0x78(%rbx)
xorl %eax, %eax
movl $0x0, %edx
cmpq %r14, %r15
jae 0x4b49
jmp 0x4ba7
leaq 0x1864(%rip), %rdi      # 0x642d
leaq 0x16e1(%rip), %rsi      # 0x62b1
leaq 0x1881(%rip), %rcx      # 0x6458
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Message::ArgReader& oscpkt::Message::ArgReader::popPod<int>(int, int&)
ArgReader &popPod(int tag, POD &v) {
      if (precheck(tag)) {
        v = bytes2pod<POD>(argBeg(arg_idx));
        ++arg_idx;
      } else v = POD(0);
      return *this;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x4d98
testb %al, %al
je 0x4d59
movq 0x10(%rbx), %rax
cmpl $0x0, 0x8(%rbx)
jne 0x4d62
movq (%rbx), %rsi
movq 0x48(%rsi), %rdx
movq 0x50(%rsi), %rcx
subq %rdx, %rcx
sarq $0x4, %rcx
cmpq %rax, %rcx
jbe 0x4d62
movq 0x60(%rsi), %rdi
xorl %ecx, %ecx
cmpq %rdi, 0x68(%rsi)
cmovneq %rdi, %rcx
movq %rax, %rsi
shlq $0x4, %rsi
addq (%rdx,%rsi), %rcx
jmp 0x4d64
movl $0x0, (%r14)
jmp 0x4d8c
xorl %ecx, %ecx
addq $0x3, %rcx
xorl %edx, %edx
movb (%rcx), %sil
movb %sil, 0x4(%rsp,%rdx)
incq %rdx
decq %rcx
cmpq $0x4, %rdx
jne 0x4d6a
movl 0x4(%rsp), %ecx
movl %ecx, (%r14)
incq %rax
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ricbit[P]dlx/cover_refactor.cc
// Function: ExactCover::solve(int)
void solve(int level) {
    if (header[0].rlink == 0) {
      count++;
      return;
    }
    int item = best_item();
    cover(item);
    solution[level] = nodes[item].dlink;
    for (auto& option = solution[level]; option != item; option = nodes[option].dlink) {
      try_option(option);
      solve(level + 1);
      rewind_option(option);
    }
    uncover(item);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
movq %rdi, %rbx
cmpl $0x0, 0x4(%rax)
je 0x3861
movq %rbx, %rdi
movl %esi, %ebp
callq 0x3872
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x38b4
movq 0x18(%rbx), %rdx
movslq %r14d, %rax
movq 0x38(%rbx), %r12
movslq %ebp, %r15
leaq (%rax,%rax,2), %rcx
movl 0x8(%rdx,%rcx,4), %esi
movl %esi, (%r12,%r15,4)
cmpl %eax, %esi
je 0x384e
incl %ebp
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x39bc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x37c2
movl (%r12,%r15,4), %esi
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x3a0c
movslq (%r12,%r15,4), %rax
movq 0x18(%rbx), %rcx
leaq (%rax,%rax,2), %rax
movl 0x8(%rcx,%rax,4), %esi
movl %esi, (%r12,%r15,4)
cmpl %r14d, %esi
jne 0x3811
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3916
incq 0x90(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ricbit[P]dlx/cover_refactor.cc
// Function: void ExactCover::option_right<ExactCover::hide(int)::'lambda'(int)>(int, ExactCover::hide(int)::'lambda'(int))
void option_right(int option, T action) {
    for (auto p = option + 1; p != option;) {
      if (nodes[p].top <= 0) {
        p = nodes[p].ulink;
      } else {
        action(p);
        p++;
      }
    }
  }

// Assembly:
pushq %rbx
movq 0x18(%rdi), %rax
leal 0x1(%rsi), %ecx
movslq %ecx, %rdi
leaq (%rdi,%rdi,2), %rdi
cmpl $0x0, (%rax,%rdi,4)
jle 0x39af
movq 0x18(%rdx), %r8
incl %ecx
movslq 0x4(%r8,%rdi,4), %r10
movslq (%r8,%rdi,4), %r9
movslq 0x8(%r8,%rdi,4), %rdi
leaq (%r10,%r10,2), %r11
leaq (%rdi,%rdi,2), %rbx
movl %edi, 0x8(%r8,%r11,4)
leaq (%r9,%r9,2), %rdi
movl %r10d, 0x4(%r8,%rbx,4)
decl (%r8,%rdi,4)
jmp 0x39b6
leaq (%rax,%rdi,4), %rcx
movl 0x4(%rcx), %ecx
cmpl %esi, %ecx
jne 0x3972
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ricbit[P]dlx/cover_refactor.cc
// Function: void ExactCover::option_left<ExactCover::unhide(int)::'lambda'(int)>(int, ExactCover::unhide(int)::'lambda'(int))
void option_left(int option, T action) {
    for (auto p = option - 1; p != option;) {
      if (nodes[p].top <= 0) {
        p = nodes[p].dlink;
      } else {
        action(p);
        p--;
      }
    }
  }

// Assembly:
movq 0x18(%rdi), %rax
leal -0x1(%rsi), %ecx
movslq %ecx, %rdi
leaq (%rdi,%rdi,2), %rdi
cmpl $0x0, (%rax,%rdi,4)
jle 0x3aa0
movq 0x18(%rdx), %r8
movslq 0x4(%r8,%rdi,4), %r10
movslq (%r8,%rdi,4), %r9
movslq 0x8(%r8,%rdi,4), %rdi
leaq (%r10,%r10,2), %r10
leaq (%rdi,%rdi,2), %rdi
movl %ecx, 0x8(%r8,%r10,4)
movl %ecx, 0x4(%r8,%rdi,4)
leaq (%r9,%r9,2), %rdi
decl %ecx
incl (%r8,%rdi,4)
jmp 0x3aa7
leaq (%rax,%rdi,4), %rcx
movl 0x8(%rcx), %ecx
cmpl %esi, %ecx
jne 0x3a63
retq
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::CleanUp()
void RegEx::CleanUp() {
	for(int i = 0; i < (int)m_NFATable.size(); ++i) {
		delete m_NFATable[i];
	}
	m_NFATable.clear();

	for(int i = 0; i < (int)m_DFATable.size(); ++i)
		delete m_DFATable[i];
	m_DFATable.clear();

	m_nNextStateID = 0;

	while(!m_CharacterClassStack.empty())
		m_CharacterClassStack.pop();

	while(!m_ExpressionStack.empty())
		m_ExpressionStack.pop();

	m_InputSet.clear();

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x4f0c
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4ef7
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
incq %r14
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jl 0x4ee1
cmpq %rax, %rcx
je 0x4f15
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
testl %edx, %edx
jle 0x4f5a
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4f45
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
incq %r14
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jl 0x4f2e
cmpq %rax, %rcx
je 0x4f63
movq %rax, 0x20(%rbx)
movl $0x0, 0x14c(%rbx)
movq 0x60(%rbx), %rax
cmpq 0x40(%rbx), %rax
je 0x4f8d
leaq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x85c8
movq 0x60(%rbx), %rax
cmpq 0x40(%rbx), %rax
jne 0x4f7b
movq 0xb0(%rbx), %rax
cmpq 0x90(%rbx), %rax
je 0x4fbc
leaq 0x80(%rbx), %r14
movq %r14, %rdi
callq 0x864e
movq 0xb0(%rbx), %rax
cmpq 0x90(%rbx), %rax
jne 0x4fa4
addq $0xd0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x869a
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::IsMetaChar(char)
bool RegEx::IsMetaChar( char inputCh ) {
	return(( inputCh == CLOSURE )      || 
		   ( inputCh == OR )           || 
		   ( inputCh == OPEN_PAREN )   || 
		   ( inputCh == CLOSE_PAREN )  || 
		   ( inputCh == PLUS_CLOSURE ) ||
		   ( inputCh == FALSE_CONCAT ) ||
		   ( inputCh == OPTIONAL ));
}

// Assembly:
movb $0x1, %al
cmpl $0x3f, %esi
ja 0x4fec
movl %esi, %ecx
movabsq $-0x7ffff0c000000000, %rdx # imm = 0x80000F4000000000
btq %rcx, %rdx
jae 0x4fec
retq
cmpl $0x7c, %esi
je 0x4feb
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::PopTable(std::vector<RegExState*, std::allocator<RegExState*>>&)
bool RegEx::PopTable(Table  &NFATable) {
	if(m_CharacterClassStack.size()>0) {
		NFATable = m_CharacterClassStack.top();
		m_CharacterClassStack.pop();
		return true;
	}
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rdi), %rcx
movq %rcx, %rax
subq 0x58(%rdi), %rax
sarq $0x3, %rax
cmpq $0x1, %rcx
adcq $-0x1, %rax
leaq (%rax,%rax,4), %rdx
leaq (%rax,%rdx,4), %rdi
movq 0x50(%rbx), %r8
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rdx
movq %rax, %r9
subq %rdx, %r9
sarq $0x3, %r9
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r9, %r14
addq %rdi, %r14
subq 0x40(%rbx), %r8
sarq $0x3, %r8
movabsq $0x5555555555555555, %r15 # imm = 0x5555555555555555
imulq %r8, %r15
cmpq %r15, %r14
je 0x50a0
addq $0x30, %rbx
cmpq %rdx, %rax
jne 0x5089
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
addq $-0x18, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x79bc
movq %rbx, %rdi
callq 0x85c8
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::Concatenate()
bool RegEx::Concatenate() {

    Table  LeftTable, RightTable;
    if(!PopTable(RightTable) || !PopTable(LeftTable))
		return false;

	(*(LeftTable.rbegin()))->AddTransition(EPSILON, (*(RightTable.begin())));
	LeftTable.insert(LeftTable.end(), RightTable.begin(), RightTable.end());
	m_CharacterClassStack.push(LeftTable);

	return true;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movq %rax, 0x10(%rsi)
movaps %xmm0, (%rsi)
callq 0x500e
testb %al, %al
je 0x512c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x500e
testb %al, %al
je 0x512c
movq 0x8(%rsp), %rax
movq -0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x94d8
movq %rsp, %rdi
movq 0x8(%rdi), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x86e4
addq $0x30, %rbx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x88e4
jmp 0x512e
xorl %ebp, %ebp
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5145
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x515b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x5168
jmp 0x5168
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5182
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5198
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::PushOnCharacterStack(char)
void RegEx::PushOnCharacterStack(char chInput) {

	RegExState *s0 = new RegExState(m_nNextStateID++);
	RegExState *s1 = new RegExState(m_nNextStateID++);

	s0->AddTransition(chInput, s1);

	Table NewSubTable;
	NewSubTable.push_back(s0);
	NewSubTable.push_back(s1);
	m_CharacterClassStack.push(NewSubTable);

	m_InputSet.insert(chInput);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, 0xc(%rsp)
movq %rdi, %rbx
movb %sil, 0x7(%rsp)
movl $0x78, %edi
callq 0x2150
movq %rax, %r14
movl 0x14c(%rbx), %ebp
leal 0x1(%rbp), %eax
movl %eax, 0x8(%rsp)
movl %eax, 0x14c(%rbx)
leaq 0x8b9f(%rip), %r12      # 0xdd80
addq $0x10, %r12
movq %r12, (%r14)
leaq 0x10(%r14), %rax
xorl %r13d, %r13d
movl %r13d, 0x10(%r14)
movq %r13, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %rax, 0x28(%r14)
movq %r13, 0x30(%r14)
leaq 0x40(%r14), %rax
movl %r13d, 0x40(%r14)
movq %r13, 0x48(%r14)
movq %rax, 0x50(%r14)
movq %rax, 0x58(%r14)
movq %r13, 0x60(%r14)
movl %ebp, 0x68(%r14)
movb %r13b, 0x6c(%r14)
movl %r13d, 0x70(%r14)
leaq 0x30(%rsp), %rax
movq %r14, (%rax)
movl $0x78, %edi
callq 0x2150
movq %rax, %r15
addl $0x2, %ebp
movl %ebp, 0x14c(%rbx)
movq %r12, (%rax)
addq $0x10, %rax
movl %r13d, 0x10(%r15)
movq %r13, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r13, 0x30(%r15)
leaq 0x40(%r15), %rax
movl %r13d, 0x40(%r15)
movq %r13, 0x48(%r15)
movq %rax, 0x50(%r15)
movq %rax, 0x58(%r15)
movq %r13, 0x60(%r15)
movl 0x8(%rsp), %eax
movl %eax, 0x68(%r15)
movb %r13b, 0x6c(%r15)
movl %r13d, 0x70(%r15)
movq %r15, 0x28(%rsp)
movq %r14, %rdi
movl 0xc(%rsp), %esi
movq %r15, %rdx
callq 0x94d8
leaq 0x10(%rsp), %rdi
movq %r13, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
xorl %esi, %esi
leaq 0x30(%rsp), %rdx
callq 0x8bf2
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x52ce
movq %r15, (%rsi)
addq $0x8, 0x18(%rsp)
jmp 0x52dd
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x8bf2
leaq 0x30(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x88e4
addq $0xd0, %rbx
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x8cce
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5316
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x533f
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::ClosureOptional()
bool RegEx::ClosureOptional() {

	Table PrevTable;
	if(!PopTable(PrevTable))
		return false;

	RegExState *LeftTable  = new RegExState(m_nNextStateID++);
	RegExState *RightTable = new RegExState(m_nNextStateID++);

	LeftTable->AddTransition(EPSILON, RightTable);
	LeftTable->AddTransition(EPSILON, ((*(PrevTable.begin()))));
	((*(PrevTable.rbegin())))->AddTransition(EPSILON, RightTable);

	PrevTable.insert( PrevTable.begin(), LeftTable );
	PrevTable.push_back ( RightTable);

	m_CharacterClassStack.push(PrevTable);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x500e
movl %eax, %ebx
testb %al, %al
je 0x54f1
movb %bl, 0xf(%rsp)
movl $0x78, %edi
callq 0x2150
movq %rax, %r12
movl 0x14c(%r14), %ebx
leal 0x1(%rbx), %eax
movl %eax, 0x34(%rsp)
movl %eax, 0x14c(%r14)
leaq 0x89d8(%rip), %rbp      # 0xdd80
addq $0x10, %rbp
movq %rbp, (%r12)
leaq 0x10(%r12), %rax
xorl %r13d, %r13d
movl %r13d, 0x10(%r12)
movq %r13, 0x18(%r12)
movq %rax, 0x20(%r12)
movq %rax, 0x28(%r12)
movq %r13, 0x30(%r12)
movq %r12, %rax
addq $0x40, %rax
movl %r13d, 0x40(%r12)
movq %r13, 0x48(%r12)
movq %rax, 0x50(%r12)
movq %rax, 0x58(%r12)
movq %r13, 0x60(%r12)
movl %ebx, 0x68(%r12)
movb $0x0, 0x6c(%r12)
movl %r13d, 0x70(%r12)
movq %r12, 0x40(%rsp)
movl $0x78, %edi
callq 0x2150
movq %rax, %r15
addl $0x2, %ebx
movl %ebx, 0x14c(%r14)
movq %rbp, (%rax)
addq $0x10, %rax
movl %r13d, 0x10(%r15)
movq %r13, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r13, 0x30(%r15)
movq %r15, %rax
addq $0x40, %rax
movl %r13d, 0x40(%r15)
movq %r13, 0x48(%r15)
movq %rax, 0x50(%r15)
movq %rax, 0x58(%r15)
movq %r13, 0x60(%r15)
movl 0x34(%rsp), %eax
movl %eax, 0x68(%r15)
movb $0x0, 0x6c(%r15)
movl %r13d, 0x70(%r15)
movq %r15, 0x38(%rsp)
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x94d8
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x94d8
movq 0x18(%rsp), %rax
movq -0x8(%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x94d8
leaq 0x10(%rsp), %rdi
movq (%rdi), %rsi
leaq 0x40(%rsp), %rdx
callq 0x7aa0
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x54cd
movq %r15, (%rsi)
addq $0x8, 0x18(%rsp)
jmp 0x54dc
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x8bf2
addq $0x30, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x88e4
movb 0xf(%rsp), %bl
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5508
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5523
jmp 0x5523
jmp 0x5523
jmp 0x5523
jmp 0x5523
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x553d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::Move(char, std::set<RegExState*, std::less<RegExState*>, std::allocator<RegExState*>>, std::set<RegExState*, std::less<RegExState*>, std::allocator<RegExState*>>&)
void RegEx::Move(char chInput, std::set<RegExState*> NFAState, std::set<RegExState*> &Result) {

	Result.clear();
	StateIterator iter;
	for(iter = NFAState.begin(); iter != NFAState.end(); ++iter) {
		Table States;
		(*iter)->GetTransition(chInput, States);
		for(int index = 0; index < (int)States.size(); ++index){
			Result.insert(States[index]);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rcx, %rdi
callq 0x8f52
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x5ebc
movsbl %bpl, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%r15), %rdi
movl %ebp, %esi
movq %rsp, %rdx
callq 0x9552
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
subq %rsi, %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x5e90
xorl %r13d, %r13d
xorl %r12d, %r12d
addq %r13, %rsi
movq %rbx, %rdi
callq 0x9194
incq %r12
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
subq %rsi, %rax
shrq $0x3, %rax
cltq
addq $0x8, %r13
cmpq %rax, %r12
jl 0x5e67
testq %rsi, %rsi
je 0x5ea8
movq 0x10(%rsp), %rax
subq %rsi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2160
movq %r15, %rdi
callq 0x21c0
movq %rax, %r15
cmpq %r14, %rax
jne 0x5e2f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ecd
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5ee6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::Compile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool RegEx::Compile(std::string strRegEx) {

	while ( strRegEx.find( "[" ) != std::string::npos ) {
		strRegEx = PreProcessBracket(strRegEx);
	}

	m_InfixRegEx = const_cast<char*>(strRegEx.c_str());
	CleanUp();
	
	if(!ConstructThompsonNFA())
		return false;	

	PopTable( m_NFATable);
	m_NFATable[m_NFATable.size() - 1 ]->m_bAcceptingState = true;
	
	ConvertNFAtoDFA();
	MinimizeDFA();
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, (%rsp)
leaq 0x3cda(%rip), %rsi      # 0xa5e0
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2250
cmpq $-0x1, %rax
je 0x69ad
leaq 0x18(%rsp), %rbp
leaq 0x38(%rsp), %rbx
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r12
leaq 0x3ca6(%rip), %r13      # 0xa5e0
movq %rbp, 0x8(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x820c
movq %r12, %rdi
movq %r15, %rdx
callq 0x658e
movq %r14, %rdi
movq %r12, %rsi
callq 0x21d0
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x697e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6995
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movl $0x1, %ecx
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2250
cmpq $-0x1, %rax
jne 0x693a
movq (%r14), %rax
movq (%rsp), %rbx
movq %rax, 0x140(%rbx)
movq %rbx, %rdi
callq 0x4ec2
movq %rbx, %rdi
callq 0x6a1e
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x500e
movq 0x8(%rbx), %rax
movq -0x8(%rax), %rax
movb $0x1, 0x6c(%rax)
movq %rbx, %rdi
callq 0x5eee
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6a15
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::ConstructThompsonNFA()
bool RegEx::ConstructThompsonNFA() {
	CovertToPostfix();
	for(int i = 0; i < (int)m_PostStrRegEx.size(); ++i) {
		char curChar = m_PostStrRegEx[i];
		if ( IsInput( curChar )) {
			PushOnCharacterStack( curChar );
		} else if ( IsMetaChar( curChar ) ) {
			switch ( curChar ) {
				case CLOSURE:
					Closure();
					break;
				case PLUS_CLOSURE:
					ClosurePlus();
					break;
				case OPTIONAL:
					ClosureOptional();
					break;
				case OR:
					Or();
					break;
				case FALSE_CONCAT:
					Concatenate();
					break;
			}
		}		
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x140(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rdi)
movb (%rax), %al
movb %al, 0x148(%rdi)
callq 0x6c9c
cmpl $0x0, 0x128(%rbx)
jle 0x6adc
xorl %r14d, %r14d
movq 0x120(%rbx), %rax
movsbl (%rax,%r14), %ebp
movl %ebp, %esi
callq 0x4fd2
testb %al, %al
je 0x6a8d
movzbl %bpl, %eax
cmpl $0x2a, %eax
jle 0x6aaa
cmpl $0x2b, %eax
je 0x6abe
cmpl $0x3f, %eax
je 0x6ac8
cmpl $0x7c, %eax
jne 0x6a99
movq %rbx, %rdi
callq 0x596a
jmp 0x6a99
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x51a0
incq %r14
movslq 0x128(%rbx), %rax
cmpq %rax, %r14
jl 0x6a54
jmp 0x6adc
cmpl $0x26, %eax
je 0x6ad2
cmpl $0x2a, %eax
jne 0x6a99
movq %rbx, %rdi
callq 0x5750
jmp 0x6a99
movq %rbx, %rdi
callq 0x5546
jmp 0x6a99
movq %rbx, %rdi
callq 0x5348
jmp 0x6a99
movq %rbx, %rdi
callq 0x50ac
jmp 0x6a99
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::Match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool RegEx::Match(std::string strText) {
	m_strText = strText;
	RegExState *pState = m_DFATable[0];
	std::vector<RegExState*>  Transition;
	for(int i = 0; i < (int)m_strText.size(); ++i) {
		char CurrChar = m_strText[i];		
		pState->GetTransition(CurrChar, Transition);
		if ( Transition.empty())
			return false;
		pState = Transition[0];
		if ( pState->m_bAcceptingState )
			return true;
		
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x100(%rdi), %r14
movq %r14, %rdi
callq 0x20a0
movq 0x18(%rbx), %rax
movq (%rax), %rax
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x108(%rbx)
jle 0x6b63
xorl %r12d, %r12d
movq %rsp, %r15
movq (%r14), %rcx
movsbl (%rcx,%r12), %esi
movq %rax, %rdi
movq %r15, %rdx
callq 0x9552
movq (%rsp), %rdi
cmpq 0x8(%rsp), %rdi
je 0x6b67
movq (%rdi), %rax
movb 0x6c(%rax), %bpl
testb %bpl, %bpl
jne 0x6b6e
incq %r12
movslq 0x108(%rbx), %rcx
cmpq %rcx, %r12
jl 0x6b28
jmp 0x6b6e
xorl %ebp, %ebp
jmp 0x6b7b
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x6b7b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x6ba3
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::PreProcessLiterals()
int RegEx::PreProcessLiterals() {
  if (m_CurPreProcChar == '\0') 
	  return -1;
  if (m_CurPreProcChar == '\\') {
    m_CurPreProcChar = *(m_InfixRegEx++);
    if (m_CurPreProcChar == '\0') 
		return -1;
    m_PostStrRegEx += m_CurPreProcChar;
    m_CurPreProcChar = *(m_InfixRegEx++);
  } else if (strchr("()|*+?", m_CurPreProcChar) == NULL) { 
    if (m_CurPreProcChar == '&')
		m_PostStrRegEx += "\\&";
    else 
		m_PostStrRegEx += m_CurPreProcChar;

    m_CurPreProcChar = *(m_InfixRegEx++);
  } else if (m_CurPreProcChar == '(') {
    m_CurPreProcChar = *(m_InfixRegEx++);
    PreProcessOr();
    if (m_CurPreProcChar != ')') 
		return -1;
    m_CurPreProcChar = *(m_InfixRegEx++);
  } else
		return -1;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movzbl 0x148(%rdi), %r15d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %r15d, %r15d
je 0x6c8f
movq %rdi, %rbx
cmpl $0x5c, %r15d
jne 0x6c00
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
testb %al, %al
je 0x6c8f
leaq 0x120(%rbx), %rdi
movsbl %al, %esi
jmp 0x6c6e
movsbl %r15b, %r14d
leaq 0x39db(%rip), %rdi      # 0xa5e6
movl $0x7, %edx
movl %r14d, %esi
callq 0x2190
testq %rax, %rax
je 0x6c50
cmpb $0x28, %r15b
jne 0x6c8f
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
movq %rbx, %rdi
callq 0x6c9c
cmpb $0x29, 0x148(%rbx)
je 0x6c73
jmp 0x6c8f
leaq 0x120(%rbx), %rdi
cmpb $0x26, %r15b
jne 0x6c6b
leaq 0x3989(%rip), %rsi      # 0xa5ed
callq 0x2280
jmp 0x6c73
movl %r14d, %esi
callq 0x2130
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::PreProcessOr()
int RegEx::PreProcessOr() {
	PrePreprocessConcatenation();
	while (m_CurPreProcChar == '|') {
		m_CurPreProcChar = *(m_InfixRegEx++);
		PrePreprocessConcatenation();
		m_PostStrRegEx += "|";
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x6d72
cmpb $0x7c, 0x148(%rbx)
jne 0x6cf6
leaq 0x120(%rbx), %r14
leaq 0x3924(%rip), %r15      # 0xa5e4
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
movq %rbx, %rdi
callq 0x6d72
movq %r14, %rdi
movq %r15, %rsi
callq 0x2280
cmpb $0x7c, 0x148(%rbx)
je 0x6cc0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::PreProcessClosure()
int RegEx::PreProcessClosure() {
	PreProcessLiterals();
	while (m_CurPreProcChar != '\0' && strchr("*+?",m_CurPreProcChar) != NULL) {
		m_PostStrRegEx += m_CurPreProcChar;
		m_CurPreProcChar = *(m_InfixRegEx++);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6bac
movb 0x148(%rbx), %al
testb %al, %al
je 0x6d64
leaq 0x120(%rbx), %r14
leaq 0x38c4(%rip), %r15      # 0xa5e9
movsbl %al, %ebp
movl $0x4, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x2190
testq %rax, %rax
je 0x6d64
movq %r14, %rdi
movl %ebp, %esi
callq 0x2130
movq 0x140(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x140(%rbx)
movb (%rax), %al
movb %al, 0x148(%rbx)
testb %al, %al
jne 0x6d25
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regex.cpp
// Function: RegEx::PrePreprocessConcatenation()
int RegEx::PrePreprocessConcatenation(void) {
	PreProcessClosure();
	while (strchr(")|*+?", m_CurPreProcChar) == NULL) { 
		PreProcessClosure();
		m_PostStrRegEx += "&";
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6cfe
movsbl 0x148(%rbx), %esi
leaq 0x3857(%rip), %rdi      # 0xa5e7
movl $0x6, %edx
callq 0x2190
testq %rax, %rax
jne 0x6de0
leaq 0x120(%rbx), %r14
leaq 0x3841(%rip), %r15      # 0xa5ee
leaq 0x3833(%rip), %r12      # 0xa5e7
movq %rbx, %rdi
callq 0x6cfe
movq %r14, %rdi
movq %r15, %rsi
callq 0x2280
movsbl 0x148(%rbx), %esi
movl $0x6, %edx
movq %r12, %rdi
callq 0x2190
testq %rax, %rax
je 0x6db4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/davinash[P]regex/src/regexstate.cpp
// Function: RegExState::RegExState(std::set<RegExState*, std::less<RegExState*>, std::allocator<RegExState*>>, int)
RegExState::RegExState(std::set<RegExState*> NFAState, int nID) {
	m_NFAStates = NFAState;
	m_nStateID = nID;
	m_bAcceptingState = false;
	m_GroupID = 0;
	StateIterator iter;
	for(iter = NFAState.begin(); iter != NFAState.end(); ++iter) {
		if((*iter)->m_bAcceptingState) {
			m_bAcceptingState = true;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4a2a(%rip), %rax      # 0xdd90
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
leaq 0x10(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movq %rcx, 0x30(%rdi)
leaq 0x40(%rdi), %rax
movl %ecx, 0x40(%rdi)
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
movq %rcx, 0x60(%rdi)
movq %r15, %rdi
callq 0x7d44
movl %ebp, 0x68(%rbx)
movb $0x0, 0x6c(%rbx)
movl $0x0, 0x70(%rbx)
movq 0x18(%r14), %rax
addq $0x8, %r14
cmpq %r14, %rax
je 0x93d8
movq 0x20(%rax), %rcx
cmpb $0x1, 0x6c(%rcx)
jne 0x93ce
movb $0x1, 0x6c(%rbx)
movq %rax, %rdi
callq 0x21c0
jmp 0x93bb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x9764
movq %r15, %rdi
callq 0x81f8
movq %r14, %rdi
callq 0x2260