LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AndreiBarsan[P]uShell/shell.cc
// Function: microshell::core::Shell::resolve_binary_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) const
bool Shell::resolve_binary_name(const string& name, string* full_path) const {
  // No lookup needed for absolute paths.
  if(util::is_absolute_path(name)) {
    *full_path = name;
    return true;
  }

  // Search in our current directory.
  {
    string path = util::merge_paths(working_directory, name);
    if(util::is_file(path)) {
      *full_path = path;
      return true;
    }
  }

  // Search the PATH.
  for(const string& p : this->path) {
    string path = util::merge_paths(p, name);
    if(util::is_file(path)) {
      *full_path = path;
      return true;
    }
  }

  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rdi
callq 0x202d0
testb $0x1, %al
jne 0x1b771
jmp 0x1b787
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x5060
movb $0x1, -0x1(%rbp)
jmp 0x1b90c
movq -0x98(%rbp), %rsi
addq $0x40, %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x20350
movq -0xa8(%rbp), %rdi
callq 0x20840
movb %al, -0x99(%rbp)
jmp 0x1b7ba
movb -0x99(%rbp), %al
testb $0x1, %al
jne 0x1b7c6
jmp 0x1b7fc
movq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5060
jmp 0x1b7d5
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x1b803
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5190
jmp 0x1b91a
movl $0x0, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5190
movl -0x50(%rbp), %eax
testl %eax, %eax
je 0x1b81a
jmp 0x1b815
jmp 0x1b90c
movq -0x98(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x8d60
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x8d90
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x90e0
testb $0x1, %al
jne 0x1b859
jmp 0x1b908
leaq -0x60(%rbp), %rdi
callq 0x9150
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x20350
movq -0xb8(%rbp), %rdi
callq 0x20840
movb %al, -0xa9(%rbp)
jmp 0x1b895
movb -0xa9(%rbp), %al
testb $0x1, %al
jne 0x1b8a1
jmp 0x1b8da
movq -0x20(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x5060
jmp 0x1b8b3
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x1b8e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5190
jmp 0x1b91a
movl $0x0, -0x50(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5190
movl -0x50(%rbp), %eax
testl %eax, %eax
je 0x1b8f8
jmp 0x1b8f6
jmp 0x1b90c
jmp 0x1b8fa
leaq -0x60(%rbp), %rdi
callq 0x9170
jmp 0x1b843
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5460
nopw %cs:(%rax,%rax)
// File: AndreiBarsan[P]uShell/shell.cc
// Function: int microshell::core::Shell::load_module<microshell::modules::sample_module::SampleModule>(std::shared_ptr<microshell::modules::sample_module::SampleModule>)
int Shell::load_module(shared_ptr<MODULE_TYPE> module) {
  module->initialize(*this);
  auto builtins = module->get_builtins();
  for(auto bf = builtins.begin(); bf != builtins.end(); ++bf) {
    // TODO(andrei) Use managed memory in builtin registry.
    // TODO(andrei) Builtin factories should know the builtin's name.
    BuiltinRegistry::instance()->register_factory<MODULE_TYPE>(
      (*bf)->get_name(), *bf
    );
  }
  loaded_modules.push_back(module);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, %rax
movq -0x80(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x1ec30
movq -0x78(%rbp), %rsi
movq %rax, %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x70(%rbp), %rdi
callq 0x1ec30
movq %rax, %rsi
movq (%rsi), %rax
leaq -0x28(%rbp), %rdi
callq *0x8(%rax)
leaq -0x28(%rbp), %rdi
callq 0x1ec50
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1ecc0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1ec80
testb $0x1, %al
jne 0x1c681
jmp 0x1c72c
callq 0x6dc0
movq %rax, -0x88(%rbp)
jmp 0x1c68f
leaq -0x30(%rbp), %rdi
callq 0x1ed30
movq %rax, %rdi
callq 0x1cdd0
movq %rax, %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, -0x90(%rbp)
jmp 0x1c6b5
leaq -0x30(%rbp), %rdi
callq 0x1ed30
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x17e30
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x1ecf0
jmp 0x1c6ed
leaq -0x58(%rbp), %rdi
callq 0x6f30
leaq -0x30(%rbp), %rdi
callq 0x1ed50
jmp 0x1c65e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1c798
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6f30
jmp 0x1c798
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rax
addq $0xd0, %rax
movq %rax, -0xa8(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1eda0
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x1ed70
jmp 0x1c766
leaq -0x68(%rbp), %rdi
callq 0x1cfa0
leaq -0x28(%rbp), %rdi
callq 0x1edd0
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cfa0
leaq -0x28(%rbp), %rdi
callq 0x1edd0
movq -0x40(%rbp), %rdi
callq 0x5460
nopw (%rax,%rax)
// File: AndreiBarsan[P]uShell/util.cc
// Function: util::argv_to_strvec[abi:cxx11](int, char**)
vector<string> argv_to_strvec(int count, char** const argv) {
    vector<string> vargv;
    for(int i = 0; i < count; ++i) {
      vargv.emplace_back(argv[i]);
    }
    return vargv;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x1c0c0
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x202a1
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
callq 0x20ad0
jmp 0x2027d
jmp 0x2027f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2025e
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8660
jmp 0x202be
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x202b4
movq -0x40(%rbp), %rdi
callq 0x8660
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5460
nopw (%rax,%rax)
// File: AndreiBarsan[P]uShell/util.cc
// Function: util::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> split(const std::string &s, char delim) {
    std::vector<std::string> elems;
    std::stringstream ss(s);
    std::string item;
    while (std::getline(ss, item, delim)) {
      elems.push_back(item);
    }
    return elems;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f0(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x1c0c0
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x20b40
movl %eax, -0x1d4(%rbp)
jmp 0x20424
movl -0x1d4(%rbp), %edx
movq -0x1e0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x5400
jmp 0x2043f
leaq -0x1d0(%rbp), %rdi
callq 0x5370
movsbl -0x11(%rbp), %edx
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x54a0
movq %rax, -0x1f8(%rbp)
jmp 0x2046b
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x5330
movb %al, -0x1f9(%rbp)
jmp 0x20489
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x20495
jmp 0x204ec
movq -0x1f0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x20b60
jmp 0x204aa
jmp 0x2044b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2052a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x5190
leaq -0x1a0(%rbp), %rdi
callq 0x51e0
jmp 0x2052a
movb $0x1, -0x12(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x5190
leaq -0x1a0(%rbp), %rdi
callq 0x51e0
testb $0x1, -0x12(%rbp)
jne 0x2051a
movq -0x1f0(%rbp), %rdi
callq 0x8660
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1f0(%rbp), %rdi
callq 0x8660
movq -0x1a8(%rbp), %rdi
callq 0x5460
nopw %cs:(%rax,%rax)
// File: AndreiBarsan[P]uShell/util.cc
// Function: util::merge_with(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, 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>>>>> const&, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, 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>>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string merge_with(const std::vector<std::string>::iterator& start,
                         const std::vector<std::string>::iterator& end,
                         const std::string delimitator) {
    std::stringstream ss;
    for(auto it = start; it != end; ++it) {
      ss << *it;
      if(it + 1 != end) {
        ss << delimitator;
      }
    }

    return ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rcx, -0x1e0(%rbp)
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x51d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1b0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1b0(%rbp), %rdi
callq 0x1c370
testb $0x1, %al
jne 0x205b6
jmp 0x20659
leaq -0x198(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0x1c3b0
movq -0x1e8(%rbp), %rdi
movq %rax, %rsi
callq 0x5220
jmp 0x205e1
leaq -0x1b0(%rbp), %rdi
movl $0x1, %esi
callq 0x6940
movq %rax, -0x1c8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0x1c370
testb $0x1, %al
jne 0x2060f
jmp 0x20646
movq -0x1e0(%rbp), %rsi
leaq -0x198(%rbp), %rdi
callq 0x5220
jmp 0x20624
jmp 0x20646
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0x51e0
jmp 0x2068a
jmp 0x20648
leaq -0x1b0(%rbp), %rdi
callq 0x1c3d0
jmp 0x2059d
movq -0x1d8(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x5260
jmp 0x2066e
leaq -0x1a8(%rbp), %rdi
callq 0x51e0
movq -0x1d0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x5460
nopw %cs:(%rax,%rax)
// File: AndreiBarsan[P]uShell/util.cc
// Function: util::get_raw_array(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>>>> const&)
char** get_raw_array(const std::vector<std::string>& v) {
    char** ret = new char*[v.size() + 1];
    for(size_t i = 0; i < v.size(); ++i) {
      ret[i] = ::strdup(v[i].c_str());
    }
    ret[v.size()] = nullptr;
    return ret;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7120
addq $0x1, %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7120
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x2073d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1cdb0
movq %rax, %rdi
callq 0x5110
movq %rax, %rdi
callq 0x5490
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x206e6
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7120
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AndreiBarsan[P]uShell/util.cc
// Function: util::getcwd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool getcwd(std::string *cwd) {
    // Note: PATH_MAX might not be sufficient.
    // See: insanecoding.blogspot.com/2007/11/pathmax-simply-isnt.html
    static char dir[PATH_MAX];
    if(::getcwd(dir, sizeof(dir))) {
      *cwd = std::string(dir);
      return true;
    }
    
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x18b4d(%rip), %rdi     # 0x392d0
movl $0x1000, %esi           # imm = 0x1000
callq 0x5150
cmpq $0x0, %rax
je 0x207f2
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5470
movq -0x50(%rbp), %rdx
leaq 0x18b25(%rip), %rsi     # 0x392d0
leaq -0x30(%rbp), %rdi
callq 0x5360
jmp 0x207b6
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5320
leaq -0x30(%rbp), %rdi
callq 0x5190
leaq -0x31(%rbp), %rdi
callq 0x52c0
movb $0x1, -0x1(%rbp)
jmp 0x207f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x52c0
jmp 0x20801
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x5460
nopw (%rax,%rax)
// File: AndreiBarsan[P]uShell/util.cc
// Function: util::is_regular_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool is_regular_file(const std::string& name) {
    struct stat stat_buf;
    if(0 == ::stat(name.c_str(), &stat_buf)) {
      return S_ISREG(stat_buf.st_mode);
    }

    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5110
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5230
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x208c9
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x208cd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AndreiBarsan[P]uShell/util.cc
// Function: util::is_directory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool is_directory(const std::string& name) {
    struct stat stat_buf;
    if(0 == ::stat(name.c_str(), &stat_buf)) {
      return S_ISDIR(stat_buf.st_mode);
    }

    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5110
movq %rax, %rdi
leaq -0xa0(%rbp), %rsi
callq 0x5230
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x20929
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x2092d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: AndreiBarsan[P]uShell/util.cc
// Function: util::get_current_home[abi:cxx11]()
string get_current_home() {
    char* home;
    if(nullptr == (home = ::getenv("HOME"))) {
      home = ::getpwuid(::getuid())->pw_dir;
      return string(home);
    }
    else {
      string ret(home);
      return ret;
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x2e20(%rip), %rdi      # 0x2377e
callq 0x5310
movq %rax, %rcx
movq %rcx, -0x10(%rbp)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x209cf
callq 0x5140
movl %eax, %edi
callq 0x52e0
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x5470
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x5360
jmp 0x209ad
leaq -0x11(%rbp), %rdi
callq 0x52c0
jmp 0x20a32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x52c0
jmp 0x20a3c
movb $0x0, -0x25(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x26(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5470
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x5360
jmp 0x209fb
leaq -0x26(%rbp), %rdi
callq 0x52c0
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x20a30
jmp 0x20a27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x52c0
jmp 0x20a3c
movq -0x38(%rbp), %rdi
callq 0x5190
jmp 0x20a32
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5460
nopw %cs:(%rax,%rax)
// File: szmer[P]brill/./src/corpus.cpp
// Function: Corpus::load_tagset[abi:cxx11](char const*)
vector<string> Corpus::load_tagset(const char* fname) {
	vector<string> tagset;
	ifstream ts_file(fname);

	char buff [256];
	while(ts_file.good()) {

		ts_file.getline(buff, 256);
		if(ts_file.gcount() == 256 && buff[255] != '\0')
			throw "load_tagset: tagset file has a line longer than 256 characters!";
		if(string(buff).size() > 0)
			tagset.push_back(string(buff));
	}

	return tagset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3c0, %rsp            # imm = 0x3C0
movq %rdi, -0x390(%rbp)
movq %rdi, %rax
movq %rax, -0x388(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x8330
movq -0x10(%rbp), %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x3430
jmp 0x3de4
jmp 0x3de6
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x33b0
movb %al, -0x391(%rbp)
jmp 0x3e06
movb -0x391(%rbp), %al
testb $0x1, %al
jne 0x3e15
jmp 0x3fe7
leaq -0x220(%rbp), %rdi
leaq -0x330(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x30a0
jmp 0x3e2f
leaq -0x220(%rbp), %rdi
callq 0x34a0
movq %rax, -0x3a0(%rbp)
jmp 0x3e44
movq -0x3a0(%rbp), %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x3eb9
movsbl -0x231(%rbp), %eax
cmpl $0x0, %eax
je 0x3eb9
movl $0x8, %edi
callq 0x3120
movq %rax, %rdi
leaq 0xf313(%rip), %rax      # 0x13186
movq %rax, (%rdi)
movq 0x18143(%rip), %rsi     # 0x1bfc0
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
jmp 0x4041
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x4029
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x3fff
leaq -0x351(%rbp), %rdi
movq %rdi, -0x3a8(%rbp)
callq 0x3410
movq -0x3a8(%rbp), %rdx
leaq -0x350(%rbp), %rdi
leaq -0x330(%rbp), %rsi
callq 0x7ec0
jmp 0x3ee8
leaq -0x350(%rbp), %rdi
callq 0x3190
movq %rax, -0x3b0(%rbp)
leaq -0x350(%rbp), %rdi
callq 0x34b8
leaq -0x351(%rbp), %rdi
callq 0x3280
movq -0x3b0(%rbp), %rax
cmpq $0x0, %rax
jbe 0x3fe2
leaq -0x379(%rbp), %rdi
movq %rdi, -0x3b8(%rbp)
callq 0x3410
movq -0x3b8(%rbp), %rdx
leaq -0x378(%rbp), %rdi
leaq -0x330(%rbp), %rsi
callq 0x7ec0
jmp 0x3f53
movq -0x390(%rbp), %rdi
leaq -0x378(%rbp), %rsi
callq 0x8350
jmp 0x3f68
leaq -0x378(%rbp), %rdi
callq 0x34b8
leaq -0x379(%rbp), %rdi
callq 0x3280
jmp 0x3fe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x351(%rbp), %rdi
callq 0x3280
jmp 0x3fff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x3fd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x378(%rbp), %rdi
callq 0x34b8
leaq -0x379(%rbp), %rdi
callq 0x3280
jmp 0x3fff
jmp 0x3de6
movb $0x1, -0x11(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x3080
testb $0x1, -0x11(%rbp)
jne 0x4019
jmp 0x400d
leaq -0x220(%rbp), %rdi
callq 0x3080
jmp 0x4029
movq -0x390(%rbp), %rdi
callq 0x8380
movq -0x388(%rbp), %rax
addq $0x3c0, %rsp            # imm = 0x3C0
popq %rbp
retq
movq -0x390(%rbp), %rdi
callq 0x8380
movq -0x228(%rbp), %rdi
callq 0x3400
nopw %cs:(%rax,%rax)
// File: szmer[P]brill/./src/rules_applier.cpp
// Function: atoi_longlong(char*)
static long long atoi_longlong(char * str) {
	int len = strlen(str);
	long long num = 0;

	for(int i = 0; i < len; i++)
		num += pow(10, (len-i-1)) * (str[i] - 48); // 48 being '0' ASCII value

	return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3100
movl %eax, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x73a7
movl -0xc(%rbp), %esi
subl -0x1c(%rbp), %esi
subl $0x1, %esi
movl $0xa, %edi
callq 0xa4c0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm2
cvtsi2sdq -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7357
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: szmer[P]brill/Brill-test.cpp
// Function: main
int main(int argc, char ** argv) {

	if(argc != 4) {
		cout << "Usage: Brill-test CORPUS_FILE TAGSET_FILE TRANSFORMATIONS_FILE" << endl;
		return 1;
	}

	try {
		Corpus base_corp = Corpus::load_file(argv[1]);
		RulesApplier appl(argv[2], argv[3], & base_corp);

		appl.transform(& base_corp); // discard returned corpus, we need only the scores

		cout << "Unigrams: " << appl.baseline_score << endl;
		cout << "Transformations: " << appl.final_score << endl;
	}

	catch(const char * e) {
		cout << e << endl;
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x7bfd
movq 0x14402(%rip), %rdi     # 0x1bfd8
leaq 0xb79b(%rip), %rsi      # 0x13378
callq 0x3210
movq %rax, %rdi
movq 0x143cc(%rip), %rsi     # 0x1bfb8
callq 0x3260
movl $0x1, -0x4(%rbp)
jmp 0x7db5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x58(%rbp), %rdi
callq 0x3800
jmp 0x7c10
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
leaq -0xe0(%rbp), %rdi
leaq -0x58(%rbp), %rcx
callq 0x6d50
jmp 0x7c2e
leaq -0x128(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x73c0
jmp 0x7c47
leaq -0x128(%rbp), %rdi
callq 0x8300
movq 0x1437e(%rip), %rdi     # 0x1bfd8
leaq 0xb756(%rip), %rsi      # 0x133b7
callq 0x3210
movq %rax, -0x138(%rbp)
jmp 0x7c6f
movq -0x138(%rbp), %rdi
movsd -0x78(%rbp), %xmm0
callq 0x3440
movq %rax, -0x140(%rbp)
jmp 0x7c89
movq -0x140(%rbp), %rdi
movq 0x14321(%rip), %rsi     # 0x1bfb8
callq 0x3260
jmp 0x7c9e
movq 0x14333(%rip), %rdi     # 0x1bfd8
leaq 0xb716(%rip), %rsi      # 0x133c2
callq 0x3210
movq %rax, -0x148(%rbp)
jmp 0x7cba
movq -0x148(%rbp), %rdi
movsd -0x70(%rbp), %xmm0
callq 0x3440
movq %rax, -0x150(%rbp)
jmp 0x7cd4
movq -0x150(%rbp), %rdi
movq 0x142d6(%rip), %rsi     # 0x1bfb8
callq 0x3260
jmp 0x7ce9
leaq -0xe0(%rbp), %rdi
callq 0x9650
leaq -0x58(%rbp), %rdi
callq 0x8300
jmp 0x7dae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7d40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x7d37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x9650
leaq -0x58(%rbp), %rdi
callq 0x8300
movl -0x64(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7dc1
movq -0x60(%rbp), %rdi
callq 0x30e0
movq %rax, -0x130(%rbp)
movq -0x130(%rbp), %rsi
movq 0x1426e(%rip), %rdi     # 0x1bfd8
callq 0x3210
movq %rax, -0x158(%rbp)
jmp 0x7d78
movq -0x158(%rbp), %rdi
movq 0x14232(%rip), %rsi     # 0x1bfb8
callq 0x3260
jmp 0x7d8d
movl $0x1, -0x4(%rbp)
callq 0x3380
jmp 0x7db5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x3380
jmp 0x7dc1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3400
nopw (%rax,%rax)
// File: rapirent[P]JPEG/./util.h
// Function: read_word_to_bigendian(_IO_FILE*)
uint16_t read_word_to_bigendian(FILE* fp)
{
    byte high,low;
    fread(&high, 1, 1, fp);
    fread(&low, 1, 1, fp);
    word word_value = 0x0000;
    word_value = ((word_value | high) << 8) &0xff00;
    word_value = word_value | low;
    return word_value;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
leaq 0xf(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movq 0x10(%rsp), %rcx
leaq 0xe(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movw $0x0, 0xc(%rsp)
movzwl 0xc(%rsp), %eax
movzbl 0xf(%rsp), %ecx
orl %ecx, %eax
shll $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
movw %ax, 0xc(%rsp)
movzwl 0xc(%rsp), %eax
movzbl 0xe(%rsp), %ecx
orl %ecx, %eax
movw %ax, 0xc(%rsp)
movw 0xc(%rsp), %ax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: rapirent[P]JPEG/decoder.c
// Function: huffman_table_index(unsigned char)
int huffman_table_index (byte index)
{
    switch(index) {
        case 0x10:
            return 2;
        case 0x11:
            return 3;
        case 0x00:
            return 0;
        case 0x01:
            return 1;
        default:
            printf("huffman table index error");
            exit(1);
    }
}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
movb %al, 0x13(%rsp)
movzbl 0x13(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x11, %rax
ja 0x55a8
movq 0x8(%rsp), %rax
leaq 0x4a99(%rip), %rcx      # 0xa010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, 0x14(%rsp)
jmp 0x55c0
movl $0x3, 0x14(%rsp)
jmp 0x55c0
movl $0x0, 0x14(%rsp)
jmp 0x55c0
movl $0x1, 0x14(%rsp)
jmp 0x55c0
leaq 0x5516(%rip), %rdi      # 0xaac5
movb $0x0, %al
callq 0x5030
movl $0x1, %edi
callq 0x5220
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: rapirent[P]JPEG/decoder.c
// Function: read_qt(_IO_FILE*)
void read_qt(FILE* fp)
{
    byte len = read_word_to_bigendian(fp);
    byte id_prec;
    len = len - 2;
    byte pq,id;
    byte c;
    word tmp;
    while (len > 0) {
        fread(&id_prec,1,1,fp);
        len-=1;
        pq = (id_prec >> 4) ? 1: 0;
        id = id_prec & 0x0f;
        for(int i = 0; i<64; i++) {
            if (pq) {
                tmp = read_word_to_bigendian(fp);
                len = len - 2;
            } else {
                fread(&c, 1, 1, fp);
                len--;
                tmp = c;
            }
            quantize_table_list[id][i] = tmp;
        }
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5470
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
subl $0x2, %eax
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0x0, %eax
jle 0x5742
movq 0x10(%rsp), %rcx
leaq 0xe(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movzbl 0xf(%rsp), %eax
subl $0x1, %eax
movb %al, 0xf(%rsp)
movzbl 0xe(%rsp), %edx
sarl $0x4, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movb %al, 0xd(%rsp)
movzbl 0xe(%rsp), %eax
andl $0xf, %eax
movb %al, 0xc(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x40, 0x4(%rsp)
jge 0x573d
cmpb $0x0, 0xd(%rsp)
je 0x56e0
movq 0x10(%rsp), %rdi
callq 0x5470
movw %ax, 0x8(%rsp)
movzbl 0xf(%rsp), %eax
subl $0x2, %eax
movb %al, 0xf(%rsp)
jmp 0x570b
movq 0x10(%rsp), %rcx
leaq 0xb(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movb 0xf(%rsp), %al
addb $-0x1, %al
movb %al, 0xf(%rsp)
movzbl 0xb(%rsp), %eax
movw %ax, 0x8(%rsp)
movzwl 0x8(%rsp), %edx
movzbl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x91c2(%rip), %rax      # 0xe8e0
shlq $0x8, %rcx
addq %rcx, %rax
movslq 0x4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x56b1
jmp 0x5653
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: rapirent[P]JPEG/decoder.c
// Function: read_sos(_IO_FILE*)
void read_sos(FILE* fp)
{
    int len = read_word_to_bigendian(fp);
    byte component_num;
    fread(&component_num,1,1,fp);
    assert(len == 6+2*component_num);
    len = len - 3;
    assert(component_num==3);//JFIF defined
    byte component_id,destination;
    for (int i =0; i<component_num; i++) {

        fread(&component_id,1,1,fp);
        fread(&destination,1,1,fp);
        len = len-2;
        component_mapping_huffman[component_id-1] = destination;
    }
    fread(&destination,1,1,fp);
    fread(&destination,1,1,fp);
    fread(&destination,1,1,fp);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x5470
movzwl %ax, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rcx
leaq 0xb(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movl 0xc(%rsp), %eax
movzbl 0xb(%rsp), %ecx
shll %ecx
addl $0x6, %ecx
cmpl %ecx, %eax
jne 0x5bc5
jmp 0x5be4
leaq 0x4f13(%rip), %rdi      # 0xaadf
leaq 0x4f25(%rip), %rsi      # 0xaaf8
movl $0xab, %edx
leaq 0x4f23(%rip), %rcx      # 0xab02
callq 0x50e0
movl 0xc(%rsp), %eax
subl $0x3, %eax
movl %eax, 0xc(%rsp)
movzbl 0xb(%rsp), %eax
cmpl $0x3, %eax
jne 0x5bfb
jmp 0x5c1a
leaq 0x4f16(%rip), %rdi      # 0xab18
leaq 0x4eef(%rip), %rsi      # 0xaaf8
movl $0xad, %edx
leaq 0x4eed(%rip), %rcx      # 0xab02
callq 0x50e0
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movzbl 0xb(%rsp), %ecx
cmpl %ecx, %eax
jge 0x5c8e
movq 0x10(%rsp), %rcx
leaq 0xa(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movq 0x10(%rsp), %rcx
leaq 0x9(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movl 0xc(%rsp), %eax
subl $0x2, %eax
movl %eax, 0xc(%rsp)
movb 0x9(%rsp), %dl
movzbl 0xa(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x90c2(%rip), %rax      # 0xed40
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5c22
movq 0x10(%rsp), %rcx
leaq 0x9(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movq 0x10(%rsp), %rcx
leaq 0x9(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movq 0x10(%rsp), %rcx
leaq 0x9(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: rapirent[P]JPEG/decoder.c
// Function: read_one_bit(_IO_FILE*)
byte read_one_bit(FILE *fp)
{
    static byte buffer;
    static byte count = 0;
    byte check_ff00;
    if (!count) {
        fread(&buffer,1,1,fp);
        if (buffer == 0xff) {
            byte check_ff00;
            fread(&check_ff00,1,1,fp);
            if (check_ff00 != 0x00) {
                printf("missing 0xff00 sequence!");
                exit(1);
            }
        }
    }
    byte bit = (buffer >> (7 - count))&0x01;
    count = (count == 7 ? 0 : count + 1);
    return bit;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpb $0x0, 0x9261(%rip)      # 0xef51
jne 0x5d56
movq 0x10(%rsp), %rcx
leaq 0x9252(%rip), %rdi      # 0xef50
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movzbl 0x923e(%rip), %eax      # 0xef50
cmpl $0xff, %eax
jne 0x5d54
movq 0x10(%rsp), %rcx
leaq 0xe(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x5290
movzbl 0xe(%rsp), %eax
cmpl $0x0, %eax
je 0x5d52
leaq 0x4de8(%rip), %rdi      # 0xab29
movb $0x0, %al
callq 0x5030
movl $0x1, %edi
callq 0x5220
jmp 0x5d54
jmp 0x5d56
movzbl 0x91f3(%rip), %eax      # 0xef50
movzbl 0x91ed(%rip), %edx      # 0xef51
movl $0x7, %ecx
subl %edx, %ecx
sarl %cl, %eax
andl $0x1, %eax
movb %al, 0xd(%rsp)
movzbl 0x91d6(%rip), %eax      # 0xef51
cmpl $0x7, %eax
jne 0x5d88
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x5d96
movzbl 0x91c2(%rip), %eax      # 0xef51
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movb %al, 0x91b1(%rip)       # 0xef51
movb 0xd(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: rapirent[P]JPEG/decoder.c
// Function: codeword_decode(_IO_FILE*, unsigned char)
int codeword_decode (FILE *fp, byte need_read_length)
{
    byte leading = read_one_bit(fp);
    int decoding_code = 1;
    byte c;
    for (int i = 1; i < need_read_length; i++) {
        c = read_one_bit(fp);
        decoding_code = decoding_code << 1;
        decoding_code += leading ? c : !c;
    }
    decoding_code = leading ? decoding_code: -decoding_code;
    return decoding_code;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5ce0
movb %al, 0x1e(%rsp)
movl $0x1, 0x18(%rsp)
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
movzbl 0x1f(%rsp), %ecx
cmpl %ecx, %eax
jge 0x5e41
movq 0x20(%rsp), %rdi
callq 0x5ce0
movb %al, 0x17(%rsp)
movl 0x18(%rsp), %eax
shll %eax
movl %eax, 0x18(%rsp)
cmpb $0x0, 0x1e(%rsp)
je 0x5e15
movzbl 0x17(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x5e28
cmpb $0x0, 0x17(%rsp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x5dde
cmpb $0x0, 0x1e(%rsp)
je 0x5e52
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x5e5c
xorl %eax, %eax
subl 0x18(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: rapirent[P]JPEG/decoder.c
// Function: decode_huffman(_IO_FILE*, int)
byte decode_huffman(FILE *fp, int huffman_table_id)
{
    huffman_leaf* huffman_table = huffman_tables[huffman_table_id].start;
    int ht_node_num = huffman_tables[huffman_table_id].ht_node_num;
    word codeword = 0x0000;
    for(int i = 0; i<16; i++) {
        codeword =codeword<<1;
        codeword |= (word)read_one_bit(fp);
        for(int j = 0; j<ht_node_num; j++) {
            if(huffman_table[j].codeword==codeword&&huffman_table[j].codeword_len==(i+1)) {
                return huffman_table[j].value;
            }
        }
    }
    printf("do not find\n");
    exit(1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x8e77(%rip), %rax      # 0xed00
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movslq 0x1c(%rsp), %rcx
leaq 0x8e5c(%rip), %rax      # 0xed00
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
movw $0x0, 0xa(%rsp)
movl $0x0, 0x4(%rsp)
cmpl $0x10, 0x4(%rsp)
jge 0x5f75
movzwl 0xa(%rsp), %eax
shll %eax
movw %ax, 0xa(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5ce0
movzbl %al, %eax
movzwl %ax, %ecx
movzwl 0xa(%rsp), %eax
orl %ecx, %eax
movw %ax, 0xa(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x5f63
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movzwl (%rax), %eax
movzwl 0xa(%rsp), %ecx
cmpl %ecx, %eax
jne 0x5f56
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl 0x4(%rsp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x5f56
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movb 0x8(%rax), %al
addq $0x28, %rsp
retq
jmp 0x5f58
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x5efb
jmp 0x5f65
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x5ec1
leaq 0x4bc6(%rip), %rdi      # 0xab42
movb $0x0, %al
callq 0x5030
movl $0x1, %edi
callq 0x5220
nopl (%rax)
// File: rapirent[P]JPEG/./bitmap_image.hpp
// Function: bitmap_image::write_bfh(std::basic_ofstream<char, std::char_traits<char>>&, bitmap_image::bitmap_file_header const&) const
inline void write_bfh(std::ofstream& stream, const bitmap_file_header& bfh) const
   {
      if (big_endian())
      {
         write_to_stream(stream,flip(bfh.type     ));
         write_to_stream(stream,flip(bfh.size     ));
         write_to_stream(stream,flip(bfh.reserved1));
         write_to_stream(stream,flip(bfh.reserved2));
         write_to_stream(stream,flip(bfh.off_bits ));
      }
      else
      {
         write_to_stream(stream,bfh.type     );
         write_to_stream(stream,bfh.size     );
         write_to_stream(stream,bfh.reserved1);
         write_to_stream(stream,bfh.reserved2);
         write_to_stream(stream,bfh.off_bits );
      }
   }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x8db0
testb $0x1, %al
jne 0x87cb
jmp 0x88d3
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rsi
callq 0x8e00
movq (%rsp), %rsi
movq 0x28(%rsp), %rdi
movw %ax, 0x3e(%rsp)
leaq 0x3e(%rsp), %rdx
callq 0x8dd0
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rsi
addq $0x4, %rsi
callq 0x8e60
movq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
movl %eax, 0x38(%rsp)
leaq 0x38(%rsp), %rdx
callq 0x8e30
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rsi
addq $0x8, %rsi
callq 0x8e00
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdi
movw %ax, 0x36(%rsp)
leaq 0x36(%rsp), %rdx
callq 0x8dd0
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
addq $0xa, %rsi
callq 0x8e00
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdi
movw %ax, 0x34(%rsp)
leaq 0x34(%rsp), %rdx
callq 0x8dd0
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rsi
addq $0xc, %rsi
callq 0x8e60
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %eax, 0x30(%rsp)
leaq 0x30(%rsp), %rdx
callq 0x8e30
jmp 0x8947
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x8dd0
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
addq $0x4, %rdx
callq 0x8e30
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
addq $0x8, %rdx
callq 0x8dd0
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
addq $0xa, %rdx
callq 0x8dd0
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
addq $0xc, %rdx
callq 0x8e30
addq $0x58, %rsp
retq
nopl (%rax)
// File: rapirent[P]JPEG/./bitmap_image.hpp
// Function: bitmap_image::flip(unsigned int const&) const
inline unsigned int flip(const unsigned int& v) const
   {
      return (
               ((v & 0xFF000000) >> 0x18) |
               ((v & 0x000000FF) << 0x18) |
               ((v & 0x00FF0000) >> 0x08) |
               ((v & 0x0000FF00) << 0x08)
             );
   }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movl (%rax), %eax
andl $0xff000000, %eax       # imm = 0xFF000000
shrl $0x18, %eax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
andl $0xff, %ecx
shll $0x18, %ecx
orl %ecx, %eax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
shrl $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rsp), %rcx
movl (%rcx), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
shll $0x8, %ecx
orl %ecx, %eax
retq
// File: AndreRenaud[P]simple_options/demo_app.c
// Function: main
int main(int argc, const char *argv[])
{
	const char *file = NULL;
	int64_t val = 5;
	struct option_entry entries[] = {
		{"file", 'f', "File to load", OPTION_FLAG_string, .string = &file},
		{"number", 'n', "Number", OPTION_FLAG_int, .integer = &val},
		{"desc", 0, NULL, OPTION_FLAG_required},
		{NULL, 0},
	};
	int extra_args = opt_parse(argc, argv, entries);
	if (extra_args < 0) {
		opt_parse_usage(eprintf, argv[0], entries);
		return -1;
	}
	printf("file: %s (%spresent)\n", file, opt_parse_present('f', entries) ? "" : "not ");
	printf("number: %lld (%spresent)\n", (long long int)val, opt_parse_present('n', entries) ? "" : "not ");
	for (int i = extra_args; i < argc; i++) {
		printf("Extra arg %d: %s\n", i, argv[i]);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x5, -0x20(%rbp)
leaq 0x11db(%rip), %rax      # 0x30cb
movq %rax, -0xe0(%rbp)
movb $0x66, -0xd8(%rbp)
leaq 0x11cb(%rip), %rax      # 0x30d0
movq %rax, -0xd0(%rbp)
movl $0x4, -0xc8(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
movb $0x0, -0xb8(%rbp)
leaq 0x11ae(%rip), %rax      # 0x30dd
movq %rax, -0xb0(%rbp)
movb $0x6e, -0xa8(%rbp)
leaq 0x11a0(%rip), %rax      # 0x30e4
movq %rax, -0xa0(%rbp)
movl $0x2, -0x98(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x88(%rbp)
leaq -0xe0(%rbp), %rdi
addq $0x60, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1090
leaq 0x1166(%rip), %rax      # 0x30eb
movq %rax, -0x80(%rbp)
movl $0x10, -0x68(%rbp)
leaq -0xe0(%rbp), %rdi
addq $0x90, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1090
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0xe0(%rbp), %rdx
callq 0x14a0
movl %eax, -0xe4(%rbp)
cmpl $0x0, -0xe4(%rbp)
jge 0x1ff2
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq -0xe0(%rbp), %rdx
leaq 0xff(%rip), %rdi        # 0x20e0
callq 0x11d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x20d4
movq -0x18(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0xe0(%rbp), %rsi
movl $0x66, %edi
callq 0x1c10
movq -0xf8(%rbp), %rsi
movb %al, %cl
leaq 0x10e8(%rip), %rdx      # 0x3106
leaq 0x101c(%rip), %rax      # 0x3041
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x10bd(%rip), %rdi      # 0x30f0
movb $0x0, %al
callq 0x1080
movq -0x20(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xe0(%rbp), %rsi
movl $0x6e, %edi
callq 0x1c10
movq -0xf0(%rbp), %rsi
movb %al, %cl
leaq 0x10a0(%rip), %rdx      # 0x3106
leaq 0xfd4(%rip), %rax       # 0x3041
testb $0x1, %cl
cmovneq %rax, %rdx
leaq 0x1090(%rip), %rdi      # 0x310b
movb $0x0, %al
callq 0x1080
movl -0xe4(%rbp), %eax
movl %eax, -0xe8(%rbp)
movl -0xe8(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x20cd
movl -0xe8(%rbp), %esi
movq -0x10(%rbp), %rax
movslq -0xe8(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x1070(%rip), %rdi      # 0x3125
movb $0x0, %al
callq 0x1080
movl -0xe8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe8(%rbp)
jmp 0x208e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
// File: AndreRenaud[P]simple_options/demo_app.c
// Function: eprintf
static int eprintf(const char *str, ...) {
	va_list ap;
	va_start(ap, str);
	vfprintf(stderr, str, ap);
	va_end(ap);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x2115
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq 0x2e94(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x10c0
xorl %eax, %eax
addq $0xd0, %rsp
popq %rbp
retq
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/allocPtr.cc
// Function: use_factory(int)
Foo* use_factory(T arg)
{
	Foo *p = factory(arg);
	print(cout, *p);
	cout << endl;
	// use p
	return p;  // caller must delete the memory
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x1230
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq 0x2d1e(%rip), %rdi      # 0x3fd0
callq 0x1200
movq 0x2d12(%rip), %rdi      # 0x3fd0
movq 0x2cfb(%rip), %rsi      # 0x3fc0
callq 0x1070
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/allocPtr.cc
// Function: main
int main()
{
	T arg;
	while (cin >> arg) {
		auto p = use_factory(arg);
		delete p; // remember to delete the memory from use_factory
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2cea(%rip), %rdi      # 0x3fe0
leaq -0x8(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1080
testb $0x1, %al
jne 0x1314
jmp 0x133e
movl -0x8(%rbp), %edi
callq 0x1290
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x133c
movq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x1060
jmp 0x12ef
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: leonn[P]neuralNet/data/xor/source/xordatagenerate.cpp
// Function: main
int main(int argc, char const *argv[]){
	srand(time(NULL));
	int inputs_number=atoi(argv[1]);
	//cout << inputs_number<<argc<<endl;

	cout<<"topology: 2 4 1"<<endl;
	cout << "eta: 0.8" << endl;
	cout << "momentum: 0.45" << endl;
	cout << "transfer_function: th" << endl;
	for (int i = 0; i < inputs_number; i++){
		int n1= (int)(2.0*rand() / double(RAND_MAX));
		int n2= (int)(2.0*rand() / double(RAND_MAX));
		int t = n1 ^ n2;
		cout<<"in: "<<n1<<".0 "<<n2<<".0 "<<endl;
		cout<<"out: "<<t<<".0"<<endl;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1050
movl %eax, %edi
callq 0x1060
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
movl %eax, -0x14(%rbp)
movq 0x2d9b(%rip), %rdi      # 0x3fd8
leaq 0xdd4(%rip), %rsi       # 0x2018
callq 0x1070
movq %rax, %rdi
movq 0x2d75(%rip), %rsi      # 0x3fc8
callq 0x1080
movq 0x2d79(%rip), %rdi      # 0x3fd8
leaq 0xdc2(%rip), %rsi       # 0x2028
callq 0x1070
movq %rax, %rdi
movq 0x2d53(%rip), %rsi      # 0x3fc8
callq 0x1080
movq 0x2d57(%rip), %rdi      # 0x3fd8
leaq 0xda9(%rip), %rsi       # 0x2031
callq 0x1070
movq %rax, %rdi
movq 0x2d31(%rip), %rsi      # 0x3fc8
callq 0x1080
movq 0x2d35(%rip), %rdi      # 0x3fd8
leaq 0xd96(%rip), %rsi       # 0x2040
callq 0x1070
movq %rax, %rdi
movq 0x2d0f(%rip), %rsi      # 0x3fc8
callq 0x1080
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x13ca
callq 0x1030
cvtsi2sd %eax, %xmm1
movsd 0xd2e(%rip), %xmm0      # 0x2010
mulsd %xmm1, %xmm0
movsd 0xd1a(%rip), %xmm1      # 0x2008
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
callq 0x1030
cvtsi2sd %eax, %xmm1
movsd 0xd06(%rip), %xmm0      # 0x2010
mulsd %xmm1, %xmm0
movsd 0xcf2(%rip), %xmm1      # 0x2008
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
xorl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movq 0x2ca7(%rip), %rdi      # 0x3fd8
leaq 0xd1e(%rip), %rsi       # 0x2056
callq 0x1070
movq %rax, %rdi
movl -0x1c(%rbp), %esi
callq 0x10b0
movq %rax, %rdi
leaq 0xd09(%rip), %rsi       # 0x205b
callq 0x1070
movq %rax, %rdi
movl -0x20(%rbp), %esi
callq 0x10b0
movq %rax, %rdi
leaq 0xcef(%rip), %rsi       # 0x205b
callq 0x1070
movq %rax, %rdi
movq 0x2c4d(%rip), %rsi      # 0x3fc8
callq 0x1080
movq 0x2c51(%rip), %rdi      # 0x3fd8
leaq 0xcd1(%rip), %rsi       # 0x205f
callq 0x1070
movq %rax, %rdi
movl -0x24(%rbp), %esi
callq 0x10b0
movq %rax, %rdi
leaq 0xcbd(%rip), %rsi       # 0x2065
callq 0x1070
movq %rax, %rdi
movq 0x2c11(%rip), %rsi      # 0x3fc8
callq 0x1080
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x12c5
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: Sleepwalking[P]world-octave/common.cpp
// Function: NuttallWindow(int, double*)
void NuttallWindow(int y_length, double *y) {
  double tmp;
  for (int i = 0; i < y_length; ++i) {
    tmp  = static_cast<double>(i) / (y_length - 1);
    y[i] = 0.355768 - 0.487396 * cos(2.0 * world::kPi * tmp) +
      0.144232 * cos(4.0 * world::kPi * tmp) -
      0.012604 * cos(6.0 * world::kPi * tmp);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1b97
cvtsi2sdl -0x1c(%rbp), %xmm0
movl -0x4(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x1a55e(%rip), %xmm0    # 0x1c060
mulsd -0x18(%rbp), %xmm0
callq 0x11a0
movsd 0x1a53c(%rip), %xmm1    # 0x1c050
mulsd %xmm1, %xmm0
movsd 0x1a538(%rip), %xmm1    # 0x1c058
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x1a517(%rip), %xmm0    # 0x1c048
mulsd -0x18(%rbp), %xmm0
callq 0x11a0
movsd -0x30(%rbp), %xmm1
movsd 0x1a4f8(%rip), %xmm2    # 0x1c040
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x1a4db(%rip), %xmm0    # 0x1c038
mulsd -0x18(%rbp), %xmm0
callq 0x11a0
movsd -0x28(%rbp), %xmm1
movsd 0x1a4bc(%rip), %xmm2    # 0x1c030
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1ad6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)