LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/wo3kie[P]calc/calc.cpp
// Function: void error_handler_::operator()<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(boost::spirit::info const&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>) const
void operator()(
        qi::info const & what
      , TIterator err_pos, TIterator last ) const
    {
        std::cout
            << "Error! Expecting "
            << what
            << " here: \""
            << std::string( err_pos, last )
            << "\""
            << std::endl
        ;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0xbd41(%rip), %rbx      # 0x1dfc8
leaq 0x2017(%rip), %rsi      # 0x142a5
movl $0x11, %edx
movq %rbx, %rdi
callq 0x3260
leaq 0x28(%rsp), %rax
movq %rbx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r12, 0x8(%rsi)
movl $0x0, 0x10(%rsi)
addq $0x20, %r12
movq %r12, %rdi
callq 0x12388
leaq 0x1fee(%rip), %rsi      # 0x142b7
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3260
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12dec
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x3260
movq %rax, %rbx
leaq 0x1fb1(%rip), %rsi      # 0x142be
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x12358
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x12380
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/wo3kie[P]calc/calc.cpp
// Function: ast::Calc::operator()(ast::Signed const&) const
double operator()( Signed const & x ) const
        {
            double const rhs = boost::apply_visitor( *this, x.operand_ );

            switch( x.sign_ )
            {
                case '-':
                    return - rhs;

                case '+':
                    return + rhs;

                case '!':
                    return ( fabs( rhs ) < 0.000001 ) ? 1 : 0;

                default:
                    BOOST_ASSERT( 0 );
            }
        }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rbx), %rdi
callq 0x12a96
movzbl (%rbx), %eax
cmpl $0x21, %eax
je 0x12b60
cmpl $0x2b, %eax
je 0x12b7d
cmpl $0x2d, %eax
jne 0x12b7f
xorpd 0x552(%rip), %xmm0      # 0x130b0
jmp 0x12b7d
andpd 0x538(%rip), %xmm0      # 0x130a0
cmpltsd 0x4ef(%rip), %xmm0      # 0x13060
movsd 0x4bf(%rip), %xmm1      # 0x13038
andpd %xmm1, %xmm0
popq %rbx
retq
leaq 0xe3d(%rip), %rdi       # 0x139c3
leaq 0xb0a(%rip), %rsi       # 0x13697
leaq 0x1754(%rip), %rcx      # 0x142e8
movl $0xf3, %edx
callq 0x3140
// File: /workspace/github_cpp_makefile_star2_O1/lioncedric[P]cimpressGridCoverage/src/squares.cc
// Function: clear_square(int*, int, int const*)
void clear_square(int * puzzle, const int width, const int * square) {

    const int row = *(square + 1);
    const int col = *square;
    const int square_size = *(square + 2);
    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 = 1;
        }
    }

}

// Assembly:
movl 0x4(%rdx), %r8d
movslq 0x8(%rdx), %rax
leal (%rax,%r8), %r9d
imull %esi, %r9d
imull %esi, %r8d
cmpl %r9d, %r8d
jge 0x39f2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rdx), %r11
leaq (%rdi,%r11,4), %rcx
movslq %r9d, %rdx
leaq (%rcx,%rdx,4), %rdx
movslq %r8d, %r10
leaq (%rcx,%r10,4), %r8
movslq %esi, %rsi
leaq (%rcx,%rax,4), %r9
leaq (,%r10,4), %r14
leaq (%r9,%r10,4), %r9
shlq $0x2, %rsi
leaq (%rcx,%r10,4), %r10
addq $0x4, %r10
notq %rdi
leaq (%r14,%r11,4), %r11
subq %r11, %rdi
movq %rsi, %r11
negq %r11
leaq (%r8,%rax,4), %rbx
notq %rcx
subq %r14, %rcx
xorl %r14d, %r14d
movdqa 0x1802(%rip), %xmm0     # 0x50a0
movdqa 0x180a(%rip), %xmm1     # 0x50b0
movdqa 0x1812(%rip), %xmm2     # 0x50c0
pcmpeqd %xmm3, %xmm3
movq %r10, %r15
cmpq %r15, %rbx
movq %r15, %r12
cmovaq %rbx, %r12
testl %eax, %eax
jle 0x39d0
addq %rcx, %r12
shrq $0x2, %r12
addq $0x4, %r12
andq $-0x4, %r12
movq %rsi, %r13
imulq %r14, %r13
leaq (%r9,%r13), %rbp
addq %r10, %r13
cmpq %r13, %rbp
cmovaq %rbp, %r13
movq %r11, %rbp
imulq %r14, %rbp
addq %rdi, %rbp
addq %r13, %rbp
movq %rbp, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
psrlq $0x2, %xmm4
pxor %xmm2, %xmm4
xorl %r13d, %r13d
movq %r13, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm1, %xmm6
pxor %xmm2, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm4, %xmm7
pcmpeqd %xmm4, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %ebp
notl %ebp
testb $0x1, %bpl
je 0x3959
movl $0x1, (%r8,%r13,4)
pxor %xmm3, %xmm6
pextrw $0x4, %xmm6, %ebp
testb $0x1, %bpl
je 0x3971
movl $0x1, 0x4(%r8,%r13,4)
por %xmm0, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm4, %xmm6
pcmpeqd %xmm4, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm3, %xmm5
pextrw $0x0, %xmm5, %ebp
testb $0x1, %bpl
je 0x39af
movl $0x1, 0x8(%r8,%r13,4)
pextrw $0x4, %xmm5, %ebp
testb $0x1, %bpl
je 0x39c3
movl $0x1, 0xc(%r8,%r13,4)
addq $0x4, %r13
cmpq %r13, %r12
jne 0x390e
addq %rsi, %r8
incq %r14
addq %rsi, %rbx
addq %rsi, %r15
subq %rsi, %rcx
cmpq %rdx, %r8
jb 0x38b5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movl %edi, %ebx
leaq 0x6cf9(%rip), %rdi      # 0x92d0
callq 0x22c0
testl %eax, %eax
jne 0x264e
movq 0x6cd1(%rip), %rdi      # 0x92b8
movq 0x6cd2(%rip), %rdx      # 0x92c0
cmpq %rdx, %rdi
sete %bpl
je 0x2633
cmpl %ebx, (%rdi)
je 0x261a
addq $0x4, %rdi
cmpq %rdx, %rdi
sete %bpl
je 0x2633
leaq 0x4(%rdi), %rax
cmpl %ebx, (%rdi)
movq %rax, %rdi
jne 0x25ff
addq $-0x4, %rax
movq %rax, %rdi
leaq 0x4(%rdi), %rsi
cmpq %rdx, %rsi
je 0x262b
subq %rsi, %rdx
callq 0x2300
addq $-0x4, 0x6c8d(%rip)     # 0x92c0
movzbl %bpl, %ebx
negl %ebx
leaq 0x6c90(%rip), %rdi      # 0x92d0
callq 0x2180
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %edi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x4, %edx
callq 0x22b0
xorl %r14d, %r14d
cmpl $-0xb, %eax
je 0x2a72
testl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
sete %cl
movl 0xc(%rsp), %eax
cmpl $0x20000, %eax          # imm = 0x20000
setae %dl
orb %cl, %dl
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jne 0x2a72
movl %eax, %edx
leaq 0x10(%rsp), %r15
movl %ebp, %edi
movq %r15, %rsi
callq 0x22b0
movq %rax, %r14
movslq %r14d, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3aea
movl %r14d, %eax
addq $0x20018, %rsp          # imm = 0x20018
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8(%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 0x2a09
testl %eax, %eax
js 0x2b68
cmpl $0x0, 0x28(%rsp)
jne 0x2b68
cmpq %r14, 0x8(%rsp)
je 0x2ae8
movq 0x20(%rsp), %rbx
cmpq %r14, %rbx
je 0x2ae8
movq (%rbx), %rax
movq %rax, 0x20(%rsp)
addq $0x10, %rbx
jmp 0x2aea
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x2aac
cmpl $0x0, 0x28(%rsp)
setne %dl
movq 0x20(%rsp), %rcx
cmpq %r14, 0x8(%rsp)
sete %al
orb %dl, %al
movq %rbx, 0x30(%rsp)
movl 0x78(%rbx), %edx
movl %edx, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
testl %edx, %edx
jne 0x2b41
cmpq $0x0, 0x30(%rbx)
je 0x2b39
movq 0x28(%rbx), %rdx
cmpb $0x69, (%rdx)
jne 0x2b41
jmp 0x2b83
movl $0x6, 0x38(%rsp)
cmpq %r14, %rcx
sete %dl
orb %al, %dl
je 0x2b4f
xorl %ebx, %ebx
jmp 0x2b5e
movq %rcx, %rbx
movq (%rcx), %rcx
movq %rcx, 0x20(%rsp)
addq $0x10, %rbx
testq %rbx, %rbx
jne 0x2b06
jmp 0x2aac
leaq 0x8(%rsp), %rdi
callq 0x45be
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movl $0x69, %esi
callq 0x4db4
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x347d(%rip), %rsi      # 0x6024
leaq 0x347b(%rip), %rdx      # 0x6029
leaq 0x48(%rsp), %rdi
callq 0x51ea
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rbx, %rsi
callq 0x3b4c
movl 0x70(%rsp), %ebp
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x2be5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2230
testl %ebp, %ebp
jne 0x2bf2
movl 0x4(%rsp), %edi
callq 0x25cb
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x2c34
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x2c22
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x2c22
jmp 0x2c1f
jmp 0x2c1f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x45be
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x30(%rsp)
leaq 0xc(%rsp), %r15
xorl %r12d, %r12d
movl %ebp, %edi
movq %rbx, %rsi
leaq 0x2e6c(%rip), %rdx      # 0x6249
leaq 0x5dfc(%rip), %rcx      # 0x91e0
movq %r15, %r8
callq 0x2310
movl %eax, %r13d
cmpl $0x67, %eax
jg 0x342f
cmpl $0x53, %r13d
je 0x343c
cmpl $0x65, %r13d
jne 0x3484
movq 0x5bb5(%rip), %rax      # 0x8fc0
movq (%rax), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
leaq 0xb(%rsp), %rdx
callq 0x20c0
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x53d8
jmp 0x3463
cmpl $0x69, %r13d
jne 0x3490
movb $0x1, 0x38(%r14)
jmp 0x3484
movq 0x5b7d(%rip), %rax      # 0x8fc0
movq (%rax), %rsi
leaq 0x10(%rsp), %r15
movq %r15, %rdi
leaq 0xb(%rsp), %rdx
callq 0x20c0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2290
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x347f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0xc(%rsp), %r15
cmpl $-0x1, %r13d
jne 0x33d1
jmp 0x34b5
cmpl $0x76, %r13d
je 0x34aa
cmpl $0x68, %r13d
jne 0x33d1
movq (%rbx), %rdi
callq 0x3654
jmp 0x34af
callq 0x360c
movl $0xa, %r12d
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x34e6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3552
incq %rax
cmpq $0x400, %rax            # imm = 0x400
jne 0x353e
jmp 0x3558
movq %r15, %r14
addq %rax, %r14
leaq 0x2cf2(%rip), %rsi      # 0x6251
movl $0x4, %edx
movq %r14, %rdi
callq 0x2100
testl %eax, %eax
je 0x35c7
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b46(%rip), %rsi      # 0x60c6
leaq 0x2b44(%rip), %rdx      # 0x60cb
leaq 0x20(%rsp), %rdi
callq 0x51ea
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2b2a(%rip), %rsi      # 0x60cc
leaq 0x2b24(%rip), %rdx      # 0x60cd
movq %rsp, %rdi
callq 0x51ea
leaq 0x20(%rsp), %rsi
movq %rsp, %rcx
movl %ebp, %edi
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2655
movq %r15, %rdi
callq 0x22a0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x35ed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
jmp 0x35ed
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x3604
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x360c
movq 0x5964(%rip), %r14      # 0x8fd0
leaq 0x2a94(%rip), %rsi      # 0x6107
movl $0x7, %edx
movq %r14, %rdi
callq 0x2260
leaq 0x2a88(%rip), %rsi      # 0x610f
movl $0x1, %edx
movq %r14, %rdi
callq 0x2260
testq %rbx, %rbx
je 0x36b5
movq %rbx, %rdi
callq 0x20d0
movq 0x5928(%rip), %rdi      # 0x8fd0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2260
jmp 0x36cd
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2320
movq 0x58fc(%rip), %rbx      # 0x8fd0
leaq 0x2a36(%rip), %rsi      # 0x6111
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2260
leaq 0x2b2e(%rip), %rsi      # 0x621d
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2260
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2a11(%rip), %rsi      # 0x611d
leaq 0x2b0b(%rip), %rdx      # 0x621e
movq %rsp, %r14
movq %r14, %rdi
callq 0x51ea
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2260
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x3743
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 0x3768
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2230
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3e7a
leaq 0x8(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x2130
movq %r15, (%rbx)
cmpq $0x0, 0x10(%rbx)
je 0x38ff
movq (%r14), %rax
cmpb $0x2f, (%rax)
je 0x390c
cmpl $0x0, 0x78(%rbx)
jne 0x390c
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_O1/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 0x3a08
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 0x39d5
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x50(%rbx)
jmp 0x39e1
leaq 0x48(%rbx), %rdi
movq %rsp, %rdx
callq 0x410c
movq 0x8(%r14), %rsi
incq %rsi
movq %r15, %rdi
callq 0x408e
movq (%r14), %rsi
movq %rax, %rdi
callq 0x2200
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x28e2(%rip), %rdi      # 0x62f1
leaq 0x289b(%rip), %rsi      # 0x62b1
leaq 0x28ea(%rip), %rcx      # 0x6307
movl $0x193, %edx            # imm = 0x193
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a45
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x3a79
leaq 0x18(%rbx), %rsi
movq 0x8(%rbx), %rax
xorl %edx, %edx
cmpq (%rbx), %rax
setne %dl
movq %r14, %rdi
callq 0x424c
movl 0x78(%r14), %eax
testl %eax, %eax
je 0x3a6e
cmpl $0x0, 0x30(%rbx)
jne 0x3a6e
movl %eax, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x0, 0x30(%rbx)
jne 0x3a5d
movl $0xa, 0x30(%rbx)
jmp 0x3a5d
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45be
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq $0x0, 0x10(%rbx)
testb $0x3, %r14b
je 0x3b28
cmpl $0x0, 0x20(%rbx)
jne 0x3b3e
movl $0x9, 0x20(%rbx)
jmp 0x3b3e
addq %r15, %r14
movl $0x1, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x43f0
movq (%rbx), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %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, 0x8(%rsp)
movq $0x4, 0x10(%rsp)
movq 0x50(%rbx), %rsi
cmpq 0x58(%rbx), %rsi
je 0x404b
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x50(%rbx)
jmp 0x4059
leaq 0x48(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x410c
movl $0x4, %r15d
movl $0x4, %esi
movq %r14, %rdi
callq 0x408e
movl %ebp, 0x8(%rsp)
movb 0x7(%rsp,%r15), %cl
movb %cl, (%rax)
incq %rax
decq %r15
jne 0x4070
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jgeumlek[P]moltengamepadctl/source/oscpkt/oscpkt.hh
// Function: oscpkt::Storage::getBytes(unsigned long)
char *getBytes(size_t sz) {
    assert((data.size() & 3) == 0);
    if (data.size() + sz > data.capacity()) { data.reserve((data.size() + sz)*2); }
    size_t sz4 = ceil4(sz);
    size_t pos = data.size(); 
    data.resize(pos + sz4); // resize will fill with zeros, so the zero padding is OK
    return &(data[pos]);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rsi
subq %rax, %rsi
testb $0x3, %sil
jne 0x40ec
movq %rdi, %rbx
addq %r14, %rsi
movq 0x10(%rdi), %rcx
subq %rax, %rcx
cmpq %rcx, %rsi
jbe 0x40c3
addq %rsi, %rsi
movq %rbx, %rdi
callq 0x3de8
addq $0x3, %r14
andq $-0x4, %r14
movq 0x8(%rbx), %r15
subq (%rbx), %r15
addq %r15, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ebe
addq (%rbx), %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x21a7(%rip), %rdi      # 0x629a
leaq 0x21b7(%rip), %rsi      # 0x62b1
leaq 0x21c8(%rip), %rcx      # 0x62c9
movl $0x9d, %edx
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpq %rdx, %rsi
ja 0x4580
movq %rdi, %rbx
cmpl $0x0, 0x20(%rdi)
jne 0x4580
movq %rdx, %r14
subq %rsi, %rdx
testb $0x3, %dl
jne 0x4589
cmpq %r14, %rsi
je 0x4571
cmpb $0x23, (%rsi)
jne 0x44db
movl $0x8, %eax
cmpq $0x14, %rdx
jl 0x456e
movabsq $0x656c646e756223, %rcx # imm = 0x656C646E756223
cmpq %rcx, (%rsi)
jne 0x456e
leaq 0xf(%rsi), %rax
xorl %ecx, %ecx
movb (%rax), %dl
movb %dl, 0x8(%rsp,%rcx)
incq %rcx
decq %rax
cmpq $0x8, %rcx
jne 0x445d
movq 0x8(%rsp), %r15
addq $0x10, %rsi
leaq 0x3(%rsi), %rax
xorl %ecx, %ecx
movb (%rax), %dl
movb %dl, 0x8(%rsp,%rcx)
incq %rcx
decq %rax
cmpq $0x4, %rcx
jne 0x447e
movl 0x8(%rsp), %r12d
addq $0x4, %rsi
testb $0x3, %r12b
jne 0x44a7
addq %rsi, %r12
cmpq %r14, %r12
jbe 0x44b6
cmpl $0x0, 0x20(%rbx)
jne 0x44c7
movl $0x8, 0x20(%rbx)
jmp 0x44c7
movq %rbx, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0x43f0
movq %r12, %rsi
cmpl $0x0, 0x20(%rbx)
jne 0x4571
cmpq %r14, %rsi
jne 0x4478
jmp 0x4571
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x465a
movq %rbx, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x473e
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x450d
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x4524
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x2230
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x453f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2230
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x455a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2230
movq 0x8(%rbx), %rax
movl 0x88(%rax), %eax
testl %eax, %eax
je 0x4571
cmpl $0x0, 0x20(%rbx)
jne 0x4571
movl %eax, 0x20(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1db9(%rip), %rdi      # 0x6340
jmp 0x4590
leaq 0x1e09(%rip), %rdi      # 0x6399
leaq 0x1d1a(%rip), %rsi      # 0x62b1
leaq 0x1db5(%rip), %rcx      # 0x6353
movl $0x216, %edx            # imm = 0x216
callq 0x2150
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3a88
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x10, %rsp
cmpl $0x0, 0x78(%rdi)
jne 0x4c66
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 0x4c72
addq %rax, %r15
movq %r15, %rdx
subq %r14, %rdx
jb 0x4c72
movl $0x4, %ecx
cmpl $0x61, %esi
jle 0x4b9c
leal -0x62(%rsi), %eax
cmpl $0x7, %eax
ja 0x4bb4
leaq 0x1478(%rip), %rdx      # 0x6004
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movl $0x8, %eax
jmp 0x4c07
xorl %eax, %eax
cmpl $0x46, %esi
je 0x4c07
cmpl $0x54, %esi
je 0x4c07
jmp 0x4c63
movl $0x4, %eax
jmp 0x4c07
cmpl $0x73, %esi
jne 0x4c63
movq %r14, %rdi
xorl %esi, %esi
callq 0x2240
testq %rax, %rax
je 0x4bfe
subq %r14, %rax
incq %rax
jmp 0x4c07
cmpq %r14, %r15
je 0x4c5e
leaq 0x3(%r14), %rax
xorl %ecx, %ecx
movb (%rax), %dl
movb %dl, 0xc(%rsp,%rcx)
incq %rcx
decq %rax
cmpq $0x4, %rcx
jne 0x4be3
movl 0xc(%rsp), %eax
addl $0x4, %eax
jmp 0x4c07
movl $0x3, 0x78(%rbx)
xorl %eax, %eax
testq %rax, %rax
js 0x4c58
leaq (%r14,%rax), %rsi
cmpq %r15, %rsi
ja 0x4c58
leaq 0x3(%rsi), %rcx
andq $-0x4, %rcx
movq %rsi, %rdx
subq %rcx, %rdx
setae %dil
jae 0x4c53
cmpb $0x0, (%rsi)
jne 0x4c58
leaq (%rax,%r14), %rdi
incq %rdi
incq %rdx
movq %rdi, %rsi
testq %rdx, %rdx
je 0x4c4c
leaq 0x1(%rsi), %rdi
incq %rdx
cmpb $0x0, (%rsi)
je 0x4c38
cmpq %rcx, %rsi
setae %dil
testb %dil, %dil
jne 0x4c68
cmpl $0x0, 0x78(%rbx)
jne 0x4c66
movl $0x3, %ecx
movl %ecx, 0x78(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x17b4(%rip), %rdi      # 0x642d
leaq 0x1631(%rip), %rsi      # 0x62b1
leaq 0x17d1(%rip), %rcx      # 0x6458
movl $0x1bb, %edx            # imm = 0x1BB
callq 0x2150
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4e42
testb %al, %al
je 0x4e03
movq 0x10(%rbx), %rax
cmpl $0x0, 0x8(%rbx)
jne 0x4e0c
movq (%rbx), %rsi
movq 0x48(%rsi), %rdx
movq 0x50(%rsi), %rcx
subq %rdx, %rcx
sarq $0x4, %rcx
cmpq %rax, %rcx
jbe 0x4e0c
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 0x4e0e
movl $0x0, (%r14)
jmp 0x4e36
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 0x4e14
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_O1/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, %rbx
movq (%rdi), %rax
cmpl $0x0, 0x4(%rax)
je 0x3851
movl %esi, %ebp
movq %rbx, %rdi
callq 0x3862
movl %eax, %r14d
movq %rbx, %rdi
movl %eax, %esi
callq 0x38a4
movslq %r14d, %rax
leaq (%rax,%rax,2), %rcx
movslq %ebp, %r15
movq 0x18(%rbx), %rdx
movq 0x38(%rbx), %r12
movl 0x8(%rdx,%rcx,4), %esi
movl %esi, (%r12,%r15,4)
cmpl %eax, %esi
je 0x383e
incl %ebp
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x39ac
movq %rbx, %rdi
movl %ebp, %esi
callq 0x37b2
movl (%r12,%r15,4), %esi
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x39fc
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 0x3801
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3906
incq 0x90(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leal 0x1(%rsi), %ecx
movq 0x18(%rdi), %rax
movslq %ecx, %rdi
leaq (%rdi,%rdi,2), %rdi
cmpl $0x0, (%rax,%rdi,4)
jle 0x399f
movq 0x18(%rdx), %r8
movslq (%r8,%rdi,4), %r9
movslq 0x4(%r8,%rdi,4), %r10
movslq 0x8(%r8,%rdi,4), %rdi
leaq (%r10,%r10,2), %r11
leaq (%rdi,%rdi,2), %rbx
movl %edi, 0x8(%r8,%r11,4)
movl %r10d, 0x4(%r8,%rbx,4)
leaq (%r9,%r9,2), %rdi
decl (%r8,%rdi,4)
incl %ecx
jmp 0x39a6
leaq (%rax,%rdi,4), %rcx
movl 0x4(%rcx), %ecx
cmpl %esi, %ecx
jne 0x3962
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
leal -0x1(%rsi), %ecx
movq 0x18(%rdi), %rax
movslq %ecx, %rdi
leaq (%rdi,%rdi,2), %rdi
cmpl $0x0, (%rax,%rdi,4)
jle 0x3a90
movq 0x18(%rdx), %r8
movslq (%r8,%rdi,4), %r9
movslq 0x4(%r8,%rdi,4), %r10
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
incl (%r8,%rdi,4)
decl %ecx
jmp 0x3a97
leaq (%rax,%rdi,4), %rcx
movl 0x8(%rcx), %ecx
cmpl %esi, %ecx
jne 0x3a53
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4f08
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4eec
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jl 0x4edd
cmpq %rax, %rcx
je 0x4f11
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 0x4f56
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x4f39
movq (%rdi), %rax
callq *0x8(%rax)
incq %r14
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jl 0x4f2a
cmpq %rax, %rcx
je 0x4f5f
movq %rax, 0x20(%rbx)
movl $0x0, 0x14c(%rbx)
movq 0x60(%rbx), %rax
cmpq 0x40(%rbx), %rax
je 0x4f89
leaq 0x30(%rbx), %r14
movq %r14, %rdi
callq 0x85cc
movq 0x60(%rbx), %rax
cmpq 0x40(%rbx), %rax
jne 0x4f77
movq 0xb0(%rbx), %rax
cmpq 0x90(%rbx), %rax
je 0x4fb8
leaq 0x80(%rbx), %r14
movq %r14, %rdi
callq 0x8652
movq 0xb0(%rbx), %rax
cmpq 0x90(%rbx), %rax
jne 0x4fa0
addq $0xd0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x869e
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4fe8
movl %esi, %ecx
movabsq $-0x7ffff0c000000000, %rdx # imm = 0x80000F4000000000
btq %rcx, %rdx
jae 0x4fe8
retq
cmpl $0x7c, %esi
je 0x4fe7
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x509c
addq $0x30, %rbx
cmpq %rdx, %rax
jne 0x5085
movl $0x1f8, %eax            # imm = 0x1F8
addq -0x8(%rcx), %rax
addq $-0x18, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x79f0
movq %rbx, %rdi
callq 0x85cc
cmpq %r15, %r14
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x500a
testb %al, %al
je 0x5128
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x500a
testb %al, %al
je 0x5128
movq 0x8(%rsp), %rax
movq -0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9520
movq %rsp, %rdi
movq 0x8(%rdi), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x86e8
addq $0x30, %rbx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8920
jmp 0x512a
xorl %ebp, %ebp
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5141
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5157
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
jmp 0x5164
jmp 0x5164
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x517e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5194
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movl %esi, 0x34(%rsp)
movq %rdi, %rbx
movb %sil, 0xf(%rsp)
movl $0x78, %edi
callq 0x2150
movq %rax, %r14
movl 0x14c(%rbx), %r13d
leal 0x1(%r13), %r12d
movl %r12d, 0x14c(%rbx)
leaq 0x8ba4(%rip), %rbp      # 0xdd80
addq $0x10, %rbp
movq %rbp, (%rax)
addq $0x10, %rax
xorl %r15d, %r15d
movl %r15d, 0x10(%r14)
movq %r15, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %rax, 0x28(%r14)
movq %r15, 0x30(%r14)
leaq 0x40(%r14), %rax
movl %r15d, 0x40(%r14)
movq %r15, 0x48(%r14)
movq %rax, 0x50(%r14)
movq %rax, 0x58(%r14)
movq %r15, 0x60(%r14)
movl %r13d, 0x68(%r14)
movb %r15b, 0x6c(%r14)
movl %r15d, 0x70(%r14)
movq %r14, 0x40(%rsp)
movl $0x78, %edi
callq 0x2150
addl $0x2, %r13d
movl %r13d, 0x14c(%rbx)
movq %rbp, (%rax)
leaq 0x10(%rax), %rcx
movl %r15d, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movq %r15, 0x30(%rax)
leaq 0x40(%rax), %rcx
movl %r15d, 0x40(%rax)
movq %r15, 0x48(%rax)
movq %rcx, 0x50(%rax)
movq %rcx, 0x58(%rax)
movq %r15, 0x60(%rax)
movl %r12d, 0x68(%rax)
movb %r15b, 0x6c(%rax)
movl %r15d, 0x70(%rax)
movq %rax, 0x38(%rsp)
movq %r14, %rdi
movl 0x34(%rsp), %esi
movq %rax, %rdx
callq 0x9520
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r15, 0x20(%rsp)
movq 0x18(%rsp), %rsi
testq %rsi, %rsi
je 0x52b6
movq 0x40(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%rsp)
jmp 0x52c5
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x8c2e
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x52e1
movq 0x38(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%rsp)
jmp 0x52f0
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x8c2e
leaq 0x30(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8920
addq $0xd0, %rbx
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq 0x8d0a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5329
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
addq $0x48, %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 0x5352
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
callq 0x500a
movl %eax, %ebx
testb %al, %al
je 0x54f2
movb %bl, 0xf(%rsp)
movl $0x78, %edi
callq 0x2150
movq %rax, %r15
movl 0x14c(%r14), %r13d
leal 0x1(%r13), %ebp
movl %ebp, 0x14c(%r14)
leaq 0x89c9(%rip), %rbx      # 0xdd80
addq $0x10, %rbx
movq %rbx, (%rax)
addq $0x10, %rax
xorl %r12d, %r12d
movl %r12d, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rax, 0x28(%r15)
movq %r12, 0x30(%r15)
movq %r15, %rax
addq $0x40, %rax
movl %r12d, 0x40(%r15)
movq %r12, 0x48(%r15)
movq %rax, 0x50(%r15)
movq %rax, 0x58(%r15)
movq %r12, 0x60(%r15)
movl %r13d, 0x68(%r15)
movb $0x0, 0x6c(%r15)
movl %r12d, 0x70(%r15)
movq %r15, 0x30(%rsp)
movl $0x78, %edi
callq 0x2150
addl $0x2, %r13d
movl %r13d, 0x14c(%r14)
movq %rbx, (%rax)
leaq 0x10(%rax), %rcx
movl %r12d, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rcx, 0x28(%rax)
movq %r12, 0x30(%rax)
movq %rax, %rcx
addq $0x40, %rcx
movl %r12d, 0x40(%rax)
movq %r12, 0x48(%rax)
movq %rcx, 0x50(%rax)
movq %rcx, 0x58(%rax)
movq %r12, 0x60(%rax)
movl %ebp, 0x68(%rax)
movb $0x0, 0x6c(%rax)
movl %r12d, 0x70(%rax)
movq %rax, 0x28(%rsp)
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rax, %rdx
callq 0x9520
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9520
movq 0x18(%rsp), %rax
movq -0x8(%rax), %rdi
movq 0x28(%rsp), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9520
leaq 0x10(%rsp), %rdi
movq (%rdi), %rsi
leaq 0x30(%rsp), %rdx
callq 0x7ac6
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x54ce
movq 0x28(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%rsp)
jmp 0x54dd
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x8c2e
addq $0x30, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x8920
movb 0xf(%rsp), %bl
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5509
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5524
jmp 0x5524
jmp 0x5524
jmp 0x5524
jmp 0x5524
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x553e
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8f90
movq 0x18(%r14), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x5eba
movsbl %bpl, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x20(%r15), %rdi
movl %ebp, %esi
movq %rsp, %rdx
callq 0x959a
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
subq %rsi, %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x5e8e
xorl %r13d, %r13d
xorl %r12d, %r12d
addq %r13, %rsi
movq %rbx, %rdi
callq 0x91d2
incq %r12
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
subq %rsi, %rax
shrq $0x3, %rax
cltq
addq $0x8, %r13
cmpq %rax, %r12
jl 0x5e65
testq %rsi, %rsi
je 0x5ea6
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 0x5e2d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5ecb
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x5ee4
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2260