LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/lioncedric[P]cimpressGridCoverage/src/squares.cc
// Function: use_squares(int*, int, int*)
void use_squares(int * puzzle, const int width, int * squares) {
    for (int* ptrSquares = squares; *ptrSquares >= 0; ptrSquares += 3) {
        const int row = *(ptrSquares + 1);
        const int col = *ptrSquares;
        const int square_size = *(ptrSquares + 2);
        const int id = (row) * width + col;
        const int * ptrLineMax = puzzle + col + (row + square_size) * width;
        for (int* ptrLine = puzzle + col + (row) * width; ptrLine < ptrLineMax; ptrLine += width) {
            const int * ptrColMax = ptrLine + square_size;
            for (int* ptrCol = ptrLine; ptrCol < ptrColMax; ++ptrCol) {
                *ptrCol = id;
            }
        }
    }
}

// Assembly:
pushq %rbx
movslq %esi, %rax
movslq (%rdx), %r10
testq %r10, %r10
js 0x3582
movl 0x4(%rdx), %ecx
movslq 0x8(%rdx), %r8
leal (%r8,%rcx), %r9d
imull %esi, %ecx
leaq (%rdi,%r10,4), %r11
imull %esi, %r9d
movslq %r9d, %r9
leaq (%r11,%r9,4), %r9
movslq %ecx, %rbx
addl %r10d, %ecx
leaq (%r11,%rbx,4), %r10
cmpq %r9, %r10
jae 0x357c
leaq (%r10,%r8,4), %r11
movq %r10, %rbx
cmpq %r11, %rbx
jae 0x3576
movl %ecx, (%rbx)
addq $0x4, %rbx
jmp 0x3569
leaq (%r10,%rax,4), %r10
jmp 0x355d
addq $0xc, %rdx
jmp 0x352e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: remove_pending(int)
int remove_pending(int id) {
  std::lock_guard<std::mutex> guard(pending_lock);
  for (auto it = pending_requests.begin(); it != pending_requests.end(); it++) {
    if (*it == id) {
      pending_requests.erase(it);
      return 0;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
leaq 0x5d85(%rip), %rdi      # 0x82c0
callq 0x4bfc
movq 0x5d61(%rip), %rbx      # 0x82a8
movq 0x5d62(%rip), %r14      # 0x82b0
cmpq %r14, %rbx
je 0x256c
cmpl %ebp, (%rbx)
je 0x255d
addq $0x4, %rbx
jmp 0x254e
leaq 0x5d44(%rip), %rdi      # 0x82a8
movq %rbx, %rsi
callq 0x32bc
xorl %ebp, %ebp
cmpq %r14, %rbx
sete %bpl
negl %ebp
leaq 0x5d42(%rip), %rdi      # 0x82c0
callq 0x2190
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x5d2c(%rip), %rdi      # 0x82c0
callq 0x2190
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: read_osc(int, oscpkt::PacketReader*)
int read_osc(int fd, oscpkt::PacketReader* pr) {
  uint32_t size;
  char buff[1024*128];
  int bytes = read(fd, &size, sizeof(size));
  if (bytes == -EAGAIN) return 0;
  if (bytes < sizeof(size) || size >=1024*128)
    return -1;
  bytes = read(fd, &buff, size);
  pr->init(&buff, bytes);
  return bytes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x20018, %rsp          # imm = 0x20018
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc(%rsp), %rsi
pushq $0x4
popq %rdx
callq 0x22c0
xorl %r14d, %r14d
cmpl $-0xb, %eax
je 0x28cd
testl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
sete %cl
movl 0xc(%rsp), %eax
cmpl $0x20000, %eax          # imm = 0x20000
setae %dl
orb %cl, %dl
je 0x28ab
pushq $-0x1
popq %r14
jmp 0x28cd
movl %eax, %edx
leaq 0x10(%rsp), %r15
movl %ebp, %edi
movq %r15, %rsi
callq 0x22c0
movq %rax, %r14
movslq %r14d, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x35dc
movl %r14d, %eax
addq $0x20018, %rsp          # imm = 0x20018
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %edi, %ebp
leaq 0x28(%rsp), %r14
movq %r14, 0x8(%r14)
movq %r14, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
andl $0x0, 0x20(%r14)
leaq 0x10(%rsp), %r15
movl %ebp, %edi
movq %r14, %rsi
callq 0x2866
testl %eax, %eax
js 0x299f
cmpl $0x0, 0x48(%rsp)
jne 0x299f
movq 0x40(%rsp), %rbx
cmpq %r14, 0x28(%rsp)
sete %al
cmpq %r14, %rbx
sete %cl
orb %al, %cl
je 0x2991
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x290b
movq %rbx, 0x10(%rsp)
movl 0x78(%rbx), %eax
movl %eax, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
orl $-0x1, 0xc(%rsp)
movq %r15, %rdi
callq 0x362a
testb %al, %al
jne 0x29ba
cmpl $0x0, 0x48(%rsp)
setne %cl
movq 0x40(%rsp), %rax
cmpq %r14, 0x28(%rsp)
sete %dl
cmpq %r14, %rax
sete %sil
orb %dl, %sil
orb %cl, %sil
movl $0x0, %ebx
jne 0x293d
movq %rax, %rbx
movq (%rbx), %rax
movq %rax, 0x40(%rsp)
addq $0x10, %rbx
jmp 0x293d
leaq 0x28(%rsp), %rdi
callq 0x4058
pushq $-0x1
popq %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3638
leaq 0x2654(%rip), %rsi      # 0x5024
leaq 0x50(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x20c0
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
movq %rbx, %rsi
callq 0x3644
movl 0x78(%rsp), %ebp
leaq 0x50(%rsp), %rdi
callq 0x20f0
testl %ebp, %ebp
jne 0x2a0c
movl 0xc(%rsp), %edi
callq 0x252e
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x2a43
jmp 0x2a2e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x20f0
jmp 0x2a31
jmp 0x2a2e
jmp 0x2a2e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4058
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x14(%rsp), %r12
leaq 0x18(%rsp), %r13
xorl %ebx, %ebx
cmpl $-0x1, %ebx
je 0x30a4
movl %ebp, %edi
movq %r14, %rsi
leaq 0x222d(%rip), %rdx      # 0x5249
leaq 0x51ad(%rip), %rcx      # 0x81d0
movq %r12, %r8
callq 0x2310
movl %eax, %ebx
cmpl $0x53, %eax
je 0x3075
cmpl $0x65, %ebx
je 0x3048
cmpl $0x69, %ebx
je 0x306e
cmpl $0x76, %ebx
je 0x30a8
cmpl $0x68, %ebx
jne 0x3007
jmp 0x30af
movq 0x4f71(%rip), %rax      # 0x7fc0
movq (%rax), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x20c0
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x4d72
jmp 0x3097
movb $0x1, 0x38(%r15)
jmp 0x3007
movq 0x4f44(%rip), %rax      # 0x7fc0
movq (%rax), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x20c0
movq %r15, %rdi
movq %r13, %rsi
callq 0x2290
movq %r13, %rdi
callq 0x20f0
jmp 0x3007
xorl %eax, %eax
jmp 0x30ba
callq 0x31b8
jmp 0x30b7
movq (%r14), %rdi
callq 0x31ee
pushq $0xa
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movq %rdx, %r14
movl %esi, %ebx
movl %edi, %ebp
movl $0x400, %edi            # imm = 0x400
callq 0x2030
movq %rax, %r15
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
movq %rax, %rsi
callq 0x2080
leaq 0x400(%r15), %r14
xorl %eax, %eax
cmpq $0x400, %rax            # imm = 0x400
je 0x3132
leaq 0x1(%rax), %rcx
cmpb $0x20, (%r15,%rax)
movq %rcx, %rax
je 0x3115
leaq (%r15,%rcx), %r14
decq %r14
leaq 0x2118(%rip), %rsi      # 0x5251
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x2110
testl %eax, %eax
je 0x318c
leaq 0x1f77(%rip), %rsi      # 0x50c6
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x20c0
leaq 0x1f67(%rip), %rsi      # 0x50cc
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x20c0
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movl %ebp, %edi
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x25a1
movq %r15, %rdi
callq 0x22a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
jmp 0x31a6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
callq 0x31b8
movq 0x4dcc(%rip), %rbx      # 0x7fd0
leaq 0x1efc(%rip), %rsi      # 0x5107
movq %rbx, %rdi
callq 0x2230
leaq 0x1ef5(%rip), %rsi      # 0x510f
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
movq %r14, %rsi
callq 0x2230
leaq 0x1edd(%rip), %rsi      # 0x5111
movq %rax, %rdi
callq 0x2230
leaq 0x1fda(%rip), %rsi      # 0x521d
movq %rbx, %rdi
callq 0x2230
leaq 0x1ecb(%rip), %rsi      # 0x511d
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
leaq 0x8(%rsp), %rdi
callq 0x20f0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O2/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 0x394c
leaq 0x8(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2140
movq %r15, (%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x3417
movq (%r14), %rax
cmpb $0x2f, (%rax)
je 0x3424
cmpl $0x0, 0x78(%rbx)
jne 0x3424
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_O2/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 0x34f0
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rdi
pushq $0x73
popq %rsi
callq 0x21e0
leaq 0x48(%rbx), %rdi
leaq 0x60(%rbx), %r15
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
movq 0x8(%r14), %rcx
incq %rcx
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rcx, 0x8(%rsi)
callq 0x3c0e
movq 0x8(%r14), %rsi
incq %rsi
movq %r15, %rdi
callq 0x3b90
movq (%r14), %rsi
movq %rax, %rdi
callq 0x2220
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1dfa(%rip), %rdi      # 0x52f1
leaq 0x1db3(%rip), %rsi      # 0x52b1
leaq 0x1e02(%rip), %rcx      # 0x5307
movl $0x193, %edx            # imm = 0x193
callq 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3563
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x356a
cmpl $0x0, 0x30(%rbx)
jne 0x357e
movl $0xa, 0x30(%rbx)
jmp 0x357e
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
leaq 0x18(%rbx), %rsi
xorl %edx, %edx
cmpq %rax, %rcx
setne %dl
movq %r14, %rdi
callq 0x3d74
movl 0x78(%r14), %eax
testl %eax, %eax
je 0x358f
cmpl $0x0, 0x30(%rbx)
jne 0x358f
movl %eax, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x20(%rdi)
callq 0x3f00
testb $0x3, %r14b
je 0x3608
cmpl $0x0, 0x20(%rbx)
jne 0x361c
movl $0x9, 0x20(%rbx)
jmp 0x361c
addq %r15, %r14
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3f18
movq (%rbx), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21e0
leaq 0x48(%rbx), %rdi
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
leaq 0x60(%rbx), %r14
movq %rsp, %rsi
movq %rax, (%rsi)
movq $0x4, 0x8(%rsi)
callq 0x3c0e
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x3b90
movl %ebp, %edi
movq %rax, %rsi
callq 0x3b6a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: void oscpkt::pod2bytes<int>(int, char*)
void pod2bytes(const POD value, char *bytes) {
  PodBytes<POD> p; p.value = value; 
  for (size_t i=0; i < sizeof(POD); ++i) {
    if (isBigEndian()) 
      bytes[i] = p.bytes[i];
    else
      bytes[i] = p.bytes[sizeof(POD) - i - 1];
  }
}

// Assembly:
movl %edi, -0x4(%rsp)
movabsq $0x4, %rcx
movq %rcx, %rax
subq $0x1, %rax
jb 0x3b8f
movb -0x5(%rsp,%rcx), %cl
movb %cl, (%rsi)
incq %rsi
movq %rax, %rcx
jmp 0x3b7b
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpq %rdx, %rsi
ja 0x401a
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jne 0x401a
movq %rdx, %r14
movq %rsi, %r15
subq %rsi, %rdx
testb $0x3, %dl
jne 0x4023
cmpq %r14, %r15
je 0x4008
cmpb $0x23, (%r15)
jne 0x3fcc
pushq $0x8
popq %rbp
cmpq $0x14, %rdx
jl 0x4005
movabsq $0x656c646e756223, %rax # imm = 0x656C646E756223
cmpq %rax, (%r15)
jne 0x4005
leaq 0x8(%r15), %rdi
callq 0x408c
movq %rax, %r12
addq $0x10, %r15
movq %r15, %rdi
callq 0x40ac
testb $0x3, %al
jne 0x3fff
addq $0x4, %r15
movl %eax, %r13d
addq %r15, %r13
cmpq %r14, %r13
ja 0x3fff
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x3f18
cmpl $0x0, 0x20(%rbx)
jne 0x4008
movq %r13, %r15
cmpq %r14, %r13
jne 0x3f90
jmp 0x4008
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x40d8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40cc
leaq 0x8(%rsp), %rdi
callq 0x359a
movq 0x8(%rbx), %rax
movl 0x88(%rax), %ebp
testl %ebp, %ebp
je 0x4008
cmpl $0x0, 0x20(%rbx)
jne 0x4008
movl %ebp, 0x20(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x131f(%rip), %rdi      # 0x5340
jmp 0x402a
leaq 0x136f(%rip), %rdi      # 0x5399
leaq 0x1280(%rip), %rsi      # 0x52b1
leaq 0x131b(%rip), %rcx      # 0x5353
movl $0x216, %edx            # imm = 0x216
callq 0x2170
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x359a
movq %rbx, %rdi
callq 0x2340
nop
// File: /workspace/github_cpp_makefile_star2_O2/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: unsigned long oscpkt::bytes2pod<unsigned long>(char const*)
POD bytes2pod(const char *bytes) {
  PodBytes<POD> p; 
  for (size_t i=0; i < sizeof(POD); ++i) {
    if (isBigEndian()) 
      p.bytes[i] = bytes[i];
    else
      p.bytes[i] = bytes[sizeof(POD) - i - 1];
  }
  return p.value;
}

// Assembly:
addq $0x7, %rdi
xorl %eax, %eax
cmpq $0x8, %rax
je 0x40a6
movb (%rdi), %cl
movb %cl, -0x8(%rsp,%rax)
incq %rax
decq %rdi
jmp 0x4092
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::isZeroPaddingCorrect(char const*)
inline bool isZeroPaddingCorrect(const char *p) {
  const char *q = ceil4(p);
  for (;p < q; ++p)
    if (*p != 0) { return false; }
  return true;
}

// Assembly:
leaq 0x3(%rdi), %rax
andq $-0x4, %rax
movq %rdi, %rcx
cmpq %rax, %rdi
jae 0x4529
leaq 0x1(%rcx), %rdi
cmpb $0x0, (%rcx)
je 0x4518
cmpq %rax, %rcx
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x78(%rdi)
je 0x456c
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rdi, %rbx
movq 0x60(%rdi), %r13
movq 0x68(%rdi), %rbp
xorl %ecx, %ecx
movq %rbp, %r12
subq %r13, %r12
cmovneq %r13, %rcx
cmpq %rdx, %rcx
ja 0x468d
addq %r12, %rcx
movq %rcx, %rdx
subq %r14, %rdx
jb 0x468d
pushq $0x4
popq %rax
leal -0x62(%rsi), %edi
pushq $0x3
popq %r8
cmpl $0x7, %edi
ja 0x45c1
leaq 0xa50(%rip), %rdx       # 0x5004
movslq (%rdx,%rdi,4), %rsi
addq %rdx, %rsi
jmpq *%rsi
pushq $0x8
jmp 0x45fa
xorl %r15d, %r15d
cmpl $0x46, %esi
je 0x45fc
cmpl $0x54, %esi
je 0x45fc
cmpl $0x73, %esi
jne 0x4672
movq %r14, %rdi
xorl %esi, %esi
callq 0x2260
testq %rax, %rax
je 0x467a
movq %rax, %r15
subq %r14, %r15
incq %r15
jmp 0x4684
pushq $0x4
popq %r15
xorl %eax, %eax
cmpq %r13, %rbp
cmovneq %r13, %rax
testq %r15, %r15
js 0x4636
addq %r15, %r14
addq %r12, %rax
cmpq %rax, %r14
ja 0x4636
movl %r8d, %ebp
movq %r14, %rdi
callq 0x4510
testb %al, %al
jne 0x455a
cmpl $0x0, 0x78(%rbx)
movl %ebp, %eax
jne 0x4557
jmp 0x4672
cmpl $0x0, 0x78(%rbx)
movl %r8d, %eax
jne 0x4557
jmp 0x4672
cmpq %r14, %rcx
je 0x466f
movq %r14, %rdi
movl %r8d, %ebp
callq 0x40ac
movl %ebp, %r8d
movl %eax, %r15d
addl $0x4, %r15d
movq 0x60(%rbx), %r13
movq 0x68(%rbx), %rbp
movq %rbp, %r12
subq %r13, %r12
jmp 0x45fc
movl %r8d, %eax
movl %eax, 0x78(%rbx)
jmp 0x4557
movl $0x3, 0x78(%rbx)
xorl %r15d, %r15d
pushq $0x3
popq %r8
jmp 0x45fc
leaq 0xd99(%rip), %rdi       # 0x542d
leaq 0xc16(%rip), %rsi       # 0x52b1
leaq 0xdb6(%rip), %rcx       # 0x5458
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
callq 0x4838
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x482b
movq 0x10(%r14), %rsi
movq %r14, %rdi
callq 0x48b4
movq %rax, %rdi
callq 0x4895
incq 0x10(%r14)
movl %eax, (%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3549
movq %rbx, %rdi
movl %esi, %r14d
callq 0x355a
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x3594
movq 0x18(%rbx), %rcx
movslq %ebp, %rax
movq 0x38(%rbx), %r15
movslq %r14d, %r12
imulq $0xc, %rax, %rax
leal 0x1(%r12), %r14d
leaq 0x8(%rcx,%rax), %rax
movl (%rax), %esi
movl %esi, (%r15,%r12,4)
cmpl %ebp, %esi
je 0x3537
movq %rbx, %rdi
callq 0x35e4
movq %rbx, %rdi
movl %r14d, %esi
callq 0x34b0
movl (%r15,%r12,4), %esi
movq %rbx, %rdi
callq 0x35ec
movslq (%r15,%r12,4), %rax
movq 0x18(%rbx), %rcx
imulq $0xc, %rax, %rax
leaq 0x8(%rcx,%rax), %rax
jmp 0x34fb
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x35f4
incq 0x90(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
leal 0x1(%rbx), %ebp
movq %rsp, %r15
movq %rdi, %r14
movq %rdx, (%r15)
cmpl %ebx, %ebp
je 0x3684
movq 0x18(%r14), %rax
movslq %ebp, %rcx
imulq $0xc, %rcx, %rcx
cmpl $0x0, (%rax,%rcx)
jle 0x367c
movq %r15, %rdi
movl %ebp, %esi
callq 0x3690
incl %ebp
jmp 0x3659
addq %rcx, %rax
movl 0x4(%rax), %ebp
jmp 0x3659
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_refactor.cc
// Function: ExactCover::hide(int)::'lambda'(int)::operator()(int) const
void hide(int p) {
    option_right(p, [&](int q) {
      auto x = nodes[q].top;
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      nodes[u].dlink = d;
      nodes[d].ulink = u;
      nodes[x].top--;
    });
  }

// Assembly:
movq (%rdi), %rax
movslq %esi, %rcx
imulq $0xc, %rcx, %rcx
movq 0x18(%rax), %rax
movslq 0x4(%rax,%rcx), %rsi
movslq (%rax,%rcx), %rdx
movslq 0x8(%rax,%rcx), %rcx
imulq $0xc, %rsi, %rdi
movl %ecx, 0x8(%rax,%rdi)
imulq $0xc, %rcx, %rcx
movl %esi, 0x4(%rax,%rcx)
imulq $0xc, %rdx, %rcx
decl (%rax,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_refactor.cc
// Function: void ExactCover::option_left<ExactCover::rewind_option(int)::'lambda'(int)>(int, ExactCover::rewind_option(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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
leal -0x1(%rbx), %ebp
movq %rsp, %r15
movq %rdi, %r14
movq %rdx, (%r15)
cmpl %ebx, %ebp
je 0x3766
movq 0x18(%r14), %rax
movslq %ebp, %rcx
imulq $0xc, %rcx, %rcx
cmpl $0x0, (%rax,%rcx)
jle 0x375e
movq %r15, %rdi
movl %ebp, %esi
callq 0x3772
decl %ebp
jmp 0x373b
addq %rcx, %rax
movl 0x8(%rax), %ebp
jmp 0x373b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ricbit[P]dlx/cover_refactor.cc
// Function: ExactCover::unhide(int)::'lambda'(int)::operator()(int) const
void unhide(int p) {
    option_left(p, [&](int q) {
      auto x = nodes[q].top;
      auto u = nodes[q].ulink;
      auto d = nodes[q].dlink;
      nodes[u].dlink = q;
      nodes[d].ulink = q;
      nodes[x].top++;
    });
  }

// Assembly:
movq (%rdi), %rax
movslq %esi, %rcx
imulq $0xc, %rcx, %rdx
movq 0x18(%rax), %rax
movslq 0x4(%rax,%rdx), %rdi
movslq (%rax,%rdx), %rsi
movslq 0x8(%rax,%rdx), %rdx
imulq $0xc, %rdi, %rdi
imulq $0xc, %rdx, %rdx
movl %ecx, 0x8(%rax,%rdi)
movl %ecx, 0x4(%rax,%rdx)
imulq $0xc, %rsi, %rcx
incl (%rax,%rcx)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r14d, %r14d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jge 0x417b
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4176
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
jmp 0x414e
cmpq %rax, %rcx
je 0x4184
movq %rax, 0x8(%rbx)
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jge 0x41b5
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x41b0
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
jmp 0x4187
cmpq %rax, %rcx
je 0x41be
movq %rax, 0x20(%rbx)
andl $0x0, 0x14c(%rbx)
leaq 0x30(%rbx), %r14
movq 0x60(%rbx), %rax
cmpq 0x40(%rbx), %rax
je 0x41dd
movq %r14, %rdi
callq 0x6a3a
jmp 0x41c9
leaq 0x80(%rbx), %r14
movq 0xb0(%rbx), %rax
cmpq 0x90(%rbx), %rax
je 0x41fe
movq %r14, %rdi
callq 0x6a9a
jmp 0x41e4
addq $0xd0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6aee
// File: /workspace/github_cpp_makefile_star2_O2/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 0x422e
movl %esi, %ecx
movabsq $-0x7ffff0c000000000, %rdx # imm = 0x80000F4000000000
btq %rcx, %rdx
jae 0x422e
retq
cmpl $0x7c, %esi
je 0x422d
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
leaq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x6b1c
movq %rax, %r14
testq %rax, %rax
je 0x42a0
movq 0x60(%r12), %rsi
cmpq 0x68(%r12), %rsi
jne 0x428c
movq 0x78(%r12), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq %r15, %rdi
callq 0x5c6c
movq %rbx, %rdi
callq 0x6a3a
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
andq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x4250
testb %al, %al
je 0x4330
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4250
testb %al, %al
je 0x4330
movq 0x8(%rsp), %rax
movq -0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
pushq $-0x1
popq %rsi
callq 0x7aa6
movq %rsp, %rdi
movq 0x8(%rdi), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x5d36
addq $0x30, %rbx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6dd0
jmp 0x4332
xorl %ebp, %ebp
leaq 0x20(%rsp), %rdi
callq 0x6a06
movq %rsp, %rdi
callq 0x6a06
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x4351
jmp 0x4351
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6a06
movq %rsp, %rdi
callq 0x6a06
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movb %bpl, 0x7(%rsp)
pushq $0x78
popq %r14
movq %r14, %rdi
callq 0x2180
movq %rax, %r15
movl 0x14c(%rbx), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x14c(%rbx)
movq %r15, %rdi
callq 0x5d56
leaq 0x28(%rsp), %r12
movq %r15, (%r12)
movq %r14, %rdi
callq 0x2180
movq %rax, %r14
movl 0x14c(%rbx), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x14c(%rbx)
movq %r14, %rdi
callq 0x5d56
movq %r14, 0x8(%rsp)
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x7aa6
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %r12, %rsi
callq 0x5da4
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5da4
leaq 0x30(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6dd0
addq $0xd0, %rbx
leaq 0x7(%rsp), %rsi
movq %rbx, %rdi
callq 0x7136
leaq 0x10(%rsp), %rdi
callq 0x6a06
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a06
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x4250
movl %eax, %ebx
testb %al, %al
je 0x4539
pushq $0x78
popq %rdi
callq 0x2180
movq %rax, %r15
movl 0x14c(%r14), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x14c(%r14)
movq %r15, %rdi
callq 0x5d56
movq %r15, 0x20(%rsp)
pushq $0x78
popq %rdi
callq 0x2180
movq %rax, %r12
movl 0x14c(%r14), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x14c(%r14)
movq %r12, %rdi
callq 0x5d56
movq %r12, 0x18(%rsp)
pushq $-0x1
popq %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x7aa6
movq (%rsp), %rax
movq (%rax), %rdx
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x7aa6
movq 0x8(%rsp), %rax
movq -0x8(%rax), %rdi
pushq $-0x1
popq %rsi
movq %r12, %rdx
callq 0x7aa6
movq %rsp, %rdi
movq (%rdi), %rsi
leaq 0x20(%rsp), %rdx
callq 0x5dc2
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x5da4
addq $0x30, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6dd0
movq %rsp, %rdi
callq 0x6a06
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4559
jmp 0x4559
jmp 0x4559
jmp 0x4559
jmp 0x4559
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a06
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regex.cpp
// Function: RegEx::Or()
bool RegEx::Or() {

	Table  UpperTable, LowerTable;

	if(!PopTable(LowerTable) || !PopTable(UpperTable))
		return false;

	RegExState *LeftTable	= new RegExState(m_nNextStateID++);
	RegExState *RightTable	= new RegExState(m_nNextStateID++);
	
	LeftTable->AddTransition(EPSILON, ((*(UpperTable.begin()))));
	LeftTable->AddTransition(EPSILON, ((*(LowerTable.begin()))));
	((*(UpperTable.rbegin())))->AddTransition(EPSILON, RightTable);
	((*(LowerTable.rbegin())))->AddTransition(EPSILON, RightTable);

	LowerTable.push_back(RightTable);
	UpperTable.insert(UpperTable.begin(),LeftTable);
	UpperTable.insert(UpperTable.end(), LowerTable.begin(), LowerTable.end());

	m_CharacterClassStack.push(UpperTable);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0x4250
testb %al, %al
je 0x48db
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x4250
testb %al, %al
je 0x48db
pushq $0x78
popq %rdi
callq 0x2180
movq %rax, %r15
movl 0x14c(%rbx), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x14c(%rbx)
movq %r15, %rdi
callq 0x5d56
movq %r15, 0x48(%rsp)
pushq $0x78
popq %rdi
callq 0x2180
movq %rax, %r14
movl 0x14c(%rbx), %esi
leal 0x1(%rsi), %eax
movl %eax, 0x14c(%rbx)
movq %r14, %rdi
callq 0x5d56
movq %r14, 0x40(%rsp)
movq (%rsp), %rax
movq (%rax), %rdx
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x7aa6
movq 0x20(%rsp), %rax
movq (%rax), %rdx
pushq $-0x1
popq %rsi
movq %r15, %rdi
callq 0x7aa6
movq 0x8(%rsp), %rax
movq -0x8(%rax), %rdi
pushq $-0x1
popq %rsi
movq %r14, %rdx
callq 0x7aa6
movq 0x28(%rsp), %rax
movq -0x8(%rax), %rdi
pushq $-0x1
popq %rsi
movq %r14, %rdx
callq 0x7aa6
leaq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5da4
movq %rsp, %rdi
movq (%rdi), %rsi
leaq 0x48(%rsp), %rdx
callq 0x5dc2
movq %rsp, %rdi
movq 0x8(%rdi), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x5d36
addq $0x30, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6dd0
movb $0x1, %bl
jmp 0x48dd
xorl %ebx, %ebx
leaq 0x20(%rsp), %rdi
callq 0x6a06
movq %rsp, %rdi
callq 0x6a06
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x490b
jmp 0x490b
jmp 0x490b
jmp 0x490b
jmp 0x490b
jmp 0x490b
jmp 0x490b
jmp 0x490b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6a06
movq %rsp, %rdi
callq 0x6a06
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regex.cpp
// Function: RegEx::EpsilonClosure(std::set<RegExState*, std::less<RegExState*>, std::allocator<RegExState*>>, std::set<RegExState*, std::less<RegExState*>, std::allocator<RegExState*>>&)
void RegEx::EpsilonClosure(std::set<RegExState*> startSet, std::set<RegExState*> &result) {
	std::stack<RegExState*> UnVisitedStates;	
	result.clear();	
	result = startSet; 
	StateIterator iter;
	for(iter = startSet.begin(); iter != startSet.end(); ++iter) {
		UnVisitedStates.push(*iter);
	}

	while(!UnVisitedStates.empty()) {
		RegExState* curState = UnVisitedStates.top();
		UnVisitedStates.pop();

		Table epsilonStates;
		curState->GetTransition(EPSILON, epsilonStates);

		TableIterator epsilonItr;

		for ( epsilonItr = epsilonStates.begin(); epsilonItr != epsilonStates.end(); ++epsilonItr ){
			if(result.find((*epsilonItr)) == result.end()) {
				result.insert((*epsilonItr));
				UnVisitedStates.push((*epsilonItr));
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x18(%rsp), %rdi
callq 0x5e2c
movq %rbx, %rdi
callq 0x7480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x612e
movq 0x18(%r14), %r12
addq $0x8, %r14
leaq 0x18(%rsp), %r15
cmpq %r14, %r12
je 0x4985
leaq 0x20(%r12), %rsi
movq %r15, %rdi
callq 0x74ae
movq %r12, %rdi
callq 0x21d0
movq %rax, %r12
jmp 0x4966
leaq 0x8(%rbx), %r13
leaq 0x18(%rsp), %r14
pushq $-0x1
popq %rbp
movq %rsp, %r15
movq 0x48(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x4a26
cmpq 0x50(%rsp), %rax
jne 0x49bc
movq 0x60(%rsp), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
movq -0x8(%rax), %r12
movq %r14, %rdi
callq 0x76e2
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x7b1e
movq (%rsp), %r12
cmpq 0x8(%rsp), %r12
je 0x4a19
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7738
cmpq %r13, %rax
jne 0x4a13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x778e
movq %r14, %rdi
movq %r12, %rsi
callq 0x74ae
addq $0x8, %r12
jmp 0x49e6
movq %r15, %rdi
callq 0x6a06
jmp 0x4994
leaq 0x18(%rsp), %rdi
callq 0x6458
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4a43
jmp 0x4a4a
movq %rax, %rbx
jmp 0x4a55
jmp 0x4a4a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a06
leaq 0x18(%rsp), %rdi
callq 0x6458
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rcx, %rdi
callq 0x7480
movq 0x18(%r14), %r15
addq $0x8, %r14
movsbl %bpl, %eax
movl %eax, 0xc(%rsp)
leaq 0x10(%rsp), %r12
cmpq %r14, %r15
je 0x4b0b
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
movq 0x20(%r15), %rdi
movl 0xc(%rsp), %esi
movq %r12, %rbp
movq %r12, %rdx
callq 0x7b1e
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
subq %rsi, %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r12
jge 0x4af3
addq %r13, %rsi
movq %rbx, %rdi
callq 0x778e
incq %r12
addq $0x8, %r13
jmp 0x4ac7
movq %rbp, %r12
movq %rbp, %rdi
callq 0x6a06
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
jmp 0x4a9b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4b1c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6a06
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/davinash[P]regex/src/regex.cpp
// Function: RegEx::ReduceDFA()
void RegEx::ReduceDFA() {
	std::set<RegExState*> DeadEndSet;
	for(int i = 0; i < (int)m_DFATable.size(); ++i) {
		if(m_DFATable[i]->IsDeadEnd()) {
			DeadEndSet.insert(m_DFATable[i]);
		}
	}
	if(DeadEndSet.empty())
		return;
	StateIterator iter;
	for(iter = DeadEndSet.begin(); iter != DeadEndSet.end(); ++iter) {
		for(int i = 0; i < (int)m_DFATable.size(); ++i)
			m_DFATable[i]->RemoveTransition(*iter);

		TableIterator pos;
		for(pos = m_DFATable.begin(); pos != m_DFATable.end(); ++pos) {
			if(*pos == *iter) {
				break;
			}
		}
		m_DFATable.erase(pos);
		delete *iter;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
andl $0x0, (%r12)
andq $0x0, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
andq $0x0, 0x20(%r12)
leaq 0x18(%rdi), %r14
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jge 0x500c
movq (%rax,%r13), %rdi
callq 0x7ba4
testb %al, %al
je 0x5003
movq (%r14), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x778e
incq %rbp
addq $0x8, %r13
jmp 0x4fd1
cmpq $0x0, 0x30(%rsp)
je 0x5083
movq 0x20(%rsp), %r15
cmpq %r12, %r15
je 0x5083
xorl %r13d, %r13d
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rax
movq %rax, %rcx
subq %rsi, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0x5051
movq (%rsi,%r13,8), %rdi
movq 0x20(%r15), %rsi
callq 0x7ac8
incq %r13
jmp 0x5021
addq $0x8, %rsi
cmpq %rax, %rsi
je 0x505f
movq (%rsi), %rcx
cmpq 0x20(%r15), %rcx
jne 0x504d
movq %r14, %rdi
callq 0x5e48
movq 0x20(%r15), %rdi
testq %rdi, %rdi
je 0x5076
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x21d0
movq %rax, %r15
jmp 0x5019
leaq 0x8(%rsp), %rdi
callq 0x6634
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50a0
jmp 0x50a0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6634
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x42ca(%rip), %r15      # 0x95e0
movq %rsp, %r12
leaq 0x20(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x22d0
cmpq $-0x1, %rax
je 0x5364
movq %r12, %rdi
movq %r14, %rsi
callq 0x2210
movq %r13, %rdi
movq %r12, %rdx
callq 0x50b8
movq %r14, %rdi
movq %r13, %rsi
callq 0x21f0
movq %r13, %rdi
callq 0x2090
movq %r12, %rdi
callq 0x2090
jmp 0x531e
movq (%r14), %rax
movq %rax, 0x140(%rbx)
movq %rbx, %rdi
callq 0x4144
movq %rbx, %rdi
callq 0x53c0
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x4250
movq 0x8(%rbx), %rax
movq -0x8(%rax), %rax
movb $0x1, 0x6c(%rax)
movq %rbx, %rdi
callq 0x4b32
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x5722
xorl %r14d, %r14d
movslq 0x128(%rbx), %rax
cmpq %rax, %r14
jge 0x5466
movq 0x120(%rbx), %rax
movsbl (%rax,%r14), %ebp
movl %ebp, %esi
callq 0x4236
testb %al, %al
je 0x5404
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x436e
jmp 0x545e
movsbl %bpl, %esi
callq 0x4214
testb %al, %al
je 0x545e
movzbl %bpl, %eax
cmpl $0x26, %eax
je 0x5456
cmpl $0x7c, %eax
je 0x5438
cmpl $0x2b, %eax
je 0x544c
cmpl $0x3f, %eax
je 0x5442
cmpl $0x2a, %eax
jne 0x545e
movq %rbx, %rdi
callq 0x4688
jmp 0x545e
movq %rbx, %rdi
callq 0x47b2
jmp 0x545e
movq %rbx, %rdi
callq 0x445c
jmp 0x545e
movq %rbx, %rdi
callq 0x456c
jmp 0x545e
movq %rbx, %rdi
callq 0x42b2
incq %r14
jmp 0x53cf
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
nop