LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ahupp[P]mural/tags.cpp
// Function: lowercase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string lowercase(const string& s) {
  string ret = s;
  for (size_t i = 0; i < ret.length(); ++i) {
    ret[i] = tolower(ret[i]);
  }
  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x3722
cmpq $0x0, 0x8(%rbx)
je 0x39ee
xorl %r14d, %r14d
movq (%rbx), %r15
movsbl (%r15,%r14), %edi
callq 0x22a0
movb %al, (%r15,%r14)
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x39d4
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ahupp[P]mural/tags.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> split(const string& line, char delim) {

  vector<string> result;

  size_t i = 0;
  while (1) {

    size_t next = line.find(delim, i);
    if (next == string::npos) {
      break;
    }

    result.push_back(line.substr(i, next - i));

    i = next + 1;
  }
  result.push_back(line.substr(i, line.length() - i));

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %r13d, %r13d
movsbl %dl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r13, %rdx
callq 0x2270
movq %rax, %r12
cmpq $-0x1, %rax
je 0x3a7a
movq %r12, %rcx
subq %r13, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2210
movq %rbx, %rdi
movq %r15, %rsi
callq 0x46d6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a75
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x1(%r12), %r13
cmpq $-0x1, %r12
jne 0x3a24
movq 0x8(%r14), %rcx
subq %r13, %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2210
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x46d6
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3ac0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3adb
jmp 0x3ad6
movq %rax, %r14
jmp 0x3afa
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3afa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x44fe
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/ahupp[P]mural/tags.cpp
// Function: read_tags_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<TagInfo, std::allocator<TagInfo>>&)
void read_tags_file(const string& tags_file, vector<TagInfo>& tags) {

  if (0 != access(tags_file.c_str(), R_OK)) {
    cerr << "error: " << tags_file << " not readable" << endl;
    exit(1);
  }

  tags.clear();

  ifstream tags_stream(tags_file.c_str());

  string line;
  getline(tags_stream, line);
  tags_stream.seekg(0);

  if (line.length() && line[0] == '!') {
    read_ctags_file(tags_stream, tags);
  } else {
    read_etags_file(tags_stream, tags);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movl $0x4, %esi
callq 0x22f0
testl %eax, %eax
jne 0x4492
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x4c7e
movq (%r14), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2360
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %edx
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2370
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2260
cmpq $0x0, 0x10(%rsp)
je 0x4457
movq 0x8(%rsp), %rax
cmpb $0x21, (%rax)
jne 0x4457
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x3b0a
jmp 0x4464
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x3f7a
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x447b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x28(%rsp), %rdi
callq 0x2070
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r14
popq %r15
retq
movq 0x3b57(%rip), %rdi      # 0x7ff0
leaq 0xc4d(%rip), %rsi       # 0x50ed
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2190
leaq 0xc3e(%rip), %rsi       # 0x50f5
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x20e0
movl $0x1, %edi
callq 0x2240
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x44eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x28(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./DirectoryIterator.h
// Function: jshund::DirectoryIterator::addFiles(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void addFiles (std::vector<std::string>& files, std::string const& argument) {
        if (isFile(argument)) {
          files.push_back(std::string(argument));
        }
        else if (isDir(argument)) {
          addDir(files, argument);
        }
        else {
          std::cerr << "Ignoring invalid file/directory path '" << argument << "'" << std::endl;
        }
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x21d0
movl $0xf000, %ebp           # imm = 0xF000
testl %eax, %eax
jne 0x2eb3
movl 0x38(%rsp), %eax
andl %ebp, %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x2eb3
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x35f8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3390
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f13
movq 0x30(%rsp), %rsi
jmp 0x2f0b
movq (%r14), %rdi
leaq 0x20(%rsp), %rsi
callq 0x21d0
testl %eax, %eax
jne 0x2f23
andl 0x38(%rsp), %ebp
cmpl $0x4000, %ebp           # imm = 0x4000
jne 0x2f23
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x35f8
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2fd0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2f13
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x90c6(%rip), %rbx      # 0xbff0
leaq 0x5255(%rip), %rsi      # 0x8186
movl $0x26, %edx
movq %rbx, %rdi
callq 0x2250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2250
movq %rax, %rbx
leaq 0x5464(%rip), %rsi      # 0x83bb
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2160
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x2fc7
movq 0x10(%rsp), %rsi
jmp 0x2fbf
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2fc7
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./FileReader.h
// Function: jshund::FileReader::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
char* read (const std::string& fileName) {
        std::ifstream f;

        f.open(fileName.c_str(), std::ifstream::in | std::ifstream::binary);

        if (! f.is_open()) {
          return 0;
        }

        // get filesize
        f.seekg(0, std::ios::end);
        int fileSize = f.tellg();
        f.seekg(0, std::ios::beg);

        // allocate buffer plus some extra bytes
        char* buffer = new char[fileSize + 5];

        if (buffer != 0) {
          // initialise buffer with 0s
          memset(buffer + fileSize, 0, 5);

          // read contents
          f.read(buffer, fileSize);
          f.close();
        }

        return buffer;
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2240
movq (%rbx), %rsi
movq %r14, %rdi
movl $0xc, %edx
callq 0x2140
leaq 0x78(%rsp), %rdi
callq 0x2080
testb %al, %al
je 0x3729
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x22b0
movq %rsp, %rdi
callq 0x2360
movq %rax, %rbx
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22b0
shlq $0x20, %rbx
movabsq $0x500000000, %rdi      # imm = 0x500000000
addq %rbx, %rdi
sarq $0x20, %rdi
callq 0x2030
movq %rax, %r14
sarq $0x20, %rbx
movb $0x0, 0x4(%rax,%rbx)
movl $0x0, (%rax,%rbx)
movq %rsp, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2280
movq %rsp, %rdi
callq 0x2070
jmp 0x372c
xorl %r14d, %r14d
movq %rsp, %rdi
callq 0x2090
movq %r14, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0x3748
jmp 0x3748
jmp 0x3748
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::tokenize(char const*)
const std::vector<Token>& tokenize (char const* input) {
        _input    = input;
        _length   = ::strlen(input);
        _position = 0;
        _line     = 1; 
        _last     = TOKEN_UNKNOWN;

        _tokens.clear();

        doTokenize();

        if (_debug) {
          for (size_t i = 0; i < _tokens.size(); ++i) {
            _tokens[i].dump();
          }
        }

        return _tokens;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x80(%rdi)
movq %rsi, %rdi
callq 0x20f0
movq %rax, 0x88(%rbx)
movq $0x0, 0x90(%rbx)
movq $0x1, 0x98(%rbx)
movl $0x0, 0x78(%rbx)
leaq 0x60(%rbx), %r14
movq 0x60(%rbx), %rsi
movq %r14, %rdi
callq 0x6d2a
movq %rbx, %rdi
callq 0x6b28
cmpb $0x1, 0xa0(%rbx)
jne 0x5b0f
movq 0x60(%rbx), %rdi
cmpq %rdi, 0x68(%rbx)
je 0x5b0f
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r13d, %r13d
addq %r15, %rdi
callq 0x6c98
incq %r13
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rax
subq %rdi, %rax
sarq $0x4, %rax
imulq %r12, %rax
addq $0x30, %r15
cmpq %rax, %r13
jb 0x5ae8
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Validator.h
// Function: jshund::Validator::reportError(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void reportError (int line, std::string const& name, bool global) {
        std::cout << _filename << ':' << line << ':'  
                  << (global ? _colorGlobal : _colorLocal) << " unused " << (global ? "global" : "local") 
                  << " variable '" << name << '\'' << _colorEnd  
                  << std::endl;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movq 0x60(%rdi), %rsi
movq 0x68(%rdi), %rdx
movq 0x5f6a(%rip), %rdi      # 0xbfd0
callq 0x2250
movb $0x3a, %r12b
leaq 0xd(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq %rax, %rdi
movl %r15d, %esi
callq 0x2350
leaq 0xe(%rsp), %rsi
movb %r12b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movl %ebp, %ecx
xorb $0x1, %cl
movzbl %cl, %ecx
shll $0x5, %ecx
movq (%rbx,%rcx), %rsi
movq 0x8(%rbx,%rcx), %rdx
movq %rax, %rdi
callq 0x2250
movq %rax, %r15
leaq 0x22d2(%rip), %rsi      # 0x839b
movl $0x8, %edx
movq %rax, %rdi
callq 0x2250
leaq 0x22c7(%rip), %rax      # 0x83a4
leaq 0x22c7(%rip), %rsi      # 0x83ab
testl %ebp, %ebp
cmovneq %rax, %rsi
movl %ebp, %edx
addq $0x5, %rdx
movq %r15, %rdi
callq 0x2250
leaq 0x22b2(%rip), %rsi      # 0x83b1
movl $0xb, %edx
movq %r15, %rdi
callq 0x2250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2250
leaq 0xf(%rsp), %rsi
movb $0x27, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2250
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdx
movq %rax, %rdi
callq 0x2250
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2160
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::doTokenize()
void doTokenize () {
        while (true) {
          Token token = getNext();
          if (token.type == TOKEN_EOF || token.type == TOKEN_UNKNOWN) {
            break;
          }

          addToken(token);
        }

        addToken(makeToken(TOKEN_EOF));
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
leaq 0x60(%rdi), %r14
leaq 0x50(%rsp), %rbp
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6d7c
xorl %r13d, %r13d
movl 0x38(%rsp), %eax
testl %eax, %eax
je 0x6bc2
cmpl $0x72, %eax
je 0x6bc2
movl %eax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x35f8
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x77e0
movl 0x8(%rsp), %eax
movl %eax, 0x78(%rbx)
movq 0x10(%rsp), %rdi
movb $0x1, %r13b
cmpq %r15, %rdi
je 0x6bc2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6bd9
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
testb %r13b, %r13b
jne 0x6b4f
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x72, %edx
callq 0x6f46
movq %r14, %rdi
movq %r15, %rsi
callq 0x77e0
leaq 0x80(%rsp), %rax
movl -0x18(%rax), %ecx
movl %ecx, 0x78(%rbx)
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c29
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c8f
movq 0x80(%rsp), %rsi
jmp 0x6c87
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x6c78
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x6c78
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6c8f
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::makeToken(jshund::TokenType)
Token makeToken (TokenType type) {
        Token token;
        token.type  = type;
        token.line  = _line;
        token.value = "";

        ++_position;

        return token;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movl %edx, (%rdi)
movq 0x98(%rsi), %rax
movq %rax, 0x28(%rdi)
leaq 0x1451(%rip), %rcx      # 0x83d1
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2300
incq 0x90(%r14)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x6fbc
movq (%r12), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::skipWhitespace()
bool skipWhitespace () {
        while (true) {
          const char c = _input[_position];
          
          if (c == '\0') {
            return false;
          }

          if (c != ' ' && c != '\r' && c != '\n' && c != '\t' && c != '\f' && c != '\b') {
            return true;
          }

          if (c == '\r') {
            if (_input[_position + 1] == '\n') {
              ++_position;
              ++_line;
            }
          }
          else if (c == '\n') {
            ++_line;
          }

          _position++;
        }
      }

// Assembly:
movq 0x80(%rdi), %rcx
movq 0x90(%rdi), %rdx
leaq 0x98(%rdi), %rsi
movq 0x98(%rdi), %r8
leaq 0x1039(%rip), %r9       # 0x8020
movzbl (%rcx,%rdx), %r10d
cmpq $0xd, %r10
ja 0x7000
movslq (%r9,%r10,4), %r10
addq %r9, %r10
jmpq *%r10
xorl %eax, %eax
jmp 0x7008
cmpl $0x20, %r10d
je 0x7024
movb $0x1, %al
xorl %r10d, %r10d
jmp 0x7031
cmpb $0xa, 0x1(%rcx,%rdx)
jne 0x7024
incq %rdx
movq %rdx, 0x90(%rdi)
incq %r8
movq %r8, (%rsi)
incq %rdx
movq %rdx, 0x90(%rdi)
movb $0x1, %r10b
testb %r10b, %r10b
jne 0x6fe7
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleString(char)
Token handleString (const char terminator) {
        size_t now = _position + 1;

        while (true) {
          char n = _input[now];
          if (n == '\\') {
            ++now;
          }
          else if (n == terminator) {
            return makeToken(TOKEN_STRING_LITERAL, until(now + 1));
          }
          else if (n == '\0') {
            return makeToken(TOKEN_UNKNOWN);
          }
          ++now;
        }
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x90(%rsi), %rbp
incq %rbp
leaq 0x18(%rsp), %rcx
leaq 0x8(%rsp), %r12
movq 0x80(%r15), %rsi
movb (%rsi,%rbp), %al
cmpb $0x5c, %al
jne 0x7077
incq %rbp
jmp 0x70d4
cmpb %bl, %al
jne 0x70d0
leaq (%rsi,%rbp), %rdx
incq %rdx
addq 0x90(%r15), %rsi
movq %rcx, 0x8(%rsp)
movq %r12, %rdi
movq %rcx, %r13
callq 0x770a
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
movq %r12, %rcx
callq 0x7690
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
movq %r13, %rcx
je 0x70cb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x18(%rsp), %rcx
xorl %r13d, %r13d
jmp 0x70da
testb %al, %al
je 0x70e1
incq %rbp
movb $0x1, %r13b
testb %r13b, %r13b
jne 0x7064
jmp 0x70f8
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x6f46
leaq 0x18(%rsp), %rcx
jmp 0x70da
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7124
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleId()
Token handleId () {
        // name/keyword
        std::string name;
        bool canBeKeyword = true;
        size_t now = _position;
        
        while (true) {
          char n = _input[now];

          if (n >= 'a' && n <= 'z') {
            name.push_back(n);
          } 
          else if (n >= 'A' && n <= 'Z') {
            name.push_back(n);
            canBeKeyword = false;
          }
          else if (n >= '0' && n <= '9') {
            name.push_back(n);
            canBeKeyword = false;
          }
          else if (n == '_' || n == '$') {
            name.push_back(n);
          }
          else {
            break;
          }
          ++now;
        }
          
        if (canBeKeyword) {
          std::map<std::string, TokenType>::const_iterator it = _keywordMap.find(name);
          if (it != _keywordMap.end()) {
            return makeToken((*it).second, std::string(_input + _position, name.size()));
          }
        }
          
        return makeToken(TOKEN_NAME, std::string(_input + _position, name.size()));
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x90(%rsi), %r13
movb $0x1, %bpl
leaq 0x28(%rsp), %r15
movq 0x80(%r14), %rax
movzbl (%rax,%r13), %eax
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jae 0x7188
movsbl %al, %esi
movq %r15, %rdi
callq 0x21b0
jmp 0x71ab
leal -0x41(%rax), %ecx
cmpb $0x1a, %cl
setae %cl
leal -0x30(%rax), %edx
cmpb $0xa, %dl
setae %dl
testb %dl, %cl
jne 0x71b6
movsbl %al, %esi
movq %r15, %rdi
callq 0x21b0
xorl %ebp, %ebp
incq %r13
movb $0x1, %al
testb %al, %al
jne 0x7167
jmp 0x71c4
cmpl $0x5f, %eax
je 0x717b
cmpl $0x24, %eax
je 0x717b
xorl %eax, %eax
jmp 0x71b0
testb $0x1, %bpl
je 0x7221
leaq 0x30(%r14), %rdi
leaq 0x28(%rsp), %rsi
callq 0x779a
leaq 0x38(%r14), %rcx
cmpq %rcx, %rax
je 0x7221
movl 0x40(%rax), %ebp
movq 0x80(%r14), %rsi
addq 0x90(%r14), %rsi
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x770a
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x7690
jmp 0x725f
movq 0x80(%r14), %rsi
addq 0x90(%r14), %rsi
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x770a
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4b, %edx
callq 0x7690
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7276
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x728d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x72a5
jmp 0x72c3
jmp 0x72c3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x72c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x72c6
jmp 0x72c3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x72dd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleNumber()
Token handleNumber () {
        size_t now = _position;
        bool dotFound = false;
        bool expFound = false;
        
        while (true) {
          char n = _input[now];
          if (n >= '0' && n <= '9') {
            ++now;
          }
          else if (n == '.' && ! dotFound) {
            dotFound = true;
            ++now;
          }
          else if ((n == 'e' || n == 'E') && ! expFound) {
            // exponent
            expFound = true;
            ++now;
          }
          else {
            break;
          }
        }

        return makeToken(TOKEN_NUMBER, until(now));
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rax
movq 0x90(%rsi), %rsi
xorl %ecx, %ecx
xorl %edi, %edi
movq %rsi, %rdx
movb (%rax,%rdx), %r8b
leal -0x30(%r8), %r9d
cmpb $0xa, %r9b
jae 0x7322
incq %rdx
movb $0x1, %r8b
jmp 0x7340
cmpb $0x2e, %r8b
jne 0x732e
testb $0x1, %dil
je 0x7347
andb $-0x21, %r8b
cmpb $0x45, %r8b
jne 0x733d
testb $0x1, %cl
je 0x734c
xorl %r8d, %r8d
testb %r8b, %r8b
jne 0x730c
jmp 0x7350
movb $0x1, %dil
jmp 0x731a
movb $0x1, %cl
jmp 0x731a
addq %rax, %rsi
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x770a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
movq %r15, %rcx
callq 0x7690
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7397
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x73c0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleCommentMulti()
Token handleCommentMulti () {
        size_t now = _position + 2;
        
        while (true) {
          char n1 = _input[now];
          char n2 = _input[now + 1];

          if (n1 == '\r' && n1 == '\n') {
            ++_line;
            now += 2;
          }
          else if (n1 == '\r' || n1 == '\n') {
            ++_line;
            ++now;
          }
          else if (n1 == '*' && n2 == '/') {
            return makeToken(TOKEN_COMMENT_MULTI, until(now + 2));
          }
          else if (n1 == '\0') {
            return makeToken(TOKEN_UNKNOWN);
          }
          else {
            ++now;
          }
        }
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rsi), %r13
addq $0x2, %r13
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r15
movq 0x80(%r14), %rsi
movzbl (%rsi,%r13), %ecx
leaq 0x1(%r13), %rax
cmpl $0xd, %ecx
je 0x740b
cmpl $0xa, %ecx
jne 0x7417
incq 0x98(%r14)
movb $0x1, %bpl
jmp 0x7485
cmpb $0x2a, %cl
jne 0x746c
cmpb $0x2f, (%rsi,%rax)
jne 0x746c
leaq (%rsi,%r13), %rdx
addq $0x2, %rdx
addq 0x90(%r14), %rsi
movq %r12, 0x8(%rsp)
movq %r15, %rdi
callq 0x770a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x47, %edx
movq %r15, %rcx
callq 0x7690
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7468
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
xorl %ebp, %ebp
jmp 0x7482
movb $0x1, %bpl
testb %cl, %cl
jne 0x7485
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6f46
movq %r13, %rax
movq %rax, %r13
testb %bpl, %bpl
jne 0x73f1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x74bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleCommentSingle()
Token handleCommentSingle () {
        size_t now = _position + 2;

        while (true) {
          char n = _input[now];

          if (n == '\r' || n == '\n' || n == '\0') {
            return makeToken(TOKEN_COMMENT_SINGLE, until(now));
          }
          else {
            ++now;
          }
        }
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rsi), %r13
addq $0x2, %r13
leaq 0x18(%rsp), %rbp
movl $0x2401, %ecx           # imm = 0x2401
leaq 0x8(%rsp), %r15
movq 0x80(%r14), %rsi
movzbl (%rsi,%r13), %r12d
cmpl $0xd, %r12d
ja 0x7555
btl %r12d, %ecx
jae 0x7555
leaq (%rsi,%r13), %rdx
addq 0x90(%r14), %rsi
movq %rbp, 0x8(%rsp)
movq %r15, %rdi
callq 0x770a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x46, %edx
movq %r15, %rcx
callq 0x7690
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x754e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl $0x2401, %ecx           # imm = 0x2401
jmp 0x7558
incq %r13
cmpl $0xd, %r12d
ja 0x74f4
btl %r12d, %ecx
jae 0x74f4
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7590
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::handleRegex()
Token handleRegex () {
        size_t now = _position + 1;
       /* 
    if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
328         joined = joined.replace(/^[\\\/]{2,}/, '\\');
329       }
330 
*/

        while (true) {
          char n = _input[now];
          if (n == '\\') {
            ++now;
          }
          else if (n == '/') {
            ++now;
            break;
          }
          else if (n == '\0') {
            return makeToken(TOKEN_UNKNOWN);
          }
          ++now;
        }

        char n = _input[now];
        // modifier
        while (n >= 'a' && n <= 'z') {
          n = _input[++now];
        }

        //std::cout << "found regex " << std::string(_input + _position, now - _position) << std::endl;
        return makeToken(TOKEN_REGEX, until(now));
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rsi), %r15
incq %r15
movq 0x80(%r14), %rax
movzbl (%rax,%r15), %eax
testl %eax, %eax
je 0x75e1
cmpl $0x2f, %eax
je 0x75d7
cmpl $0x5c, %eax
jne 0x75d0
incq %r15
incq %r15
xorl %eax, %eax
jmp 0x75f3
incq %r15
movl $0x3, %eax
jmp 0x75f3
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6f46
movl $0x1, %eax
testl %eax, %eax
je 0x75b3
cmpl $0x3, %eax
jne 0x765e
movq 0x80(%r14), %rsi
leaq (%rsi,%r15), %rdx
decq %rdx
movb 0x1(%rdx), %al
incq %rdx
addb $-0x61, %al
cmpb $0x1a, %al
jb 0x760a
addq 0x90(%r14), %rsi
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x770a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4, %edx
movq %r15, %rcx
callq 0x7690
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x765e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7687
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O1/jsteemann[P]jshund/src/./Tokenizer.h
// Function: jshund::Tokenizer::makeToken(jshund::TokenType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Token makeToken (TokenType type, std::string const& v) {
        Token token;
        token.type  = type;
        token.line  = _line;
        token.value = v;
        
        _position += v.size();

        //std::cout << "token: " << type << "," << v << std::endl;

        return token;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %r12
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movl %edx, (%rdi)
movq 0x98(%rsi), %rax
movq %rax, 0x28(%rdi)
movq %r12, %rdi
movq %rcx, %rsi
callq 0x2120
movq 0x8(%rbx), %rax
addq %rax, 0x90(%r14)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x7702
movq (%r13), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/quiath[P]fast-atoi/main.cpp
// Function: atoisimple(char const*)
myint atoisimple(const char *b)
{
    myint res = 0; // Initialize result
    int sgn = 1;

    // Skip whitespace
    for (; isspace_fast(*b); ++b);

    if (*b == '-')
    {
        sgn = -1;
        ++b;
    } 
    else if (*b == '+')
    {
        ++b;
    }

    // Iterate through all characters of input string and update result
    for (; *b != 0; ++b)
    {
        if (*b < '0' || *b > '9')  
        {
            return sgn * res;
        }
        res = res * 10 + *b - '0';
    }

    // return result.
    return sgn * res;
}

// Assembly:
movzbl (%rdi), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jae 0x247c
incq %rdi
jmp 0x246c
cmpl $0x20, %eax
je 0x2477
cmpl $0x2b, %eax
je 0x2497
cmpl $0x2d, %eax
jne 0x249a
incq %rdi
movq $-0x1, %rcx
jmp 0x249f
incq %rdi
movl $0x1, %ecx
movb (%rdi), %dl
leal -0x3a(%rdx), %eax
cmpb $-0xa, %al
jae 0x24ac
xorl %eax, %eax
jmp 0x24cb
incq %rdi
xorl %eax, %eax
leaq (%rax,%rax,4), %rax
movzbl %dl, %edx
leaq -0x30(%rdx,%rax,2), %rax
movb (%rdi), %dl
leal -0x3a(%rdx), %esi
incq %rdi
cmpb $-0xb, %sil
ja 0x24b1
imulq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/quiath[P]fast-atoi/main.cpp
// Function: fastatoi(char const*)
myint fastatoi(const char *b)
{
    myint res = 0; // Initialize result
    int sgn = 1;

    // Skip whitespace
    for (; isspace_fast(*b); ++b);

    if (*b == '-')
    {
        sgn = -1;
        ++b;
    } 
    else if (*b == '+')
    {
        ++b;
    }

    // Iterate through all characters of input string and update result
    for (; *b != 0; ++b)
    {
        unsigned d = static_cast<unsigned>(*b) - '0';
        if (d > 9) 
        {
            return sgn * res;
        }
        res = res * 10 + d;
    }

    // return result.
    return sgn * res;
}

// Assembly:
movzbl (%rdi), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jae 0x24e0
incq %rdi
jmp 0x24d0
cmpl $0x20, %eax
je 0x24db
cmpl $0x2b, %eax
je 0x24fb
cmpl $0x2d, %eax
jne 0x24fe
incq %rdi
movq $-0x1, %rcx
jmp 0x2503
incq %rdi
movl $0x1, %ecx
movb (%rdi), %sil
testb %sil, %sil
je 0x2542
incq %rdi
xorl %edx, %edx
movsbl %sil, %esi
addl $-0x30, %esi
cmpl $0xa, %esi
jae 0x2529
leaq (%rdx,%rdx,4), %rdx
movl %esi, %r8d
leaq (%r8,%rdx,2), %rdx
jmp 0x2530
movq %rdx, %rax
imulq %rcx, %rax
cmpl $0xa, %esi
jae 0x254b
movb (%rdi), %sil
incq %rdi
testb %sil, %sil
jne 0x2510
jmp 0x2544
xorl %edx, %edx
imulq %rcx, %rdx
movq %rdx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/quiath[P]fast-atoi/main.cpp
// Function: fastatoiadd(char const*)
myint fastatoiadd(const char *b)
{
    myint res = 0; // Initialize result

    // Skip whitespace
    for (; isspace_fast(*b); ++b);

    if (*b == '-')
    {
        ++b;
        // Iterate through all characters of input string and update result
        for (; ; ++b)
        {
            unsigned d = static_cast<unsigned>(*b) - '0';
            if (d > 9) 
            {
                return res;
            }
            res = res * 10 - d;
        }

    } 
    else if (*b == '+')
    {
        ++b;
    }
    
    // Iterate through all characters of input string and update result
    for (; ; ++b)
    {
        unsigned d = static_cast<unsigned>(*b) - '0';
        if (d > 9) 
        {
            return res;
        }
        res = res * 10 + d;
    }

    //  unreachable
    return res;
}

// Assembly:
movzbl (%rdi), %eax
leal -0x9(%rax), %ecx
cmpl $0x5, %ecx
jae 0x255c
incq %rdi
jmp 0x254c
cmpl $0x20, %eax
je 0x2557
cmpl $0x2b, %eax
je 0x2596
cmpl $0x2d, %eax
jne 0x2599
incq %rdi
xorl %ecx, %ecx
movsbl (%rdi), %edx
addl $-0x30, %edx
leaq (%rcx,%rcx), %rsi
leaq (%rsi,%rsi,4), %rsi
subq %rdx, %rsi
incq %rdi
cmpl $0xa, %edx
cmovaeq %rcx, %rsi
cmovaeq %rcx, %rax
movq %rsi, %rcx
jb 0x2570
jmp 0x25c7
incq %rdi
movsbl (%rdi), %ecx
addl $-0x30, %ecx
cmpl $0x9, %ecx
ja 0x25c8
incq %rdi
xorl %eax, %eax
xorl %edx, %edx
leaq (%rdx,%rdx,4), %rdx
movl %ecx, %ecx
leaq (%rcx,%rdx,2), %rdx
movsbl (%rdi), %ecx
addl $-0x30, %ecx
incq %rdi
cmpl $0xa, %ecx
cmovaeq %rdx, %rax
jb 0x25ab
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/SilentAssassinMa[P]Sudoku-Solver/main.cpp
// Function: main
int main(int argc, char **argv)
{
    if (argc != 2)
    {
        std::cout << " Usage : " << argv[0] << " inputfilename" << std::endl;
        return 0;
    }

    clock_t time_start = clock();
    SudokuSolver solver1(argv[1]);
    SudokuSolver solver2(argv[1]);
    solver1.BackTracking();
    solver2.SimulatedAnnealing(0.1, 1e9);
    clock_t time_end = clock();
    std::cout << "Time use : " << double(time_end - time_start) / CLOCKS_PER_SEC << "s" << std::endl;

    return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x638, %rsp            # imm = 0x638
movq %rsi, %r14
cmpl $0x2, %edi
jne 0x24bb
callq 0x20f0
movq %rax, %rbx
movq 0x8(%r14), %rsi
leaq 0x320(%rsp), %rdi
callq 0x2584
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2584
leaq 0x320(%rsp), %rdi
callq 0x27ea
leaq 0x8(%rsp), %rdi
movsd 0x1bf5(%rip), %xmm0     # 0x4008
movl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
callq 0x2d48
callq 0x20f0
movq %rax, %r14
movq 0x3bac(%rip), %rdi      # 0x5fd8
leaq 0x1bfe(%rip), %rsi      # 0x4031
movl $0xb, %edx
callq 0x2190
subq %rbx, %r14
xorps %xmm0, %xmm0
cvtsi2sd %r14, %xmm0
divsd 0x1bc0(%rip), %xmm0     # 0x4010
movq 0x3b81(%rip), %rdi      # 0x5fd8
callq 0x21d0
movq %rax, %rbx
leaq 0x1bd7(%rip), %rsi      # 0x403d
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x8(%rsp), %rdi
callq 0x279a
leaq 0x320(%rsp), %rdi
callq 0x279a
movl $0x1, %eax
jmp 0x254e
movq 0x3b16(%rip), %rbx      # 0x5fd8
leaq 0x1b4f(%rip), %rsi      # 0x4018
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2190
movq (%r14), %r14
testq %r14, %r14
je 0x24fa
movq %r14, %rdi
callq 0x20a0
movq 0x3aeb(%rip), %rdi      # 0x5fd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x2190
jmp 0x2511
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x2200
leaq 0x1b0a(%rip), %rsi      # 0x4022
movl $0xe, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorl %eax, %eax
addq $0x638, %rsp            # imm = 0x638
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x256d
jmp 0x2560
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x279a
leaq 0x320(%rsp), %rdi
callq 0x279a
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O1/SilentAssassinMa[P]Sudoku-Solver/SudokuSolver.cpp
// Function: SudokuSolver::PrintSudoku(int*)
void SudokuSolver::PrintSudoku(int *sudoku)
{
    for (int i = 1; i <= 9; i++)
    {
        if (i % 3 == 1)
        {
            cout << "+-----+-----+-----+" << endl;
        }
        cout << "|";
        for (int j = 1; j <= 9; j++)
        {
            if (j % 3 == 0)
            {
                cout << FindElement(sudoku, i, j) << "|";
            }
            else
            {
                cout << FindElement(sudoku, i, j) << " ";
            }
        }
        cout << endl;
    }
    cout << "+-----+-----+-----+" << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl $0x1, %eax
movq 0x2872(%rip), %r12      # 0x5fd8
leaq 0xa04(%rip), %r15       # 0x4171
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movq %rax, (%rsp)
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
addl $0x55555555, %eax       # imm = 0x55555555
cmpl $0x55555554, %eax       # imm = 0x55555554
ja 0x37c9
movl $0x13, %edx
movq %r12, %rdi
leaq 0x9c1(%rip), %rsi       # 0x415d
callq 0x2190
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl $0x1, %r13d
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2190
xorl %r15d, %r15d
movq %r13, %rax
mulq %rbp
shrq %rdx
movq %rbp, %rbx
leal (%rdx,%rdx,2), %ebp
decl %ebp
movl (%r14,%r15,4), %esi
movq %r12, %rdi
callq 0x2210
cmpl %r15d, %ebp
movq %rbx, %rbp
leaq 0x814(%rip), %rsi       # 0x4020
leaq 0x95e(%rip), %rcx       # 0x4171
cmoveq %rcx, %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
incq %r13
incq %r15
cmpq $0x9, %r15
jne 0x37e2
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq (%rsp), %rax
incq %rax
addq $0x24, %r14
cmpq $0xa, %rax
leaq 0x903(%rip), %r15       # 0x4171
jne 0x3777
leaq 0x8e2(%rip), %rsi       # 0x415d
movl $0x13, %edx
movq %r12, %rdi
callq 0x2190
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/intheswim[P]FractalTubes/main.cpp
// Function: getMultispampleXVisual(_XDisplay*, int)
XVisualInfo * getMultispampleXVisual (Display *dpy, int screen)
{
    XVisualInfo *vi = NULL;

    int attribs [ 100 ] ;
    memcpy( attribs, Visual_attribs, sizeof( Visual_attribs ) );

    GLXFBConfig fbconfig = 0;
    int         fbcount;
    GLXFBConfig *fbc = glXChooseFBConfig( dpy, screen, attribs, &fbcount );
    if ( fbc )
    {
        if ( fbcount >= 1 )
            fbconfig = fbc[0];
        XFree( fbc );
    }

    if ( !fbconfig )
    {
        fprintf(stderr, "Failed to get MSAA GLXFBConfig\n" );
        return NULL;
    }  
    
    vi = glXGetVisualFromFBConfig( dpy, fbconfig );

    return vi;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %esi, %eax
movq %rdi, %rbx
leaq 0x57be(%rip), %rsi      # 0x9010
leaq 0x10(%rsp), %rdx
movl $0xd, %ecx
movq %rdx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movl $0x0, 0x68(%rdx)
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq 0x3450
testq %rax, %rax
je 0x3889
cmpl $0x0, 0xc(%rsp)
jle 0x388e
movq (%rax), %r14
jmp 0x3891
xorl %r14d, %r14d
jmp 0x3899
xorl %r14d, %r14d
movq %rax, %rdi
callq 0x33e0
testq %r14, %r14
je 0x38b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3490
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
callq 0x3670
xorl %eax, %eax
jmp 0x38a9
// File: /workspace/github_cpp_makefile_star2_O1/intheswim[P]FractalTubes/infra.cpp
// Function: closeLog()
void closeLog ()
{
#ifndef _DEBUG
   if (log1)
   {
      fputs ("Closing log\n", log1);
      fclose (log1);
      log1 = 0;
   }
#endif
}

// Assembly:
movq 0x8294(%rip), %rsi      # 0xc4a8
testq %rsi, %rsi
je 0x4241
pushq %rax
leaq 0x516b(%rip), %rdi      # 0x938c
callq 0x3350
movq 0x827b(%rip), %rdi      # 0xc4a8
callq 0x32e0
movq $0x0, 0x826b(%rip) # 0xc4a8
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/intheswim[P]FractalTubes/infra.cpp
// Function: setFrameSizeForGL(int, int)
void setFrameSizeForGL (int width, int height)
{    
    screen_height = height;
    screen_width = width;
	
	// Reshape
	glViewport( 0, 0, width, height );
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();
	
    gluPerspective( 45.0f, (float)width / (float)height, 0.1f, 100.0f );
    
	glMatrixMode( GL_MODELVIEW );
	glLoadIdentity();	
}

// Assembly:
pushq %rax
movl %esi, %ecx
movl %edi, %edx
cvtsi2ss %esi, %xmm0
cvtsi2ss %edi, %xmm1
divss %xmm0, %xmm1
movss %xmm1, 0x4(%rsp)
xorl %edi, %edi
xorl %esi, %esi
callq 0x30d0
movl $0x1701, %edi           # imm = 0x1701
callq 0x3440
callq 0x3400
xorps %xmm1, %xmm1
cvtss2sd 0x4(%rsp), %xmm1
movsd 0x4f96(%rip), %xmm0     # 0x9238
movsd 0x4f96(%rip), %xmm2     # 0x9240
movsd 0x4f96(%rip), %xmm3     # 0x9248
callq 0x3390
movl $0x1700, %edi           # imm = 0x1700
callq 0x3440
popq %rax
jmp 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/intheswim[P]FractalTubes/infra.cpp
// Function: freePoints()
static void freePoints()
{
    if (m3d_pt_count > 0)
    {
        delete[] pointData;
        delete[] corePoints;
        
        corePoints = NULL;
    }
    
    m3d_pt_count = 0;
}

// Assembly:
cmpq $0x0, 0x70a2(%rip)      # 0xc4e0
jle 0x5472
pushq %rax
movq 0x7068(%rip), %rdi      # 0xc4b0
testq %rdi, %rdi
je 0x5452
callq 0x33f0
movq 0x705f(%rip), %rdi      # 0xc4b8
testq %rdi, %rdi
je 0x5463
callq 0x33f0
movq $0x0, 0x704a(%rip) # 0xc4b8
addq $0x8, %rsp
movq $0x0, 0x7063(%rip) # 0xc4e0
retq
// File: /workspace/github_cpp_makefile_star2_O1/intheswim[P]FractalTubes/infra.cpp
// Function: GetConfig()
void GetConfig (void)
{
    m3d_pt_count = 0;
    current_set_index = 0;
        
    if (m_Preview == NO)
    {
        current_set_index = -1;
        selectNextImage();
    }
        
    corePoints = NULL;
                                
    srand ((unsigned int)time(NULL));
        
    stdAlpha = AppParams::getTransparency();
        
    rotationSpeed = AppParams::getRotationSpeed() * 0.01f;
        
    detailLevel = AppParams::getDetailValue();
        
    lightOption = AppParams::getLightSource();
        
    paletteOption = AppParams::getPalette();
        
    USE_LIGHT = AppParams::getLightMoving();
        
    rolloverPeriod = AppParams::getIntervalInSecs();
}

// Assembly:
pushq %rax
movq $0x0, 0x6df8(%rip) # 0xc4e0
movl $0x0, 0x6e0a(%rip)      # 0xc4fc
cmpb $0x0, 0x6dc7(%rip)      # 0xc4c0
jne 0x570a
movl $0xffffffff, 0x6df7(%rip) # imm = 0xFFFFFFFF
callq 0x5555
movq $0x0, 0x6da3(%rip) # 0xc4b8
xorl %edi, %edi
callq 0x32a0
movl %eax, %edi
callq 0x32c0
callq 0x800c
movss %xmm0, 0x6dc0(%rip)     # 0xc4f0
callq 0x8068
mulss 0x3bf3(%rip), %xmm0     # 0x9330
movss %xmm0, 0x6daf(%rip)     # 0xc4f4
callq 0x80e6
movss %xmm0, 0x6da6(%rip)     # 0xc4f8
callq 0x8146
callq 0x8224
callq 0x8278
movb %al, 0x6d69(%rip)       # 0xc4d0
callq 0x82e2
cvttss2si %xmm0, %rax
movq %rax, 0x6d88(%rip)      # 0xc500
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::GetExactColor(int, int)
DWORD M3DDrawer::GetExactColor (int cnt, int fraction)
{
	long color;
    
	if (cnt > 0 && cnt < 256)
    {
        cnt = fraction + ((cnt - 1) << 4) ;
        color = (cnt & 255) ;
        cnt = cnt >> 4;
    }
    else
        color = (cnt & 15) << 4 ;
    
    color += ((cnt & 48) << 10);
    
    color += ((cnt & 192) << 16);
    
    return alternate_palette ? TransformColor (color, pal_case) : color;
}

// Assembly:
leal -0x1(%rsi), %ecx
movl %esi, %eax
shll $0x4, %eax
cmpl $0xfe, %ecx
ja 0x5f3b
leal (%rax,%rdx), %esi
addl $-0x10, %esi
movzbl %sil, %eax
sarl $0x4, %esi
jmp 0x5f40
andl $0xf0, %eax
movl %esi, %ecx
andl $0x30, %ecx
shll $0xa, %ecx
orl %eax, %ecx
shll $0x10, %esi
andl $0xc00000, %esi         # imm = 0xC00000
orl %ecx, %esi
cmpb $0x1, 0x68(%rdi)
jne 0x5f68
movl 0x6c(%rdi), %eax
movq %rsi, %rdi
movl %eax, %esi
jmp 0x5f6c
movq %rsi, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/intheswim[P]FractalTubes/m3d.cpp
// Function: M3DDrawer::TransformColor(long, int)
long M3DDrawer::TransformColor (long color, int pal_case)
{
	int red, green, blue;

	red = color & 0xff;
	green = (color >> 8) & 0xff;
	blue = (color >> 16) & 0xff;
 
	if (((blue>>6) > 0) && ((blue >> 6) < 4) && green==0)
    {
		green = red >> 2;
        
		if (pal_case == 0)
        {
			blue -= (63 - (red >> 2));
        }
		else if (pal_case == 1)
        {
			if ((blue >> 6) == 3)
				blue -= (63 - (red >> 2));
			else if ((blue >> 6) == 1)
				blue += (63 - (red >> 2));
        }
		else if (pal_case == 2)
        {
			if ((blue >> 6) == 3)
				blue += (63 - (red >> 2));
			else if ((blue >> 6) == 1)
				blue -= (63 - (red >> 2));
        }
        
		red = 0;
		
		color = red + (blue << 16) + (green << 8);
		//green += (red >> 1);
    } 
    
	return color;
}

// Assembly:
movq %rdi, %rax
movl %eax, %ecx
shrl $0x10, %ecx
movzbl %cl, %ecx
cmpl $0x40, %ecx
setb %dl
testl $0xff00, %eax           # imm = 0xFF00
setne %dil
orb %dl, %dil
jne 0x5fd6
movl %ecx, %edx
shrl $0x6, %edx
shrl $0x2, %eax
andl $0x3f, %eax
cmpl $0x2, %esi
je 0x5fb2
cmpl $0x1, %esi
je 0x5fa6
testl %esi, %esi
je 0x5fc5
jmp 0x5fcc
cmpl $0x1, %edx
je 0x5fbc
cmpl $0x3, %edx
je 0x5fc5
jmp 0x5fcc
cmpl $0x1, %edx
je 0x5fc5
cmpl $0x3, %edx
jne 0x5fcc
movl %eax, %edx
xorl $0x3f, %edx
addl %edx, %ecx
jmp 0x5fcc
movl %eax, %edx
xorl $0x3f, %edx
subl %edx, %ecx
shll $0x10, %ecx
shll $0x8, %eax
orl %ecx, %eax
cltq
retq
nop