LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxget.cc
// Function: ofxget::OfxGetContext::AddPasswordsForTest(int, char const*)
OfxGetContext& OfxGetContext::AddPasswordsForTest(
    int id, const char* filename) {
  if (is_error()) return *this;
  std::string id_str = std::to_string(id);
  pugi::xml_document doc;
  pugi::xml_parse_result result = doc.load_file(filename);
  if (!result) {
    return *this;
  }
  auto inst = doc.find_child_by_attribute("institution", "id", id_str.c_str());
  if (inst.empty()) {
    return *this;
  }
  for (auto node : inst) {
    vars_map_[node.name()] = node.child_value();
  }
  return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x76b8
movq %rdx, %r14
leaq 0x30(%rsp), %rdi
callq 0x81e2
leaq 0x98(%rsp), %rdi
callq 0x1c754
leaq 0x50(%rsp), %rdi
leaq 0x98(%rsp), %rsi
pushq $0x74
popq %rcx
movq %r14, %rdx
xorl %r8d, %r8d
callq 0x1d378
leaq 0x50(%rsp), %rdi
callq 0x1c72c
testb %al, %al
je 0x76a1
movq 0x30(%rsp), %rcx
leaq 0x22a3b(%rip), %rsi     # 0x2a0b7
leaq 0x22a61(%rip), %rdx     # 0x2a0e4
leaq 0x98(%rsp), %rdi
callq 0x1b544
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
callq 0x1882e
testb %al, %al
je 0x76cd
leaq 0x98(%rsp), %rdi
callq 0x1c7de
leaq 0x30(%rsp), %rdi
callq 0x6890
movq %rbx, %rax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %rdi
callq 0x186fc
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x1870c
leaq 0x88(%rsp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x20(%rsp), %r15
leaq 0x18(%rsp), %r12
leaq 0x68(%rsp), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c2f8
testb %al, %al
je 0x76a1
movq %r15, %rdi
callq 0x1c318
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq %r12, %rdi
callq 0x18afc
movq %rax, %rbp
movq %r12, %rdi
callq 0x18836
movq %r13, %rdi
movq %rax, %rsi
leaq 0xf(%rsp), %rdx
callq 0x66e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8106
movq %rax, %rdi
movq %rbp, %rsi
callq 0x6840
movq %r13, %rdi
callq 0x6890
movq %r15, %rdi
callq 0x1c36c
jmp 0x7709
jmp 0x7795
jmp 0x7795
jmp 0x7795
movq %rax, %rbx
jmp 0x77a5
jmp 0x7795
jmp 0x7795
jmp 0x7795
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x6890
jmp 0x7798
jmp 0x7795
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x1c7de
leaq 0x30(%rsp), %rdi
callq 0x6890
movq %rbx, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxget.cc
// Function: ofxget::OfxGetContext::GetRequestTemplate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string OfxGetContext::GetRequestTemplate(const string& filename) {
  if (is_error()) return "";
  std::ifstream f(filename);
  if (!f.is_open()) {
    error_string_ = "Could not open " + filename;
    return "";
  }

  string line;
  string request_template;
  while (std::getline(f, line)) {
    request_template += line + "\r\n";
  }

  return request_template;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rdi, %rbx
cmpq $0x0, 0x38(%rsi)
je 0x77eb
leaq 0x22930(%rip), %rsi     # 0x2a109
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x66e0
jmp 0x78df
movq %rdx, %r15
movq %rsi, %r14
leaq 0x48(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r15, %rsi
callq 0x6760
leaq 0xc0(%rsp), %rdi
callq 0x6730
testb %al, %al
je 0x7885
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb %cl, 0x10(%rbx)
leaq 0x48(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0x228c3(%rip), %r12     # 0x2a107
leaq 0x28(%rsp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x6360
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x78cb
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x82fd
movq %rbx, %rdi
movq %r13, %rsi
callq 0x65f0
movq %r13, %rdi
callq 0x6890
jmp 0x7849
leaq 0x2286b(%rip), %rsi     # 0x2a0f7
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x816c
addq $0x30, %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6380
movq %r15, %rdi
callq 0x6890
leaq 0x2284d(%rip), %rsi     # 0x2a109
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x66e0
jmp 0x78d5
leaq 0x8(%rsp), %rdi
callq 0x6890
leaq 0x48(%rsp), %rdi
callq 0x6050
movq %rbx, %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x78f5
movq %rax, %r14
jmp 0x7920
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6890
jmp 0x790e
jmp 0x790b
movq %rax, %r14
movq %rbx, %rdi
callq 0x6890
leaq 0x8(%rsp), %rdi
callq 0x6890
leaq 0x48(%rsp), %rdi
callq 0x6050
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxget.cc
// Function: ofxget::OfxGetContext::request[abi:cxx11]()
string OfxGetContext::request() {
  if (is_error()) return "";
  string subbed = request_template_;
  for (std::size_t i = 0; i < subbed.size(); i++) {
    if (subbed[i] == '$') {
      std::size_t j;
      for (j = i + 1; j < subbed.size(); j++) {
        if (!isupper(subbed[j])) {
          break;
        }
      }
      string var = subbed.substr(i + 1, j - i - 1);
      VarsMap::const_iterator it = vars_map_.find(var);
      if (it != vars_map_.end()) {
        subbed.replace(i, j - i, it->second);
      } else {
        error_string_ = "Unspecified variable: " + var;
        return "";
      }
    }
  }
  return subbed;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x38(%rsi)
je 0x797d
leaq 0x2279e(%rip), %rsi     # 0x2a109
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x66e0
jmp 0x7ada
movq %rsi, %r15
movq %rbx, (%rsp)
addq $0x50, %rsi
leaq 0x8(%rsp), %rdi
callq 0x63c0
leaq 0x8(%r15), %r14
leaq 0x30(%r15), %rax
movq %rax, 0x28(%rsp)
xorl %r13d, %r13d
movq %r14, 0x30(%rsp)
movq 0x10(%rsp), %rbp
cmpq %rbp, %r13
jae 0x7a8b
movq %r13, %r12
movq 0x8(%rsp), %rbx
incq %r13
cmpb $0x24, (%rbx,%r12)
jne 0x79a7
movq %r15, %r14
movq %r13, %r15
cmpq %rbp, %r15
jae 0x79e8
movsbl (%rbx,%r15), %edi
callq 0x6680
testl %eax, %eax
je 0x79e5
incq %r15
jmp 0x79cd
movq %r15, %rbp
subq %r12, %rbp
leaq -0x1(%rbp), %rcx
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0x66f0
movq %r14, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8cc2
movq 0x30(%rsp), %r14
movq %rax, %rbx
cmpq %r14, %rax
je 0x7a35
leaq 0x40(%rbx), %rcx
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x66a0
jmp 0x7a76
leaq 0x58(%rsp), %r12
movq %r12, %rdi
leaq 0x226c6(%rip), %rsi     # 0x2a10a
leaq 0x38(%rsp), %rdx
callq 0x816c
movq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x6380
movq %r12, %rdi
callq 0x6890
movq (%rsp), %rdi
leaq 0x2269b(%rip), %rsi     # 0x2a109
movq %r12, %rdx
callq 0x66e0
leaq 0x38(%rsp), %rdi
callq 0x6890
cmpq %r14, %rbx
jne 0x79a7
jmp 0x7acc
movq (%rsp), %rsi
leaq 0x10(%rsi), %rcx
movq %rcx, (%rsi)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x7ab2
movq %rdx, (%rsi)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rsi)
jmp 0x7ab8
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq %rbp, 0x8(%rsi)
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x6890
movq (%rsp), %rbx
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7af7
jmp 0x7af7
jmp 0x7af7
movq %rax, %rbx
jmp 0x7b04
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6890
leaq 0x8(%rsp), %rdi
callq 0x6890
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxget.cc
// Function: ofxget::CurlWriteToString(char*, unsigned long, unsigned long, void*)
static size_t CurlWriteToString(char *ptr, size_t size, size_t nmemb, void *userdata) {
  OfxGetContext* context = static_cast<OfxGetContext*>(userdata);
  if (size != 1) {
    char err[255];
    sprintf(err, "In response, expected char size 1, got %ld", size);
    context->error_string_ = string(err);
  }
  string to_add;
  to_add.resize(nmemb);
  memcpy((void*) to_add.c_str(), (void*) ptr, nmemb);
  context->response_ += to_add;
  return size * nmemb;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
cmpq $0x1, %rsi
je 0x7dbc
leaq 0x2246f(%rip), %rsi     # 0x2a1f0
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x6720
leaq 0x10(%rsp), %rbp
leaq 0xf(%rsp), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x66e0
leaq 0x30(%r15), %rdi
movq %rbp, %rsi
callq 0x6380
movq %rbp, %rdi
callq 0x6890
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x6280
leaq 0x30(%rsp), %r13
movq (%r13), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x6080
addq $0x70, %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x65f0
imulq %r14, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6890
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x6890
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxget.cc
// Function: ofxget::OfxDate[abi:cxx11]()
string OfxDate() {
  time_t now = time(nullptr);
  struct tm* ltime = localtime(&now);
  char time_str[255];
  sprintf(time_str, "%04d%02d%02d%02d%02d%02d.000",
          1900 + ltime->tm_year, 1 + ltime->tm_mon, ltime->tm_mday,
          ltime->tm_hour, ltime->tm_min, ltime->tm_sec);
  return time_str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
xorl %edi, %edi
callq 0x6520
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x6480
movl $0x76c, %edx            # imm = 0x76C
addl 0x14(%rax), %edx
movl 0x10(%rax), %ecx
incl %ecx
movl 0xc(%rax), %r8d
movl 0x8(%rax), %r9d
movl (%rax), %r10d
movl 0x4(%rax), %r11d
leaq 0x22319(%rip), %rsi     # 0x2a1cb
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x6720
popq %rcx
popq %rdx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66e0
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxget.cc
// Function: ofxget::GetMissingRequestVars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<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&)
vector<string> GetMissingRequestVars(const string& request_template,
                                     const VarsMap& vars) {
  vector<string> missing;
  for (std::size_t i = 0; i < request_template.size(); i++) {
    if (request_template[i] == '$') {
      std::size_t j;
      for (j = i + 1; j < request_template.size(); j++) {
        if (!isupper(request_template[j])) {
          break;
        }
      }
      string var = request_template.substr(i + 1, j - i - 1);
      VarsMap::const_iterator it = vars.find(var);
      if (it == vars.end() || it->second.empty()) {
        missing.push_back(var);
      }
    }
  }
  return missing;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
movq %rdx, 0x10(%rsp)
leaq 0x8(%rdx), %rax
movq %rax, 0x8(%rsp)
xorl %r12d, %r12d
movq 0x8(%r15), %rbx
cmpq %rbx, %r12
jae 0x7f9d
movq %r12, %rbp
movq (%r15), %r14
incq %r12
cmpb $0x24, (%r14,%rbp)
jne 0x7f16
movq %r12, %r13
cmpq %rbx, %r13
jae 0x7f4d
movsbl (%r14,%r13), %edi
callq 0x6680
testl %eax, %eax
je 0x7f4a
incq %r13
jmp 0x7f32
movq %r13, %rbx
notq %rbp
addq %rbx, %rbp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbp, %rcx
callq 0x66f0
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x8d2e
cmpq 0x8(%rsp), %rax
je 0x7f84
cmpq $0x0, 0x48(%rax)
jne 0x7f90
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x835a
movq %rbx, %rdi
callq 0x6890
jmp 0x7f16
movq (%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x7fc2
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x6890
movq (%rsp), %rdi
callq 0x82dc
movq %r14, %rdi
callq 0x6460
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxhome.cc
// Function: ofxget::CurlWriteToString(char*, unsigned long, unsigned long, void*)
static size_t CurlWriteToString(char *ptr, size_t size, size_t nmemb, void *userdata) {
  if (size != 1) {
    char err[255];
    sprintf(err, "In response, expected char size 1, got %ld", size);
    throw string(err);
  }
  string* out = static_cast<string*>(userdata);
  string to_add;
  to_add.resize(nmemb);
  memcpy((void*) to_add.c_str(), (void*) ptr, nmemb);
  *out += to_add;
  return size * nmemb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
cmpq $0x1, %rsi
jne 0x90f4
movq %rcx, %r14
movq %rdx, %rbx
movq %rdi, %r15
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x10(%rsp), %rdi
movq %rdx, %rsi
callq 0x6280
leaq 0x10(%rsp), %r12
movq (%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x6080
movq %r14, %rdi
movq %r12, %rsi
callq 0x65f0
leaq 0x10(%rsp), %rdi
callq 0x6890
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rsi, %rdx
leaq 0x210f2(%rip), %rsi     # 0x2a1f0
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x6720
pushq $0x20
popq %rdi
callq 0x6250
movq %rax, %r14
leaq 0xf(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x66e0
leaq 0x393f1(%rip), %rsi     # 0x42520
movq 0x39e72(%rip), %rdx     # 0x42fa8
movq %r14, %rdi
callq 0x6440
movq %rax, %rbx
jmp 0x915d
movq %rax, %rbx
movq %r14, %rdi
callq 0x6630
jmp 0x915d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6890
movq %rbx, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxhome.cc
// Function: ofxget::FindInstitutionByName(std::vector<ofxget::Institution, std::allocator<ofxget::Institution>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const Institution* FindInstitutionByName(
    const vector<Institution>& institutions,
    const string& name)
{
  for (const Institution& i : institutions) {
    if (i.name.find(name) != string::npos) {
      return &i;
    }
  }
  return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rdi), %rbx
movq 0x8(%rdi), %r15
cmpq %r15, %rbx
je 0x991d
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x6450
cmpq $-0x1, %rax
jne 0x991f
addq $0x140, %rbx            # imm = 0x140
jmp 0x98fb
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/ofxhome.cc
// Function: ofxget::AnonymizeRequest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string AnonymizeRequest(const string& request) {
  string r = request;
  std::regex userid("<USERID>[^<]*", icase);
  std::regex acctid("<ACCTID>[^<]*", icase);
  std::regex userpass("<USERPASS>[^<]*", icase);
  r = regex_replace(r, userid, "<USERID>X\n");
  r = regex_replace(r, acctid, "<ACCTID>X\n");
  r = regex_replace(r, userpass, "<USERPASS>X\n");
  return r;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x63c0
leaq 0x20c04(%rip), %rsi     # 0x2a545
leaq 0x68(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0xa0c2
leaq 0x20bfe(%rip), %rsi     # 0x2a553
leaq 0x48(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0xa0c2
leaq 0x20bf8(%rip), %rsi     # 0x2a561
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0xa0c2
leaq 0x2601a(%rip), %rcx     # 0x2f997
leaq 0x8(%rsp), %rdi
leaq 0x68(%rsp), %rdx
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0xa128
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6890
leaq 0x20bc0(%rip), %rcx     # 0x2a571
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0xa128
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6890
leaq 0x20b97(%rip), %rcx     # 0x2a57c
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rbx, %rsi
xorl %r8d, %r8d
callq 0xa128
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6380
movq %r14, %rdi
callq 0x6890
leaq 0x28(%rsp), %rdi
callq 0xa178
leaq 0x48(%rsp), %rdi
callq 0xa178
leaq 0x68(%rsp), %rdi
callq 0xa178
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
jmp 0x9a42
jmp 0x9a42
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xa178
jmp 0x9a54
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0xa178
jmp 0x9a63
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0xa178
movq %rbx, %rdi
callq 0x6890
movq %r14, %rdi
callq 0x6460
movq %rax, %r14
jmp 0x9a6d
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArg::validate_flags()
bool CmdArg::validate_flags()
{
  if ((_syntaxFlags & isOPT) && (_syntaxFlags & isREQ))
    {
      cerr << "Warning: keyword " << getKeyword()
	   << " can't be optional AND required" << endl;
      cerr << "changing the sytax of "
	   << getKeyword() << " to be required." << endl;
      _syntaxFlags &= ~isOPT;
      return false;
    }
  if ((_syntaxFlags & isVALOPT) && (_syntaxFlags & isVALREQ  ))
    {
      cerr << "Warning: value for keyword " << getKeyword()
	   << " can't be optional AND required" << endl;
      cerr << "changing the sytax of the value of "
	   << getKeyword() << " to be required." << endl;
      _syntaxFlags &= ~isVALREQ;
      return false;
    }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x28(%rdi), %ecx
notl %ecx
testb $0x3, %cl
jne 0x164cb
pushq $-0x2
popq %rbp
leaq 0x14fc0(%rip), %r14     # 0x2b482
leaq 0x14f87(%rip), %rsi     # 0x2b450
jmp 0x164e3
movb $0x1, %al
testb $0xc, %cl
jne 0x16548
pushq $-0x9
popq %rbp
leaq 0x14fea(%rip), %r14     # 0x2b4c6
leaq 0x14fc7(%rip), %rsi     # 0x2b4aa
movq 0x2caee(%rip), %r15     # 0x42fd8
movq %r15, %rdi
callq 0x6410
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x6410
leaq 0x14f5d(%rip), %rsi     # 0x2b462
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
movq %r15, %rdi
movq %r14, %rsi
callq 0x6410
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x6410
leaq 0x14f66(%rip), %rsi     # 0x2b499
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
andl %ebp, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgInt::getValue(int*, int, char**)
bool CmdArgInt::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* arg = strdup(argv[*i]);
      _v = strtol(arg, (char **)&ptr, 0);
      if (ptr == arg)
	{
	  cout << " invalid integer value \"" << arg << "\"" << endl;
	  return false;
	}
      setParseOK();
      return true;
    }
  else
    return false;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x16695
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6040
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x65e0
movq %rax, 0x30(%rbx)
cmpq %r14, (%r15)
je 0x16660
orb $0x4, 0x2c(%rbx)
movb $0x1, %al
jmp 0x16697
movq 0x2c929(%rip), %rdi     # 0x42f90
leaq 0x14e7c(%rip), %rsi     # 0x2b4ea
callq 0x6410
movq %rax, %rdi
movq %r14, %rsi
callq 0x6410
leaq 0x14ebf(%rip), %rsi     # 0x2b544
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgFloat::getValue(int*, int, char**)
bool CmdArgFloat::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* arg = strdup(argv[*i]);
      _v = strtod(arg, (char **)&ptr);
      if (ptr == arg)
	{
	  cout << " invalid float value \"" << arg << "\"" << endl;
	  return false;
	}
      setParseOK();
      return true;
    }
  else
    return false;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x16760
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6040
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x6870
movsd %xmm0, 0x30(%rbx)
cmpq %r14, (%r15)
je 0x1672b
orb $0x4, 0x2c(%rbx)
movb $0x1, %al
jmp 0x16762
movq 0x2c85e(%rip), %rdi     # 0x42f90
leaq 0x14dca(%rip), %rsi     # 0x2b503
callq 0x6410
movq %rax, %rdi
movq %r14, %rsi
callq 0x6410
leaq 0x14df4(%rip), %rsi     # 0x2b544
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgStr::getValue(int*, int, char**)
bool CmdArgStr::getValue(int *i, int argc, char *argv[])
{
  (*i)++;
  if (*i < argc)
    {
      char* arg = strdup(argv[*i]);
      if (arg[0] == '-') return false;      
      _v = arg;
      setParseOK();
      return true;
    }
  else
    return false;  
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x16833
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6040
cmpb $0x2d, (%rax)
jne 0x16837
xorl %eax, %eax
jmp 0x16841
movq %rax, 0x30(%rbx)
orb $0x4, 0x2c(%rbx)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgStr::operator char*()
CmdArgStr::operator char*() {
  char* str = new char[strlen(_v) + 1];
  int i;
  for (i = 0; i < strlen(_v); i++)
    str[i] = _v[i];
  str[i] = '\0';
  return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rbx
movq %rbx, %rdi
callq 0x6260
movq %rax, %r14
leaq 0x1(%rax), %rdi
callq 0x62e0
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x16872
movb (%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x16862
movb $0x0, (%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgChar::getValue(int*, int, char**)
bool CmdArgChar::getValue(int *i, int argc, char *argv[])
{
  (*i)++;
  if (*i < argc)
    {
      char* arg = strdup(argv[*i]);
      if (strlen(arg) > 1){
	cout << "value \"" << arg << "\" is to long. ignoring" << endl;
	return false;
      }
      _v = arg[0];
      setParseOK();
      return true;
    }
  else
    return false;  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x16925
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6040
movq %rax, %r14
movq %rax, %rdi
callq 0x6260
cmpq $0x2, %rax
jae 0x168f0
movb (%r14), %al
movb %al, 0x30(%rbx)
orb $0x4, 0x2c(%rbx)
movb $0x1, %al
jmp 0x16927
movq 0x2c699(%rip), %rdi     # 0x42f90
leaq 0x14c40(%rip), %rsi     # 0x2b53e
callq 0x6410
movq %rax, %rdi
movq %r14, %rsi
callq 0x6410
leaq 0x14c05(%rip), %rsi     # 0x2b51a
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgIntList::getValue(int*, int, char**)
bool CmdArgIntList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  long val;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  val = strtol(tok, (char **)&ptr, 0);
	  if (ptr == tok)
	    {
	      cout << "invalid integer value \"" << tok << "\"" << endl;
	      return false;
	    }
	  insert(val);
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x16a2b
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6040
movq %rax, %rdi
leaq 0x8(%rsp), %r14
movq 0x58(%rbx), %rsi
callq 0x6190
testq %rax, %rax
je 0x169e5
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x65e0
cmpq %r15, 0x8(%rsp)
je 0x169f6
movq %rbx, %rdi
movl %eax, %esi
callq 0x16dc0
xorl %edi, %edi
jmp 0x169b2
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x16de0
movq 0x2c593(%rip), %rdi     # 0x42f90
leaq 0x14ae7(%rip), %rsi     # 0x2b4eb
callq 0x6410
movq %rax, %rdi
movq %r15, %rsi
callq 0x6410
leaq 0x14b29(%rip), %rsi     # 0x2b544
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgFloatList::getValue(int*, int, char**)
bool CmdArgFloatList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  double val;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  val = strtod(tok, (char **)&ptr);
	  if (ptr == tok)
	    {
	      cout << "invalid float value \"" << tok << "\"" << endl;
	      return false;
	    }
	  insert(val);
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x16b21
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6040
movq %rax, %rdi
leaq 0x8(%rsp), %r14
movq 0x58(%rbx), %rsi
callq 0x6190
testq %rax, %rax
je 0x16adb
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x6870
cmpq %r15, 0x8(%rsp)
je 0x16aec
movq %rbx, %rdi
callq 0x16f5a
xorl %edi, %edi
jmp 0x16aac
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x16f78
movq 0x2c49d(%rip), %rdi     # 0x42f90
leaq 0x14a0a(%rip), %rsi     # 0x2b504
callq 0x6410
movq %rax, %rdi
movq %r15, %rsi
callq 0x6410
leaq 0x14a33(%rip), %rsi     # 0x2b544
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgStrList::getValue(int*, int, char**)
bool CmdArgStrList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  insert(strdup(tok));
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x16bb6
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6040
movq %rax, %rdi
movq 0x58(%rbx), %rsi
callq 0x6190
testq %rax, %rax
je 0x16bba
movq %rax, %rdi
callq 0x6040
movq %rbx, %rdi
movq %rax, %rsi
callq 0x170f2
xorl %edi, %edi
jmp 0x16b91
xorl %eax, %eax
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x17110
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdarg.cc
// Function: CmdArgCharList::getValue(int*, int, char**)
bool CmdArgCharList::getValue(int *i, int argc, char *argv[])
{
  char *ptr;
  (*i)++;
  if (*i < argc)
    {
      char* tokens = strdup(argv[*i]);
      char* tok    = strtok(tokens, getDelimiters());
      while (tok)
	{
	  if (strlen(tok) != 1)
	    {
	      cout << "invalid char value \"" << tok << "\"" << endl;
	      return false;
	    }
	  insert(tok[0]);
	  tok = strtok(NULL, getDelimiters());
	}
      return validate();
    }
  else
    return false;  
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rsi), %rax
leal 0x1(%rax), %edi
movl %edi, (%rsi)
cmpl %edx, %edi
jge 0x16ca1
movq 0x8(%rcx,%rax,8), %rdi
callq 0x6040
movq %rax, %rdi
movq 0x58(%rbx), %rsi
callq 0x6190
testq %rax, %rax
je 0x16c5d
movq %rax, %r14
movq %rax, %rdi
callq 0x6260
cmpq $0x1, %rax
jne 0x16c6c
movsbl (%r14), %esi
movq %rbx, %rdi
callq 0x1728a
xorl %edi, %edi
jmp 0x16c2e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x172aa
movq 0x2c31d(%rip), %rdi     # 0x42f90
leaq 0x148b7(%rip), %rsi     # 0x2b531
callq 0x6410
movq %rax, %rdi
movq %r14, %rsi
callq 0x6410
leaq 0x148b3(%rip), %rsi     # 0x2b544
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/include/cmdarg.hh
// Function: CmdArgTypeList<int>::CmdArgTypeList(char, char const*, char const*, char const*, unsigned int, int, int, char const*)
CmdArgTypeList(const char   optChar,
		 const char*  keyword,
		 const char*  valueName,
		 const char*  description,
		 unsigned int syntaxFlags = (isREQ | isVALREQ),
		 int          minSize = 1,
		 int          maxSize = 100,
		 const char*  delim = ",-~/.")
    :   CmdArg(optChar, keyword, valueName, description, syntaxFlags),
	_delimiters(delim), _min(minSize),_max(maxSize)    
  {
    char buf[512];
    sprintf(buf, "%s1%c...%c%sn", getValueName(), _delimiters[0],
	    _delimiters[0], getValueName());
    setValueName(buf);
    sprintf(buf, "%s (%d <= n <= %d)", description, _min, _max);
    setDescription(buf);
    for (int i = 0; i < strlen(delim); i++){
      if (delim[i] == ' '){
	cout << "ERROR: space can't be a delimiter" << endl;
	exit(0);}}
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %r8, %r12
movq %rdi, %r15
movq 0x250(%rsp), %r14
movl 0x240(%rsp), %ebp
movl 0x248(%rsp), %r13d
callq 0x1647c
leaq 0x2bdd2(%rip), %rax     # 0x42ab8
movq %rax, (%r15)
leaq 0x30(%r15), %rbx
movq %rbx, 0x38(%r15)
movq %rbx, 0x30(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r15)
movq %r14, 0x58(%r15)
movl %r13d, 0x60(%r15)
movl %ebp, 0x64(%r15)
movq 0x18(%r15), %rdx
movsbl (%r14), %ecx
leaq 0x1482e(%rip), %rsi     # 0x2b546
xorl %ebp, %ebp
movq %rsp, %r13
movq %r13, %rdi
movl %ecx, %r8d
movq %rdx, %r9
xorl %eax, %eax
callq 0x6720
movq %r13, %rdi
callq 0x6040
movq %rax, 0x18(%r15)
movl 0x60(%r15), %r8d
movl 0x64(%r15), %ecx
leaq 0x1480c(%rip), %rsi     # 0x2b554
movq %r13, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x6720
movq %r13, %rdi
callq 0x6040
movq %rax, 0x20(%r15)
movq %r14, %rdi
callq 0x6260
cmpq %rbp, %rax
jbe 0x16d9b
cmpb $0x20, (%r14,%rbp)
leaq 0x1(%rbp), %rbp
jne 0x16d69
movq 0x2c210(%rip), %rdi     # 0x42f90
leaq 0x147e0(%rip), %rsi     # 0x2b567
callq 0x6410
movq %rax, %rdi
callq 0x6700
xorl %edi, %edi
callq 0x64b0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1735e
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/include/cmdarg.hh
// Function: CmdArgTypeList<int>::validate()
bool         validate     (){
    if (_list.size() < _min) {
      cout << "too few argument to the switch -" << getKeyword() << endl;
      return false;
    }
    if (_list.size() > _max) {
      cout << "too many argument to the switch -" << getKeyword() << endl;
      return false;
    }
    reset();
    setParseOK();
    return true;    
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movslq 0x64(%rdi), %rcx
cmpq %rcx, %rax
jae 0x16e01
movq 0x2c198(%rip), %rdi     # 0x42f90
leaq 0x1478a(%rip), %rsi     # 0x2b589
jmp 0x16e18
movslq 0x60(%rbx), %rcx
cmpq %rcx, %rax
jbe 0x16e35
movq 0x2c17f(%rip), %rdi     # 0x42f90
leaq 0x14792(%rip), %rsi     # 0x2b5aa
callq 0x6410
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
xorl %eax, %eax
jmp 0x16e44
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
orb $0x4, 0x2c(%rbx)
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdline.cc
// Function: CmdLine::CmdLine(char*, CmdArg*, ...)
CmdLine::CmdLine(char *progName, CmdArg *cmds ...) :
  _progName(progName), _maxLength(0)
{
  va_list args;
  va_start(args, cmds);
  for (CmdArg* arg = cmds; arg; arg = va_arg(args, CmdArg*))
    {
      _cmdList.push_front(arg);
      _maxLength = std::max((long)_maxLength, (long)strlen(arg->getValueName()));
    }
  va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rdi
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1779e
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rsi, 0x18(%rbx)
andl $0x0, 0x20(%rbx)
movq %rdi, 0x20(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %r14
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
je 0x1783c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17c84
movslq 0x20(%rbx), %r15
movq 0x8(%rsp), %rdi
callq 0x16586
movq %rax, %rdi
callq 0x6260
cmpq %r15, %rax
jg 0x1780b
movq %r15, %rax
movl %eax, 0x20(%rbx)
movl 0x10(%rsp), %ecx
cmpq $0x28, %rcx
ja 0x17829
movq %rcx, %rax
addq 0x20(%rsp), %rax
addl $0x8, %ecx
movl %ecx, 0x10(%rsp)
jmp 0x17837
movq 0x18(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rdx
jmp 0x177d8
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1784b
movq %rax, %r14
movq %rbx, %rdi
callq 0x17c90
movq %r14, %rdi
callq 0x6460
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/clap/src/cmdline.cc
// Function: CmdLine::usage()
void CmdLine::usage()
{
  CmdArg*            arg;
  CmdArgListIterator it;
  
  cout << endl << "Usage: " << _progName;
  for (it = _cmdList.begin(); it != _cmdList.end(); it++)
    {
      arg = *it;
      if (!arg->isHidden())
	{
	  cout << " ";
	  if (arg->isOpt()) cout << "[";
	  cout << "-" << arg->getKeyword();
	  if (!arg->isValOpt())
	    cout << " " << arg->getValueName();
	  if (arg->isOpt()) cout << "]";
	}
    }

  cout << endl << "Where: " << endl;
  for (it = _cmdList.begin(); it != _cmdList.end(); it++)
    {
      arg = *it;
      if (!arg->isHidden())
	{
	  cout << setw(_maxLength + 5);
	  if (!arg->isValOpt())	  
	    cout << arg->getValueName();
	  else
	    cout << arg->getKeyword(); // usualy boolean keyword
	  cout.flags(ios::left);
	  cout << " - " << arg->getDescription() << endl;
	  cout.flags(ios::right);
	}
    }
  cout << endl;
  exit(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x2b71d(%rip), %r14     # 0x42f90
movq %r14, %rdi
callq 0x6700
leaq 0x13e24(%rip), %rsi     # 0x2b6a6
movq %rax, %rdi
callq 0x6410
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x6410
leaq 0x13e1d(%rip), %r13     # 0x2b6ba
movq %r15, %rbx
movq (%rbx), %rbx
cmpq %r15, %rbx
je 0x17958
movq 0x10(%rbx), %r12
movq %r12, %rdi
callq 0x16596
testb %al, %al
jne 0x178a0
movq %r14, %rdi
movq %r13, %rsi
callq 0x6410
movq %r12, %rdi
callq 0x165a0
testb %al, %al
je 0x178e2
movq %r14, %rdi
leaq 0x13dd1(%rip), %rsi     # 0x2b6ae
callq 0x6410
movq %r14, %rdi
leaq 0x13de6(%rip), %rsi     # 0x2b6d2
callq 0x6410
movq %rax, %rbp
movq %r12, %rdi
callq 0x16580
movq %rbp, %rdi
movq %rax, %rsi
callq 0x6410
movq %r12, %rdi
callq 0x165a6
testb %al, %al
jne 0x17934
movq %r14, %rdi
movq %r13, %rsi
callq 0x6410
movq %rax, %rbp
movq %r12, %rdi
callq 0x16586
movq %rbp, %rdi
movq %rax, %rsi
callq 0x6410
movq %r12, %rdi
callq 0x165a0
testb %al, %al
je 0x178a0
movq %r14, %rdi
leaq 0x15778(%rip), %rsi     # 0x2d0c6
callq 0x6410
jmp 0x178a0
movq %r14, %rdi
callq 0x6700
leaq 0x13d49(%rip), %rsi     # 0x2b6b0
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x6700
leaq 0x13d3a(%rip), %rbx     # 0x2b6b8
movq %r15, %rbp
movq (%rbp), %rbp
cmpq %r15, %rbp
je 0x17a26
movq 0x10(%rbp), %r12
movq %r12, %rdi
callq 0x16596
testb %al, %al
jne 0x17981
movslq 0x20(%r15), %rax
addq $0x5, %rax
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
movq %rax, 0x10(%r14,%rcx)
movq %r12, %rdi
callq 0x165a6
movq %r12, %rdi
testb %al, %al
je 0x179c8
callq 0x16580
jmp 0x179cd
callq 0x16586
movq %r14, %rdi
movq %rax, %rsi
callq 0x6410
movq (%r14), %rax
movq -0x18(%rax), %rax
movl $0x20, 0x18(%r14,%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6410
movq %rax, %r13
movq %r12, %rdi
callq 0x1658c
movq %r13, %rdi
movq %rax, %rsi
callq 0x6410
movq %rax, %rdi
callq 0x6700
movq (%r14), %rax
movq -0x18(%rax), %rax
movl $0x80, 0x18(%r14,%rax)
jmp 0x17981
movq 0x2b563(%rip), %rdi     # 0x42f90
callq 0x6700
pushq $0x1
popq %rdi
callq 0x64b0
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_writer_stream::write(void const*, unsigned long)
PUGI__FN void xml_writer_stream::write(const void* data, size_t size)
	{
		if (narrow_stream)
		{
			assert(!wide_stream);
			narrow_stream->write(reinterpret_cast<const char*>(data), static_cast<std::streamsize>(size));
		}
		else
		{
			assert(wide_stream);
			assert(size % sizeof(wchar_t) == 0);

			wide_stream->write(reinterpret_cast<const wchar_t*>(data), static_cast<std::streamsize>(size / sizeof(wchar_t)));
		}
	}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
testq %rax, %rax
je 0x17dd2
testq %rdi, %rdi
jne 0x17de6
movq %rax, %rdi
popq %rax
jmp 0x6350
testq %rdi, %rdi
je 0x17e05
testb $0x3, %dl
jne 0x17e24
shrq $0x2, %rdx
popq %rax
jmp 0x6140
leaq 0x1413b(%rip), %rdi     # 0x2bf28
leaq 0x14141(%rip), %rsi     # 0x2bf35
leaq 0x1414e(%rip), %rcx     # 0x2bf49
movl $0x13c2, %edx           # imm = 0x13C2
callq 0x6100
leaq 0x1411d(%rip), %rdi     # 0x2bf29
leaq 0x14122(%rip), %rsi     # 0x2bf35
leaq 0x1412f(%rip), %rcx     # 0x2bf49
movl $0x13c7, %edx           # imm = 0x13C7
callq 0x6100
leaq 0x14160(%rip), %rdi     # 0x2bf8b
leaq 0x14103(%rip), %rsi     # 0x2bf35
leaq 0x14110(%rip), %rcx     # 0x2bf49
movl $0x13c8, %edx           # imm = 0x13C8
callq 0x6100
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::impl::(anonymous namespace)::get_value_bool(char const*)
PUGI__FN bool get_value_bool(const char_t* value)
	{
		// only look at first char
		char_t first = *value;

		// 1*, t* (true), T* (True), y* (yes), Y* (YES)
		return (first == '1' || first == 't' || first == 'T' || first == 'y' || first == 'Y');
	}

// Assembly:
movzbl (%rdi), %ecx
movb $0x1, %al
leal -0x54(%rcx), %edx
cmpl $0x25, %edx
ja 0x17fb2
movabsq $0x2100000021, %rsi     # imm = 0x2100000021
btq %rdx, %rsi
jae 0x17fb2
retq
cmpl $0x31, %ecx
je 0x17fb1
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: bool pugi::impl::(anonymous namespace)::set_value_integer<unsigned int, char*, unsigned long>(char*&, unsigned long&, unsigned long, unsigned int, bool)
PUGI__FN bool set_value_integer(String& dest, Header& header, uintptr_t header_mask, U value, bool negative)
	{
		char_t buf[64];
		char_t* end = buf + sizeof(buf) / sizeof(buf[0]);
		char_t* begin = integer_to_string(buf, end, value, negative);

		return strcpy_insitu(dest, header, header_mask, begin, end - begin);
	}

// Assembly:
subq $0x48, %rsp
leaq 0x3f(%rsp), %r10
movl %edx, %r9d
negl %r9d
testl %ecx, %ecx
cmovel %edx, %r9d
leal 0x1(%rcx), %eax
movzbl %al, %r8d
andl $0x1, %r8d
decq %r8
pushq $0xa
popq %r11
movl %r9d, %eax
xorl %edx, %edx
divl %r11d
orb $0x30, %dl
movb %dl, (%r10)
decq %r10
decq %r8
cmpl $0x9, %r9d
movl %eax, %r9d
ja 0x184b2
movq %rsp, %rax
cmpq %rax, %r10
jb 0x184f4
movb $0x2d, (%r10)
xorb $0x1, %cl
movzbl %cl, %ecx
addq %r10, %rcx
negq %r8
pushq $0x10
popq %rdx
callq 0x1824c
addq $0x48, %rsp
retq
leaq 0x16fa1(%rip), %rdi     # 0x2f49c
leaq 0x13a33(%rip), %rsi     # 0x2bf35
leaq 0x16fa3(%rip), %rcx     # 0x2f4ac
movl $0x120b, %edx           # imm = 0x120B
callq 0x6100
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::child(char const*) const
PUGI__FN xml_node xml_node::child(const char_t* name_) const
	{
		if (!_root) return xml_node();

		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
			if (i->name && impl::strequal(name_, i->name)) return xml_node(i);

		return xml_node();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x187c0
movq %rsi, %r14
addq $0x20, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x187c0
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x187ba
movq %r14, %rdi
callq 0x1888f
testb %al, %al
jne 0x187c2
addq $0x30, %rbx
jmp 0x1879d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::attribute(char const*) const
PUGI__FN xml_attribute xml_node::attribute(const char_t* name_) const
	{
		if (!_root) return xml_attribute();

		for (xml_attribute_struct* i = _root->first_attribute; i; i = i->next_attribute)
			if (i->name && impl::strequal(name_, i->name))
				return xml_attribute(i);

		return xml_attribute();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x188fc
movq %rsi, %r14
addq $0x38, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x188fc
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x188f6
movq %r14, %rdi
callq 0x1888f
testb %al, %al
jne 0x188fe
addq $0x20, %rbx
jmp 0x188d9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::attribute(char const*, pugi::xml_attribute&) const
PUGI__FN xml_attribute xml_node::attribute(const char_t* name_, xml_attribute& hint_) const
	{
		xml_attribute_struct* hint = hint_._attr;

		// if hint is not an attribute of node, behavior is not defined
		assert(!hint || (_root && impl::is_attribute_of(hint, _root)));

		if (!_root) return xml_attribute();

		// optimistically search from hint up until the end
		for (xml_attribute_struct* i = hint; i; i = i->next_attribute)
			if (i->name && impl::strequal(name_, i->name))
			{
				// update hint to maximize efficiency of searching for consecutive attributes
				hint_._attr = i->next_attribute;

				return xml_attribute(i);
			}

		// wrap around and search from the first attribute until the hint
		// 'j' null pointer check is technically redundant, but it prevents a crash in case the assertion above fails
		for (xml_attribute_struct* j = _root->first_attribute; j && j != hint; j = j->next_attribute)
			if (j->name && impl::strequal(name_, j->name))
			{
				// update hint to maximize efficiency of searching for consecutive attributes
				hint_._attr = j->next_attribute;

				return xml_attribute(j);
			}

		return xml_attribute();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq (%rdx), %r15
movq (%rdi), %rsi
testq %r15, %r15
je 0x189e1
testq %rsi, %rsi
je 0x189c2
movq %r15, %rdi
callq 0x18a59
testb %al, %al
jne 0x189e6
leaq 0x135de(%rip), %rdi     # 0x2bfa7
leaq 0x13565(%rip), %rsi     # 0x2bf35
leaq 0x13607(%rip), %rcx     # 0x2bfde
movl $0x159e, %edx           # imm = 0x159E
callq 0x6100
testq %rsi, %rsi
je 0x18a49
movq %r15, %r13
testq %r13, %r13
je 0x18a09
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x18a03
movq %r14, %rdi
callq 0x1888f
testb %al, %al
jne 0x18a3d
movq 0x20(%r13), %r13
jmp 0x189e9
movq (%r12), %r13
addq $0x38, %r13
xorl %r12d, %r12d
movq (%r13), %r13
testq %r13, %r13
je 0x18a4c
cmpq %r15, %r13
je 0x18a4c
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x18a37
movq %r14, %rdi
callq 0x1888f
testb %al, %al
jne 0x18a3d
addq $0x20, %r13
jmp 0x18a14
movq 0x20(%r13), %rax
movq %rax, (%rbx)
movq %r13, %r12
jmp 0x18a4c
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::child_value() const
PUGI__FN const char_t* xml_node::child_value() const
	{
		if (!_root) return PUGIXML_TEXT("");

		// element nodes can have value if parse_embed_pcdata was used
		if (PUGI__NODETYPE(_root) == node_element && _root->value)
			return _root->value;

		for (xml_node_struct* i = _root->first_child; i; i = i->next_sibling)
			if (impl::is_text_node(i) && i->value)
				return i->value;

		return PUGIXML_TEXT("");
	}

// Assembly:
movq (%rdi), %rdx
leaq 0x11603(%rip), %rcx     # 0x2a109
testq %rdx, %rdx
je 0x18b47
movl (%rdx), %eax
andl $0xf, %eax
cmpl $0x2, %eax
jne 0x18b1f
movq 0x10(%rdx), %rax
testq %rax, %rax
je 0x18b1f
retq
addq $0x20, %rdx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x18b47
movl (%rdx), %eax
andl $0xf, %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x18b41
movq 0x10(%rdx), %rax
testq %rax, %rax
jne 0x18b1e
addq $0x30, %rdx
jmp 0x18b23
movq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::set_name(char const*)
PUGI__FN bool xml_node::set_name(const char_t* rhs)
	{
		xml_node_type type_ = _root ? PUGI__NODETYPE(_root) : node_null;

		if (type_ != node_element && type_ != node_pi && type_ != node_declaration)
			return false;

		return impl::strcpy_insitu(_root->name, _root->header, impl::xml_memory_page_name_allocated_mask, rhs, impl::strlength(rhs));
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x18bcc
movl (%r14), %eax
andl $0xf, %eax
jmp 0x18bce
xorl %eax, %eax
movl %eax, %ecx
andl $-0x5, %ecx
cmpl $0x2, %ecx
setne %cl
cmpl $0x7, %eax
setne %al
testb %cl, %al
je 0x18beb
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x18462
pushq $0x20
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movq %rax, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x1824c
// File: /workspace/github_cpp_makefile_star2_O2/jliesch[P]ofxget/pugixml/pugixml.cpp
// Function: pugi::xml_node::set_value(char const*)
PUGI__FN bool xml_node::set_value(const char_t* rhs)
	{
		xml_node_type type_ = _root ? PUGI__NODETYPE(_root) : node_null;

		if (type_ != node_pcdata && type_ != node_cdata && type_ != node_comment && type_ != node_pi && type_ != node_doctype)
			return false;

		return impl::strcpy_insitu(_root->value, _root->header, impl::xml_memory_page_value_allocated_mask, rhs, impl::strlength(rhs));
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x18c5a
movl (%r14), %eax
andl $0xf, %eax
cmpl $0x8, %eax
ja 0x18c5a
movl $0x178, %ecx            # imm = 0x178
btl %eax, %ecx
jae 0x18c5a
movq %rsi, %rbx
leaq 0x10(%r14), %r15
movq %rsi, %rdi
callq 0x18462
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movq %rax, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x1824c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq