LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ahupp[P]mural/search.cpp
// Function: find_all_fuzzy_matches(std::vector<TagInfo, std::allocator<TagInfo>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
vector<FuzzyMatch> find_all_fuzzy_matches(const vector<TagInfo>& tags,
                                          const string& query,
                                          const bool ignore_case) {
  // Searches that don't explicitly look like a method ("::") will
  // never include methods, and vice-versa.
  bool methods_only = is_method_tag(query);

  vector<FuzzyMatch> matches;

  for (size_t i = 0; i < tags.size(); ++i) {
    int inter_count;
    const TagInfo& tag = tags[i];

    if (tag.is_method != methods_only) {
      // could split the tags into method and non-method sets and only
      // search one, but right now it's fast enough.
      continue;
    }

    if (is_fuzzy_match(ignore_case ? tag.symbol_lc : tag.symbol,
                       query, &inter_count)) {
      // Passing &tag here is an important perf optimization to avoid
      // excessive copying when there are many possible results (like
      // "A")
      matches.push_back(make_pair(&tag, inter_count));
    }
  }
  return matches;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r14d
movq %rsi, %r12
movq %rdi, %rbx
movq %rdx, 0x18(%rsp)
movq %rdx, %rdi
callq 0x3584
movl %eax, %ebp
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movq %rbx, 0x8(%rsp)
movups %xmm0, (%rbx)
shll $0x5, %r14d
movq %r14, 0x20(%rsp)
xorl %r13d, %r13d
pushq $0x68
popq %rbx
xorl %r15d, %r15d
movq (%r12), %r14
movq 0x8(%r12), %rax
subq %r14, %rax
cqto
idivq %rbx
cmpq %rax, %r15
jae 0x2bfc
cmpb %bpl, 0x64(%r14,%r13)
jne 0x2bf3
movq 0x20(%rsp), %rax
leaq (%r14,%rax), %rdi
addq %r13, %rdi
movq 0x18(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x2ad4
testb %al, %al
je 0x2bf3
addq %r13, %r14
movl 0x14(%rsp), %eax
movq %r14, 0x28(%rsp)
movl %eax, 0x30(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2e0a
incq %r15
addq $0x68, %r13
jmp 0x2b98
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x2dd6
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/ahupp[P]mural/search.cpp
// Function: find_best_fuzzy_matches(std::vector<TagInfo, std::allocator<TagInfo>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
vector<TagInfo> find_best_fuzzy_matches(const vector<TagInfo>& tags,
                                        const string& query,
                                        const size_t max_items) {

  bool ignore_case = query == lowercase(query);

  vector<FuzzyMatch> matches = find_all_fuzzy_matches(tags, query, ignore_case);
  if (matches.size() == 0 && !ignore_case) {
    matches = find_all_fuzzy_matches(tags, lowercase(query), true);
  }
  size_t limit = min(max_items, matches.size());
  partial_sort(matches.begin(), matches.begin()+limit, matches.end(),
               is_better_match);

  vector<TagInfo> result;
  for (size_t i = 0; i < limit; ++i) {
    result.push_back(*(matches[i].first));
  }

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x359c
movq %r12, %rdi
movq %r13, %rsi
callq 0x2d81
movl %eax, %ebp
movq %r13, %rdi
callq 0x20e0
movzbl %bpl, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x2b50
movq (%r13), %rdi
movq 0x8(%r13), %rdx
cmpq %rdi, %rdx
setne %al
orb %al, %bpl
jne 0x2ce0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x359c
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
pushq $0x1
popq %rcx
movq %r15, %rsi
callq 0x2b50
leaq 0x8(%rsp), %r15
leaq 0x40(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f96
movq %r12, %rdi
callq 0x2dd6
leaq 0x20(%rsp), %rdi
callq 0x20e0
movq (%r15), %rdi
movq 0x8(%r15), %rdx
movq %rdx, %r15
subq %rdi, %r15
sarq $0x4, %r15
cmpq %r14, %r15
cmovaeq %r14, %r15
movq %r15, %rsi
shlq $0x4, %rsi
addq %rdi, %rsi
leaq -0x1d1(%rip), %rcx      # 0x2b31
callq 0x2fe7
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
xorl %r14d, %r14d
subq $0x1, %r15
jb 0x2d32
movq 0x8(%rsp), %rax
movq (%rax,%r14), %rsi
movq %rbx, %rdi
callq 0x2daa
addq $0x10, %r14
jmp 0x2d15
leaq 0x8(%rsp), %rdi
callq 0x2dd6
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x20e0
jmp 0x2d6f
jmp 0x2d5f
movq %rax, %r14
jmp 0x2d6f
movq %rax, %r14
movq %rbx, %rdi
callq 0x2954
leaq 0x8(%rsp), %rdi
callq 0x2dd6
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x2270
xorl %r14d, %r14d
cmpq 0x8(%rbx), %r14
jae 0x35c8
movq (%rbx), %r15
movsbl (%r15,%r14), %edi
callq 0x22a0
movb %al, (%r15,%r14)
incq %r14
jmp 0x35ac
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %r12d, %r12d
movsbl %dl, %ebp
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x2260
cmpq $-0x1, %rax
je 0x3640
movq %rax, %r13
movq %rax, %rcx
subq %r12, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2200
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3de8
movq %r15, %rdi
callq 0x20e0
incq %r13
movq %r13, %r12
jmp 0x35fb
movq 0x8(%r14), %rcx
subq %r12, %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2200
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3de8
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3689
jmp 0x3684
movq %rax, %r14
jmp 0x3696
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x3c8a
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0x4
popq %rsi
callq 0x22f0
testl %eax, %eax
jne 0x3c2f
movq %rbx, %rdi
callq 0x3d22
movq (%r14), %rsi
leaq 0x20(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2340
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2060
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2240
cmpq $0x0, 0x8(%rsp)
je 0x3c05
movq (%rsp), %rax
cmpb $0x21, (%rax)
jne 0x3c05
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x36a6
jmp 0x3c12
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x3915
movq %rsp, %rdi
callq 0x20e0
leaq 0x20(%rsp), %rdi
callq 0x2070
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq 0x43ba(%rip), %rdi      # 0x7ff0
leaq 0x14b0(%rip), %rsi      # 0x50ed
callq 0x21d0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21a0
leaq 0x14a1(%rip), %rsi      # 0x50f5
movq %rax, %rdi
callq 0x21d0
movq %rax, %rdi
callq 0x2100
pushq $0x1
popq %rdi
callq 0x2220
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20e0
leaq 0x20(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/jsteemann[P]jshund/src/jshund.cpp
// Function: Bark()
static void Bark () {
  std::cout << "   _     _                     _  " << std::endl;
  std::cout << "  (_)___| |__  _   _ _ __   __| | " << std::endl;
  std::cout << "  | / __| '_ \\| | | | '_ \\ / _` | " << std::endl;
  std::cout << "  | \\__ \\ | | | |_| | | | | (_| | " << std::endl;
  std::cout << " _/ |___/_| |_|\\__,_|_| |_|\\__,_| " << std::endl;
  std::cout << "|__/                              " << std::endl;
  std::cout << std::endl;
}

// Assembly:
pushq %rbx
movq 0x8667(%rip), %rbx      # 0xafd0
leaq 0x4728(%rip), %rsi      # 0x7098
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
leaq 0x4734(%rip), %rsi      # 0x70bb
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
leaq 0x4740(%rip), %rsi      # 0x70de
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
leaq 0x474c(%rip), %rsi      # 0x7101
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
leaq 0x4758(%rip), %rsi      # 0x7124
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
leaq 0x4764(%rip), %rsi      # 0x7147
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x2100
movq %rbx, %rdi
popq %rbx
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x2b48
testb %al, %al
je 0x2aa8
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2dee
leaq 0x28(%rsp), %rdi
jmp 0x2ad7
movq %rbx, %rdi
callq 0x2b7c
testb %al, %al
je 0x2ae8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x22d0
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2bb0
leaq 0x8(%rsp), %rdi
callq 0x20f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8501(%rip), %rdi      # 0xaff0
leaq 0x4674(%rip), %rsi      # 0x716a
callq 0x21e0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
leaq 0x4892(%rip), %rsi      # 0x739f
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2100
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2b3a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xc
popq %rdx
movq %r14, %rdi
callq 0x2140
leaq 0x78(%rsp), %rdi
callq 0x2070
testb %al, %al
je 0x3066
movq %rsp, %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x22c0
movq %rsp, %rdi
callq 0x2360
movq %rax, %rbx
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22c0
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)
andl $0x0, (%rax,%rbx)
movq %rsp, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2280
movq %rsp, %rdi
callq 0x2060
jmp 0x3069
xorl %r14d, %r14d
movq %rsp, %rdi
callq 0x2090
movq %r14, %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
jmp 0x3085
jmp 0x3085
jmp 0x3085
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20e0
movq %rax, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
movq $0x1, 0x98(%rbx)
andl $0x0, 0x78(%rbx)
leaq 0x60(%rbx), %r14
movq %r14, %rdi
callq 0x5be8
movq %rbx, %rdi
callq 0x5bf0
cmpb $0x1, 0xa0(%rbx)
jne 0x4b06
xorl %r15d, %r15d
pushq $0x30
popq %r12
xorl %r13d, %r13d
movq 0x60(%rbx), %rdi
movq 0x68(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x4b06
addq %r15, %rdi
callq 0x5cc0
incq %r13
addq $0x30, %r15
jmp 0x4ae0
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x60(%rdi), %rsi
movq 0x5ec0(%rip), %rdi      # 0xafd0
callq 0x21c0
pushq $0x3a
popq %r12
movq %rax, %rdi
movl %r12d, %esi
callq 0x2260
movq %rax, %rdi
movl %r15d, %esi
callq 0x2350
movq %rax, %rdi
movl %r12d, %esi
callq 0x2260
movl %ebp, %ecx
xorb $0x1, %cl
movzbl %cl, %esi
shll $0x5, %esi
addq %rbx, %rsi
movq %rax, %rdi
callq 0x21c0
leaq 0x2228(%rip), %rsi      # 0x737f
movq %rax, %rdi
callq 0x21e0
leaq 0x2222(%rip), %rcx      # 0x7388
leaq 0x2222(%rip), %rsi      # 0x738f
testl %ebp, %ebp
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x21e0
leaq 0x2213(%rip), %rsi      # 0x7395
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
pushq $0x27
popq %rsi
movq %rax, %rdi
callq 0x2260
addq $0x40, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %r14
leaq 0x68(%rsp), %r15
leaq 0x38(%rsp), %rbx
leaq 0x30(%rsp), %r12
leaq 0x60(%rsp), %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x5d5a
movl 0x30(%rsp), %eax
testl %eax, %eax
je 0x5c57
cmpl $0x72, %eax
je 0x5c57
movq %r13, %rdi
movq %r12, %rsi
callq 0x508e
movq %r14, %rdi
movq %r13, %rsi
callq 0x5efe
movq %r15, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x20f0
jmp 0x5c17
movq %rbx, %rdi
callq 0x20f0
movq %rsp, %rbx
pushq $0x72
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f20
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5efe
leaq 0x8(%rsp), %rdi
callq 0x20f0
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x5cb3
movq %rax, %r14
movq %r15, %rdi
callq 0x20f0
jmp 0x5cb0
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
movl %edx, (%rdi)
movq 0x98(%rsi), %rax
movq %rax, 0x28(%rdi)
leaq 0x1461(%rip), %rsi      # 0x73b5
movq %rbx, %rdi
callq 0x23a0
incq 0x90(%r14)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq 0x90(%rdi), %rcx
movq 0x98(%rdi), %rdx
leaq 0x1068(%rip), %rsi      # 0x7004
movzbl (%rax,%rcx), %r8d
cmpq $0xd, %r8
ja 0x5fc7
movslq (%rsi,%r8,4), %r8
addq %rsi, %r8
jmpq *%r8
cmpb $0xa, 0x1(%rax,%rcx)
jne 0x5fcd
incq %rcx
incq %rdx
movq %rdx, 0x98(%rdi)
jmp 0x5fcd
cmpl $0x20, %r8d
jne 0x5fd9
incq %rcx
movq %rcx, 0x90(%rdi)
jmp 0x5f9c
movb $0x1, %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rcx
movq 0x90(%rsi), %rdx
movb 0x1(%rcx,%rdx), %sil
cmpb $0x5c, %sil
jne 0x6010
addq $0x2, %rdx
jmp 0x5fff
cmpb %al, %sil
je 0x602c
incq %rdx
testb %sil, %sil
jne 0x5fff
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5f20
jmp 0x6057
addq $0x2, %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x64ec
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x6480
movq %rsp, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x90(%rsi), %r12
movb $0x1, %bpl
leaq 0x20(%rsp), %r15
movq 0x80(%r14), %rsi
movzbl (%rsi,%r12), %eax
leal -0x61(%rax), %ecx
cmpb $0x1a, %cl
jae 0x60cb
movsbl %al, %esi
movq %r15, %rdi
callq 0x21a0
jmp 0x60ee
leal -0x41(%rax), %ecx
cmpb $0x1a, %cl
setae %cl
leal -0x30(%rax), %edx
cmpb $0xa, %dl
setae %dl
testb %dl, %cl
jne 0x60f3
movsbl %al, %esi
movq %r15, %rdi
callq 0x21a0
xorl %ebp, %ebp
incq %r12
jmp 0x60aa
cmpl $0x5f, %eax
je 0x60be
cmpl $0x24, %eax
je 0x60be
testb $0x1, %bpl
je 0x6159
leaq 0x30(%r14), %rdi
leaq 0x20(%rsp), %rsi
callq 0x65ac
leaq 0x38(%r14), %rdi
movq 0x80(%r14), %rsi
movq 0x90(%r14), %rcx
movq 0x28(%rsp), %rdx
cmpq %rdi, %rax
je 0x6165
movl 0x40(%rax), %ebp
addq %rcx, %rsi
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x6516
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x6480
jmp 0x6190
movq 0x90(%r14), %rcx
movq 0x28(%rsp), %rdx
addq %rsi, %rcx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
addq %rcx, %rdx
movq %rsp, %rdi
movq %rcx, %rsi
callq 0x6516
pushq $0x4b
popq %rdx
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6480
movq %rsp, %rdi
callq 0x20f0
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x61b8
jmp 0x61c7
jmp 0x61c7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20f0
jmp 0x61ca
jmp 0x61c7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rax
movq 0x90(%rsi), %rdx
xorl %ecx, %ecx
xorl %esi, %esi
movb (%rax,%rdx), %dil
leal -0x30(%rdi), %r8d
cmpb $0xa, %r8b
jb 0x6233
cmpb $0x2e, %dil
jne 0x621c
testb $0x1, %sil
movb $0x1, %sil
je 0x6233
jmp 0x6238
andb $-0x21, %dil
cmpb $0x45, %dil
setne %dil
orb %cl, %dil
movb $0x1, %cl
testb $0x1, %dil
jne 0x6238
incq %rdx
jmp 0x61fd
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x64ec
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x6480
movq %rsp, %rdi
callq 0x20f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rax
movq 0x90(%rsi), %rdx
addq $0x2, %rdx
movq 0x98(%rsi), %rcx
incq %rdx
movzbl -0x1(%rax,%rdx), %esi
cmpl $0xd, %esi
je 0x62d0
cmpl $0xa, %esi
je 0x62d0
cmpb $0x2a, %sil
jne 0x62c6
cmpb $0x2f, (%rax,%rdx)
je 0x62dc
incq %rdx
testb %sil, %sil
jne 0x62ab
jmp 0x6308
incq %rcx
movq %rcx, 0x98(%r14)
jmp 0x62a8
incq %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x64ec
pushq $0x47
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x6480
movq %rsp, %rdi
callq 0x20f0
jmp 0x6315
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5f20
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %r15
addq $0x2, %r15
movl $0x2401, %r13d          # imm = 0x2401
leaq 0x8(%rsp), %r12
movq 0x80(%r14), %rax
movzbl (%rax,%r15), %ebp
cmpl $0xd, %ebp
ja 0x63a0
btl %ebp, %r13d
jae 0x63a0
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x64ec
movq %rbx, %rdi
movq %r14, %rsi
pushq $0x46
popq %rdx
movq %r12, %rcx
callq 0x6480
movq %r12, %rdi
callq 0x20f0
jmp 0x63a3
incq %r15
cmpl $0xd, %ebp
ja 0x6360
btl %ebp, %r13d
jae 0x6360
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x80(%rsi), %rax
movq 0x90(%rsi), %rsi
movq %rsi, %rdx
movzbl 0x1(%rax,%rsi), %ecx
cmpl $0x5c, %ecx
je 0x640f
testl %ecx, %ecx
je 0x6453
leaq 0x1(%rdx), %rsi
cmpl $0x2f, %ecx
jne 0x63f3
jmp 0x6418
addq $0x2, %rdx
movq %rdx, %rsi
jmp 0x63f3
incq %rdx
movb 0x1(%rax,%rdx), %cl
addb $-0x61, %cl
incq %rdx
cmpb $0x1a, %cl
jb 0x641b
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x64ec
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x6480
movq %rsp, %rdi
callq 0x20f0
jmp 0x6460
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x5f20
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %r12
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $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
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2469
incq %rdi
jmp 0x2459
cmpl $0x20, %eax
je 0x2464
cmpl $0x2b, %eax
je 0x247f
cmpl $0x2d, %eax
jne 0x2482
incq %rdi
pushq $-0x1
jmp 0x2484
incq %rdi
pushq $0x1
popq %rcx
xorl %eax, %eax
movsbl (%rdi), %edx
testl %edx, %edx
je 0x24a4
addl $-0x30, %edx
cmpl $0x9, %edx
ja 0x24a4
imulq $0xa, %rax, %rsi
movl %edx, %eax
incq %rdi
addq %rsi, %rax
jmp 0x2487
imulq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2413
callq 0x20e0
movq %rax, %rbx
movq 0x8(%r14), %rsi
leaq 0x320(%rsp), %rdi
callq 0x2480
movq 0x8(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2480
leaq 0x320(%rsp), %rdi
callq 0x2632
leaq 0x8(%rsp), %rdi
movsd 0x1c65(%rip), %xmm0     # 0x4008
movl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
callq 0x29a8
callq 0x20e0
movq %rax, %r14
movq 0x3c1c(%rip), %rdi      # 0x5fd8
leaq 0x1c6e(%rip), %rsi      # 0x4031
callq 0x2130
subq %rbx, %r14
cvtsi2sd %r14, %xmm0
divsd 0x1c38(%rip), %xmm0     # 0x4010
movq %rax, %rdi
callq 0x21a0
leaq 0x1c56(%rip), %rsi      # 0x403d
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
callq 0x25f0
leaq 0x320(%rsp), %rdi
callq 0x25f0
pushq $0x1
popq %rax
jmp 0x244a
movq 0x3bbe(%rip), %rdi      # 0x5fd8
leaq 0x1bf7(%rip), %rsi      # 0x4018
callq 0x2130
movq (%r14), %rsi
movq %rax, %rdi
callq 0x2130
leaq 0x1bea(%rip), %rsi      # 0x4022
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
callq 0x2090
xorl %eax, %eax
addq $0x638, %rsp            # imm = 0x638
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x2469
jmp 0x245c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25f0
leaq 0x320(%rsp), %rdi
callq 0x25f0
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/SilentAssassinMa[P]Sudoku-Solver/SudokuSolver.cpp
// Function: SudokuSolver::SudokuSolver(char const*)
SudokuSolver::SudokuSolver(const char *inputfilename)
{
    ifstream infile;
    infile.open(inputfilename, ios::in);

    for (int i = 0; i < 81; i++)
    {
        infile >> OriginalSudoku[i];
        if (OriginalSudoku[i] < 0 || OriginalSudoku[i] > 9)
        {
            cout << "Error : Input Sudoku Is Wrong !" << endl;
            isSolvable = false;
            return;
        }

        isChangeable[i] = OriginalSudoku[i] == 0 ? true : false;
        Current[i] = OriginalSudoku[i];
    }

    if (!CheckConsistency(OriginalSudoku))
    {
        cout << "Error : Input Sudoku Is Wrong !" << endl;
        isSolvable = false;
        return;
    }

    if (!CheckEmpty(OriginalSudoku))
    {
        cout << "Error : The Input Sudoku Has Already Been Fiiled Out" << endl;
        isSolvable = false;
        return;
    }

    infile.close();

    isSolvable = true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38c2(%rip), %rax      # 0x5d60
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movl $0x2d9, %edx            # imm = 0x2D9
movq %r14, %rdi
xorl %esi, %esi
callq 0x20b0
xorps %xmm0, %xmm0
movups %xmm0, 0x2e8(%rbx)
movups %xmm0, 0x2f8(%rbx)
movups %xmm0, 0x308(%rbx)
movq %rsp, %rdi
callq 0x2160
movq %rsp, %rdi
pushq $0x8
popq %rdx
movq %r15, %rsi
callq 0x20d0
leaq 0x290(%rbx), %r13
pushq $-0x51
popq %rbp
movq %rsp, %r15
movq %r14, %r12
testq %rbp, %rbp
je 0x2525
movq %r15, %rdi
movq %r12, %rsi
callq 0x20c0
movl -0x144(%r13,%rbp,4), %eax
cmpl $0xa, %eax
jae 0x2552
testl %eax, %eax
sete 0x51(%r13,%rbp)
movl %eax, (%r13,%rbp,4)
incq %rbp
addq $0x4, %r12
jmp 0x24f2
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rax)
testb %al, %al
je 0x256f
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x28(%rax)
testb %al, %al
je 0x2578
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x2030
jmp 0x2595
movq 0x3a7f(%rip), %rdi      # 0x5fd8
leaq 0x1b00(%rip), %rsi      # 0x4060
callq 0x2130
movq %rax, %rdi
callq 0x2090
jmp 0x2593
leaq 0x1aea(%rip), %rsi      # 0x4060
jmp 0x257f
leaq 0x1b01(%rip), %rsi      # 0x4080
movq 0x3a52(%rip), %rdi      # 0x5fd8
callq 0x2130
movq %rax, %rdi
callq 0x2090
xorl %ebp, %ebp
movb %bpl, 0x2e1(%rbx)
movq %rsp, %rdi
callq 0x2040
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25bf
movq %rax, %r14
jmp 0x25ca
jmp 0x25bf
movq %rax, %r14
movq %rsp, %rdi
callq 0x2040
leaq 0x2e8(%rbx), %r15
addq $0x300, %rbx            # imm = 0x300
movq %rbx, %rdi
callq 0x32cc
movq %r15, %rdi
callq 0x3376
movq %r14, %rdi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/SilentAssassinMa[P]Sudoku-Solver/SudokuSolver.cpp
// Function: SudokuSolver::CheckConsistency(int*)
bool SudokuSolver::CheckConsistency(int *sudoku)
{
    // loop over every column and row and subsquare
    for (int i = 1; i <= 9; i++)
    {
        int rowsum[10] = {0};
        int columnsum[10] = {0};
        for (int j = 1; j <= 9; j++)
        {
            if (FindElement(sudoku, i, j) != 0)
            {
                columnsum[FindElement(sudoku, i, j)]++;
                if (columnsum[FindElement(sudoku, i, j)] > 1)
                    return false;
            }
            if (FindElement(sudoku, j, i) != 0)
            {
                rowsum[FindElement(sudoku, j, i)]++;
                if (rowsum[FindElement(sudoku, j, i)] > 1)
                    return false;
            }

            if ((i % 3) == 1 && (j % 3) == 1)
            {
                int subsquaresum[10] = {0};
                for (int m = 0; m < 3; m++)
                {
                    for (int n = 0; n < 3; n++)
                    {
                        if (FindElement(sudoku, i + m, j + n) != 0)
                        {
                            subsquaresum[FindElement(sudoku, i + m, j + n)]++;
                            if (subsquaresum[FindElement(sudoku, i + m, j + n)] > 1)
                                return false;
                        }
                    }
                }
            }
        }
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq -0x28(%rsi), %rdi
movabsq $0x1, %r8
xorps %xmm0, %xmm0
movl $0x3, %r9d
movq %r8, %rcx
cmpq $0xa, %rcx
je 0x2eb9
andq $0x0, (%rsp)
movaps %xmm0, -0x10(%rsp)
movaps %xmm0, -0x20(%rsp)
movaps %xmm0, -0x40(%rsp)
movaps %xmm0, -0x50(%rsp)
andq $0x0, -0x30(%rsp)
movl %ecx, %eax
xorl %edx, %edx
divl %r9d
imulq $0x24, %rcx, %r11
addq %rdi, %r11
leaq (%rdi,%rcx,4), %rbx
movq %rsi, %r14
movq %r8, %r15
cmpq $0xa, %r15
je 0x2ea7
movslq (%r11,%r15,4), %rax
testq %rax, %rax
je 0x2e12
movl -0x50(%rsp,%rax,4), %r12d
leal 0x1(%r12), %ebp
movl %ebp, -0x50(%rsp,%rax,4)
testl %r12d, %r12d
jg 0x2eb9
imulq $0x24, %r15, %rax
movslq (%rbx,%rax), %rax
testq %rax, %rax
je 0x2e36
movl -0x20(%rsp,%rax,4), %r12d
leal 0x1(%r12), %ebp
movl %ebp, -0x20(%rsp,%rax,4)
testl %r12d, %r12d
jg 0x2eb9
movzbl %r15b, %eax
movb $0x3, %r9b
divb %r9b
movzbl %ah, %eax
cmpl $0x1, %edx
jne 0x2e9b
cmpb $0x1, %al
jne 0x2e9b
andq $0x0, -0x60(%rsp)
movaps %xmm0, -0x70(%rsp)
movaps %xmm0, -0x80(%rsp)
movq %r14, %rax
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x2e9b
xorl %r13d, %r13d
cmpq $0x3, %r13
je 0x2e92
movslq (%rax,%r13,4), %rbp
testq %rbp, %rbp
je 0x2e8d
movl -0x80(%rsp,%rbp,4), %r9d
leal 0x1(%r9), %r10d
movl %r10d, -0x80(%rsp,%rbp,4)
testl %r9d, %r9d
jg 0x2eb9
incq %r13
jmp 0x2e6b
incq %r12
addq $0x24, %rax
jmp 0x2e62
incq %r15
addq $0x4, %r14
jmp 0x2de8
incq %rcx
addq $0x24, %rsi
movl $0x3, %r9d
jmp 0x2da7
cmpq $0xa, %rcx
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
pushq $0x1
popq %rax
movq 0x2de2(%rip), %r14      # 0x5fd8
pushq $0x3
popq %r15
cmpq $0xa, %rax
je 0x32a2
movq %rax, (%rsp)
movzbl %al, %eax
movb $0x3, %cl
divb %cl
movzbl %ah, %eax
cmpb $0x1, %al
jne 0x322d
movq %r14, %rdi
leaq 0xf3d(%rip), %rsi       # 0x415d
callq 0x2130
movq %rax, %rdi
callq 0x2090
movq %r14, %rdi
leaq 0xf3a(%rip), %rsi       # 0x4171
callq 0x2130
xorl %r12d, %r12d
pushq $0x1
popq %r13
movq %r13, %rax
xorl %edx, %edx
divq %r15
cmpq $0x9, %r12
je 0x328a
leaq (%rax,%rax,2), %rax
decq %rax
leaq 0xf12(%rip), %rbp       # 0x4171
cmpb %r12b, %al
je 0x326b
leaq 0xdb5(%rip), %rbp       # 0x4020
movl (%rbx,%r12,4), %esi
movq %r14, %rdi
callq 0x21d0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2130
incq %r13
incq %r12
jmp 0x3243
movq %r14, %rdi
callq 0x2090
movq (%rsp), %rax
incq %rax
addq $0x24, %rbx
jmp 0x31fa
movq 0x2d2f(%rip), %rdi      # 0x5fd8
leaq 0xead(%rip), %rsi       # 0x415d
callq 0x2130
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x588e(%rip), %rsi      # 0x9010
pushq $0x6c
popq %rcx
leaq 0x10(%rsp), %rdx
movq %rdx, %rdi
rep  movsb (%rsi), %es:(%rdi)
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq 0x3460
testq %rax, %rax
je 0x37d5
cmpl $0x0, 0xc(%rsp)
jle 0x37af
movq (%rax), %r14
jmp 0x37b2
xorl %r14d, %r14d
movq %rax, %rdi
callq 0x33e0
testq %r14, %r14
je 0x37d5
movq %rbx, %rdi
movq %r14, %rsi
callq 0x34a0
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq 0x9804(%rip), %rax      # 0xcfe0
movq (%rax), %rcx
leaq 0x5896(%rip), %rdi      # 0x907c
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
callq 0x3650
xorl %eax, %eax
jmp 0x37ca
// File: /workspace/github_cpp_makefile_star2_O2/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 0x942c(%rip), %rsi      # 0xd4b8
testq %rsi, %rsi
je 0x40b6
pushq %rax
leaq 0x5303(%rip), %rdi      # 0x939c
callq 0x3350
movq 0x9413(%rip), %rdi      # 0xd4b8
callq 0x32f0
andq $0x0, 0x9406(%rip)      # 0xd4b8
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3450
callq 0x3410
cvtss2sd 0x4(%rsp), %xmm1
movsd 0x5124(%rip), %xmm0     # 0x9238
movsd 0x5124(%rip), %xmm2     # 0x9240
movsd 0x5124(%rip), %xmm3     # 0x9248
callq 0x3390
movl $0x1700, %edi           # imm = 0x1700
callq 0x3450
popq %rax
jmp 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x8542(%rip)      # 0xd4f0
jle 0x4fdf
pushq %rax
movq 0x8508(%rip), %rdi      # 0xd4c0
testq %rdi, %rdi
je 0x4fc2
callq 0x33f0
movq 0x84ff(%rip), %rdi      # 0xd4c8
testq %rdi, %rdi
je 0x4fd3
callq 0x33f0
andq $0x0, 0x84ed(%rip)      # 0xd4c8
addq $0x8, %rsp
andq $0x0, 0x8509(%rip)      # 0xd4f0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0x82de(%rip)      # 0xd4f0
andl $0x0, 0x82f3(%rip)      # 0xd50c
cmpb $0x0, 0x82b0(%rip)      # 0xd4d0
jne 0x522e
orl $-0x1, 0x82e3(%rip)     # 0xd50c
callq 0x50c2
andq $0x0, 0x8292(%rip)      # 0xd4c8
xorl %edi, %edi
callq 0x32b0
movl %eax, %edi
callq 0x32d0
callq 0x780c
movss %xmm0, 0x82af(%rip)     # 0xd500
callq 0x7842
mulss 0x40d2(%rip), %xmm0     # 0x9330
movss %xmm0, 0x829e(%rip)     # 0xd504
callq 0x78b6
movss %xmm0, 0x8295(%rip)     # 0xd508
callq 0x78f4
callq 0x79cc
callq 0x7a0a
movb %al, 0x8258(%rip)       # 0xd4e0
callq 0x7a60
cvttss2si %xmm0, %rax
movq %rax, 0x8277(%rip)      # 0xd510
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5ceb
leal (%rax,%rdx), %esi
addl $-0x10, %esi
movzbl %sil, %eax
sarl $0x4, %esi
jmp 0x5cf0
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 0x5d18
movl 0x6c(%rdi), %eax
movq %rsi, %rdi
movl %eax, %esi
jmp 0x5d1c
movq %rsi, %rax
retq