LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_pool.cc
// Function: scdc_dataprov_pool::dataset_close_write_state(scdc_dataset*, scdc_data*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_pool::dataset_close_write_state(scdc_dataset *dataset, scdc_data *outgoing, scdc_result &result)
{
  SCDC_TRACE("dataset_close_write_state: dataset: '" << dataset << "'");

  scdc_dataprov *dataprov = dataset->get_dataprov();

  char *buf = outgoing->get_write_pos_buf();
  scdcint_t buf_size = outgoing->get_write_pos_buf_size();

  scdcint_t n = snprintf(buf, buf_size, "%p|", dataprov);

  SCDC_ASSERT(n <= buf_size);

  if (n > buf_size) n = buf_size;

  outgoing->inc_write_pos(n);

  bool ret = dataprov->dataset_close_write_state(dataset, outgoing, result);

  SCDC_TRACE("dataset_close_write_state: return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rsi), %r12
movq 0x10(%rdx), %r13
movq 0x20(%rdx), %rax
movq 0x8(%rdx), %rdi
addq %rax, %rdi
subq %rax, %r13
leaq 0x34f22(%rip), %rdx     # 0x51545
movq %r13, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xb900
movslq %eax, %rbp
cmpq %rbp, %r13
jge 0x1c6d5
leaq 0x58f3d(%rip), %rax     # 0x75580
movq (%rax), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x1c6d5
addq $0x20, %rdi
movq %rbx, (%rsp)
movq %rax, %rbx
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x34eda(%rip), %rsi     # 0x51549
callq 0xb520
leaq 0x34edc(%rip), %rsi     # 0x51557
movq %rax, %rdi
callq 0xb520
leaq 0x34cba(%rip), %rsi     # 0x51344
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0xb990
leaq 0x34ecb(%rip), %rsi     # 0x51571
movq %rax, %rdi
callq 0xb520
leaq 0x367db(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
movq (%rsp), %rbx
addq $0x20, %rdi
callq 0xb3e0
cmpq %rbp, %r13
cmovlq %r13, %rbp
addq %rbp, 0x20(%r14)
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/../include/common.hh
// Function: stringlist::conflate[abi:cxx11](int)
std::string conflate(int sep_)
    {
      std::string s;

      for (list_t::iterator i = lst.begin(); i != lst.end(); ++i) s += i->first + static_cast<char>(sep_);

      if (s.size() > 0) s.resize(s.size() - 1);

      return s;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movsbl %dl, %ebp
movq %rsp, %r15
movq %rsi, %r12
movq (%r12), %r12
cmpq %r14, %r12
je 0x1ca9c
leaq 0x10(%r12), %rsi
movq %r15, %rdi
movl %ebp, %edx
callq 0x1cae2
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba90
movq %r15, %rdi
callq 0xb230
jmp 0x1ca6f
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1cab0
decq %rsi
movq %rbx, %rdi
callq 0xb760
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1cac2
movq %rax, %r14
jmp 0x1cad2
movq %rax, %r14
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb230
movq %r14, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::dataset_open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
scdc_dataset *scdc_dataprov_register::dataset_open(std::string &path, scdc_result &result)
{
  SCDC_TRACE("dataset_open: path: '" << path << "'");

  scdc_dataset_register *dataset_register = new scdc_dataset_register(this);

  SCDC_TRACE("dataset_open: return: " << dataset_register);

  return dataset_register;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x38
popq %rdi
callq 0xb540
leaq 0x561b7(%rip), %rcx     # 0x73248
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0x10(%rax)
leaq 0x28(%rax), %rdx
movq %rdx, 0x18(%rax)
andq $0x0, 0x20(%rax)
movb %cl, 0x28(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::reg_put(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_register::reg_put(const std::string &url)
{
  SCDC_TRACE("reg_put: url: '" << url << "'");

  pair<register_t::iterator, bool> ret = reg.insert(register_t::value_type(url, scdc_dataprov_register_entry_t()));

  if (!ret.second)
  {
    SCDC_FAIL("reg_put: inserting register entry '" << url << "' failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
callq 0x1d7ec
addq $0x68, %r14
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0x1d968
movl %edx, %ebp
leaq 0x40(%rsp), %rdi
callq 0x1d812
movq %rsp, %rdi
callq 0x1d828
testb $0x1, %bpl
jne 0x1d3e2
leaq 0x58210(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x1d3e2
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x33df7(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x34449(%rip), %rsi     # 0x517e6
movq %rax, %rdi
callq 0xb520
leaq 0x3444e(%rip), %rsi     # 0x517fa
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb490
leaq 0x35aca(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
andb $0x1, %bpl
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1d812
jmp 0x1d406
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1d828
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::reg_update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_register::reg_update(const std::string &url)
{
  SCDC_TRACE("reg_update: url: '" << url << "'");

  register_t::iterator i = reg.find(url);

  if (i == reg.end()) return false;

  i->second.type = "";
  i->second.state = "";

  string cmd = url + "/CONFIG info";

  bool ret = scdc_dataset_cmd(SCDC_DATASET_NULL, cmd.c_str(), 0, 0);
  string result = scdc_last_result();

  if (ret)
  {
    string::size_type p = result.find('|');

    i->second.type = result.substr(0, p);
    if (p != string::npos) i->second.state = result.substr(p + 1, string::npos);
  }

  SCDC_TRACE("reg_update: type: '" << i->second.type << "', state: '" << i->second.state << "'");

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r15
movq %rdi, %r14
addq $0x68, %rdi
callq 0x1db7e
addq $0x70, %r14
cmpq %r14, %rax
je 0x1d535
movq %rax, %rbx
leaq 0x40(%rax), %r14
leaq 0x35071(%rip), %r12     # 0x524bd
movq %r14, %rdi
movq %r12, %rsi
callq 0xba40
addq $0x60, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xba40
leaq 0x343db(%rip), %rdx     # 0x51848
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1d867
movq (%r12), %rsi
xorl %edi, %edi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x1909c
movq %rax, %r15
testq %rax, %rax
setne %bpl
callq 0x17d8e
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x1a132
testq %r15, %r15
je 0x1d51f
leaq 0x20(%rsp), %r12
pushq $0x7c
popq %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0xb710
movq %rax, %r15
movq %rsp, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb560
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xb690
movq %r12, %rdi
callq 0xb230
cmpq $-0x1, %r15
je 0x1d51f
incq %r15
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %r15, %rdx
callq 0xb560
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb690
movq %r14, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0xb230
leaq 0x40(%rsp), %rdi
callq 0xb230
jmp 0x1d537
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d548
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb230
jmp 0x1d55e
jmp 0x1d55b
jmp 0x1d55b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::reg_info(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>>&)
bool scdc_dataprov_register::reg_info(const std::string &url, string &r)
{
  SCDC_TRACE("reg_info: url: '" << url << "'");

  stringstream ss;

  if (url == "")
  {
    ss << reg.size() << " url(s)";

  } else
  {
    register_t::iterator i = reg.find(url);

    if (i == reg.end()) return false;

    ss << i->second.type << ":" << i->second.state;
  }

  r = ss.str();

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %rdi
callq 0xb390
leaq 0x34f0d(%rip), %rsi     # 0x524bd
movq %r14, %rdi
callq 0x19be0
testb %al, %al
je 0x1d5de
leaq 0x38(%rsp), %rdi
movq 0x90(%r15), %rsi
callq 0xb360
leaq 0x3424a(%rip), %rsi     # 0x5181e
movq %rax, %rdi
callq 0xb520
jmp 0x1d622
leaq 0x68(%r15), %rdi
movq %r14, %rsi
callq 0x1db7e
movq %rax, %r14
addq $0x70, %r15
cmpq %r15, %rax
je 0x1d664
leaq 0x38(%rsp), %rdi
leaq 0x40(%r14), %rsi
callq 0xb490
leaq 0x33d39(%rip), %rsi     # 0x51344
movq %rax, %rdi
callq 0xb520
addq $0x60, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xb490
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xb8d0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb690
movq %r14, %rdi
callq 0xb230
movb $0x1, %bl
leaq 0x28(%rsp), %rdi
callq 0xb3d0
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x1d64b
jmp 0x1d66c
jmp 0x1d66c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb3d0
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::reg_rm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_register::reg_rm(const std::string &url)
{
  SCDC_TRACE("reg_rm: url: '" << url << "'");

  if (reg.erase(url) != 1)
  {
    SCDC_FAIL("relay_rm: erasing relay entry '" << url << "' failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
addq $0x68, %rdi
callq 0x1dbf4
movq %rax, %rbx
cmpq $0x1, %rax
je 0x1d715
leaq 0x57edd(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x1d715
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x8(%rax), %rdi
leaq 0x33ac4(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x34116(%rip), %rsi     # 0x517e6
movq %rax, %rdi
callq 0xb520
leaq 0x34147(%rip), %rsi     # 0x51826
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r14, %rsi
callq 0xb490
leaq 0x35797(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
cmpq $0x1, %rbx
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::reg_ls(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>>&)
bool scdc_dataprov_register::reg_ls(const std::string &type, string &r)
{
  SCDC_TRACE("reg_ls: type: '" << type << "'");

  r = "";

  for (register_t::iterator i = reg.begin(); i != reg.end(); ++i)
  {
    if (type == "" || i->second.type == type) r += i->first + ",";
  }

  if (r.size() > 0) r.resize(r.size() - 1);

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x34d7d(%rip), %r12     # 0x524bd
movq %rdx, %rdi
movq %r12, %rsi
callq 0xba40
movq 0x80(%r15), %r13
addq $0x70, %r15
leaq 0x8(%rsp), %rbp
cmpq %r15, %r13
je 0x1d7b2
movq %r14, %rdi
movq %r12, %rsi
callq 0x19be0
testb %al, %al
jne 0x1d77f
leaq 0x40(%r13), %rdi
movq %r14, %rsi
callq 0x1d83e
testb %al, %al
je 0x1d7a5
leaq 0x20(%r13), %rsi
movq %rbp, %rdi
leaq 0x340b9(%rip), %rdx     # 0x51846
callq 0x1d867
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xba90
movq %rbp, %rdi
callq 0xb230
movq %r13, %rdi
callq 0xb380
movq %rax, %r13
jmp 0x1d75b
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1d7c6
decq %rsi
movq %rbx, %rdi
callq 0xb760
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_put(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_relay::relay_put(const std::string &path, const std::string &url, std::string &r)
{
  SCDC_TRACE("relay_put: path: '" << path << "', url: '" << url << "'");

  scdcint_t i = 0;

  r = path;

  while (relay.find(r) != relay.end())
  {
    char s[64];
    sprintf(s, "_%" scdcint_fmt, i);

    r = path + s;

    ++i;
  }

  pair<relay_t::iterator, bool> ret = relay.insert(relay_t::value_type(r, url));

  if (!ret.second)
  {
    SCDC_FAIL("relay_put: inserting relay entry '" << r << "' failed");
    return false;
  }

  reg_put(url);

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %rbx
movq %rdx, 0x18(%rsp)
movq %rsi, %r13
movq %rdi, %r14
movq %rcx, %rdi
callq 0xb2e0
leaq 0x98(%r14), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0xa0(%r14), %r12
leaq 0x20(%rsp), %r14
leaq 0x68(%rsp), %r15
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x1f19c
cmpq %r12, %rax
je 0x1ea0f
movq %r14, %rdi
leaq 0x32f57(%rip), %rsi     # 0x51936
movq %rbp, %rdx
xorl %eax, %eax
callq 0xb0c0
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1d867
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb690
movq %r15, %rdi
callq 0xb230
incq %rbp
jmp 0x1e9c3
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq 0x18(%rsp), %r15
movq %r15, %rdx
callq 0x1efc2
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1f212
movl %edx, %ebp
leaq 0x20(%rsp), %rdi
callq 0x1eff8
testb $0x1, %bpl
je 0x1ea55
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1d2fe
jmp 0x1eace
leaq 0x56b24(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x1eace
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x3270b(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x32de5(%rip), %rsi     # 0x5186e
movq %rax, %rdi
callq 0xb520
leaq 0x32ea4(%rip), %rsi     # 0x5193c
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb490
leaq 0x343de(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
andb $0x1, %bpl
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1eff8
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_get(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>>&)
bool scdc_dataprov_relay::relay_get(const std::string &path, std::string &r)
{
  SCDC_TRACE("relay_get: path: '" << path << "'");

  relay_t::iterator i = relay.find(path);

  if (i == relay.end()) return false;

  r = i->second;

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
addq $0x98, %rdi
callq 0x1f19c
movq %rax, %r15
addq $0xa0, %rbx
cmpq %rbx, %rax
je 0x1eb2e
leaq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0xb2e0
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_info(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>>&)
bool scdc_dataprov_relay::relay_info(const std::string &path, std::string &r)
{
  SCDC_TRACE("relay_info: path: '" << path << "'");

  stringstream ss;

  if (path == "")
  {
    ss << relay.size() << " path(s)";

  } else
  {
    relay_t::iterator i = relay.find(path);

    if (i == relay.end()) return false;

    if (!reg_info(i->second, r)) return false;

    ss << r;
  }

  r = ss.str();

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x28(%rsp), %rdi
callq 0xb390
leaq 0x3395d(%rip), %rsi     # 0x524bd
movq %r15, %rdi
callq 0x19be0
testb %al, %al
je 0x1eb8e
leaq 0x38(%rsp), %rdi
movq 0xc0(%r14), %rsi
callq 0xb360
leaq 0x32ddb(%rip), %rsi     # 0x5195f
movq %rax, %rdi
callq 0xb520
jmp 0x1ebcc
leaq 0x98(%r14), %rdi
movq %r15, %rsi
callq 0x1f19c
leaq 0xa0(%r14), %rcx
cmpq %rcx, %rax
je 0x1ebf7
addq $0x40, %rax
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1d58a
testb %al, %al
je 0x1ebf7
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0xb490
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xb8d0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb690
movq %r14, %rdi
callq 0xb230
movb $0x1, %bl
jmp 0x1ebf9
xorl %ebx, %ebx
leaq 0x28(%rsp), %rdi
callq 0xb3d0
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1ec16
jmp 0x1ec16
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb3d0
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_rm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_relay::relay_rm(const std::string &path)
{
  SCDC_TRACE("relay_rm: path: '" << path << "'");

  relay_t::iterator i = relay.find(path);

  if (i == relay.end() || !reg_rm(i->second) || relay.erase(path) != 1)
  {
    SCDC_FAIL("relay_rm: erasing relay entry '" << path << "' failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x98(%rdi), %r14
movq %r14, %rdi
callq 0x1f19c
leaq 0xa0(%r15), %rcx
cmpq %rcx, %rax
je 0x1ec7b
addq $0x40, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x1d682
testb %al, %al
je 0x1ec7b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f426
movq %rax, %rcx
movb $0x1, %al
cmpq $0x1, %rcx
je 0x1ecf6
leaq 0x568fe(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x1ecf4
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x324e5(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x32bbf(%rip), %rsi     # 0x5186e
movq %rax, %rdi
callq 0xb520
leaq 0x32b68(%rip), %rsi     # 0x51826
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb490
leaq 0x341b8(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_ls(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>>&)
bool scdc_dataprov_relay::relay_ls(const std::string &type, std::string &r)
{
  SCDC_TRACE("relay_ls: type: '" << type << "'");

  r = "";

  for (relay_t::iterator i = relay.begin(); i != relay.end(); ++i)
  {
    if (type != "")
    {
      register_t::iterator j = reg.find(i->second);

      if (j == reg.end() || j->second.type != type) continue;
    }

    r += i->first + ",";
  }

  if (r.size() > 0) r.resize(r.size() - 1);

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x337a3(%rip), %rsi     # 0x524bd
movq %rdx, %rdi
callq 0xba40
movq 0xb0(%r15), %rbp
leaq 0xa0(%r15), %r13
leaq 0x68(%r15), %rax
movq %rax, (%rsp)
addq $0x70, %r15
leaq 0x8(%rsp), %r12
cmpq %r13, %rbp
je 0x1edb1
movq %r14, %rdi
leaq 0x3376d(%rip), %rsi     # 0x524bd
callq 0x1b1d7
testb %al, %al
je 0x1ed7e
leaq 0x40(%rbp), %rsi
movq (%rsp), %rdi
callq 0x1db7e
cmpq %r15, %rax
je 0x1eda4
addq $0x40, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x1eea8
testb %al, %al
jne 0x1eda4
leaq 0x20(%rbp), %rsi
movq %r12, %rdi
leaq 0x32aba(%rip), %rdx     # 0x51846
callq 0x1d867
movq %rbx, %rdi
movq %r12, %rsi
callq 0xba90
movq %r12, %rdi
callq 0xb230
movq %rbp, %rdi
callq 0xb380
movq %rax, %rbp
jmp 0x1ed41
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1edc5
decq %rsi
movq %rbx, %rdi
callq 0xb760
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_relay::relay_update(const std::string &path)
{
  SCDC_TRACE("relay_update: path: '" << path << "'");

  relay_t::iterator i = relay.find(path);

  if (i == relay.end() || !reg_update(i->second))
  {
    SCDC_FAIL("relay_update: updating relay entry '" << path << "' failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x98, %rdi
callq 0x1f19c
leaq 0xa0(%r14), %rcx
cmpq %rcx, %rax
je 0x1ee25
addq $0x40, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x1d416
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1eea0
leaq 0x56754(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x1ee9e
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x3233b(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x32a15(%rip), %rsi     # 0x5186e
movq %rax, %rdi
callq 0xb520
leaq 0x32b00(%rip), %rsi     # 0x51968
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb490
leaq 0x3400e(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataset_relay::do_cmd(char const*, long long, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
virtual bool do_cmd(const char *cmd, scdcint_t cmd_size, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      SCDC_TRACE("do_cmd: '" << string(cmd, cmd_size) << "'");

      scdcint_t ret = scdc_dataset_cmd(dataset, string(cmd, cmd_size).c_str(), input, output);

      SCDC_TRACE("do_cmd: return: '" << ret << "'");

      return (ret == SCDC_SUCCESS);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq 0x38(%rdi), %r15
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1a1f2
movq (%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1909c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
cmpq $0x1, %rbx
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::clear_stores()
void scdc_dataprov_store_mem_handler::clear_stores()
{
  SCDC_TRACE_F();

  for (stores_t::iterator i = stores.begin(); i != stores.end(); ++i) del_store(*i);

  stores.clear();

  SCDC_TRACE_F("return:");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x1f628
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x1fb74
jmp 0x1f612
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a02
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::ls_stores(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_store_mem_handler::ls_stores(std::string &result)
{
  SCDC_TRACE_F();

  bool ret = false;

  result = zxx::to_string(stores.size()) + "|";

  for (stores_t::const_iterator i = stores.begin(); i != stores.end(); ++i)
  {
    result += (*i)->name + "|";
  }

  ret = true;

  SCDC_TRACE_F("return: " << ret << ", result: " << result);

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x2188b
leaq 0x32e71(%rip), %rdx     # 0x524d2
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb18
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb690
movq %r15, %rdi
callq 0xb230
movq %rsp, %rdi
callq 0xb230
leaq 0x32e3d(%rip), %r12     # 0x524d2
movq %r14, %r13
movq (%r13), %r13
cmpq %r14, %r13
je 0x1f6c5
movq 0x10(%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x1d867
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba90
movq %r15, %rdi
callq 0xb230
jmp 0x1f698
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x1f6e5
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::find_store(char const*)
scdc_dataprov_store_mem_handler::store_t scdc_dataprov_store_mem_handler::find_store(const char *path)
{
  SCDC_TRACE_F("path: '" << path << "'");

  store_t ret = store_null;

  if (!path || path[0] == '\0') goto do_return;

  for (stores_t::const_iterator i = stores.begin(); ret == store_null && i != stores.end(); ++i)
  {
    if ((*i)->name == path) ret = *i;
  }

do_return:
  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
testq %rsi, %rsi
je 0x1f9ce
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpb $0x0, (%rsi)
je 0x1f9c6
movq %rdi, %r14
movq %rdi, %r15
xorl %eax, %eax
testq %rax, %rax
jne 0x1f9c8
movq (%r15), %r15
cmpq %r14, %r15
je 0x1f9c6
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x19be0
movl %eax, %ecx
movl $0x0, %eax
testb %cl, %cl
je 0x1f99c
movq 0x10(%r15), %rax
jmp 0x1f99c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::mk_store(char const*)
bool scdc_dataprov_store_mem_handler::mk_store(const char *path)
{
  SCDC_TRACE_F("path: '" << path << "'");

  bool ret = false;
  store_t store = store_null;

  if (!path || path[0] == '\0') goto do_return;

  if (find_store(path) != store_null) goto do_return;

  store = add_store(path);

  if (store == store_null)
  {
    SCDC_FAIL_F("adding store '" << path << "' failed");
    goto do_return;
  } 

  stores.push_back(store);

  ret = true;

do_return:
  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
testq %rsi, %rsi
je 0x1f9f7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x1f9f3
movq %rdi, %rbx
movq %r14, %rsi
callq 0x1f982
testq %rax, %rax
je 0x1f9fa
xorl %eax, %eax
jmp 0x1fa12
xorl %eax, %eax
retq
movq %r14, %rsi
callq 0x1fa1a
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x21958
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::add_store(char const*)
scdc_dataprov_store_mem_handler::store_t scdc_dataprov_store_mem_handler::add_store(const char *path)
{
  SCDC_TRACE_F("path: '" << path << "'");

  store_t store = new store_data_t;
  store->name = path;

  SCDC_TRACE_F("return: store: " << store);

  return store;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
pushq $0x38
popq %rdi
callq 0xb540
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x20(%r14), %rax
movq %rax, 0x28(%r14)
movq %rax, 0x20(%r14)
andq $0x0, 0x30(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xba40
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::rm_store(char const*)
bool scdc_dataprov_store_mem_handler::rm_store(const char *path)
{
  SCDC_TRACE_F("path: '" << path << "'");

  bool ret = false;

  if (!path || path[0] == '\0') goto do_return;

  for (stores_t::iterator i = stores.begin(); i != stores.end(); ++i)
  {
    if ((*i)->name != path) continue;

    del_store(*i);

    stores.erase(i);

    ret = true;
  }

  if (!ret)
  {
    SCDC_FAIL_F("removing store '" << path << "' failed");
  }

do_return:
  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1fab7
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x1fab7
movq %rdi, %r15
xorl %ebx, %ebx
movq %rdi, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x1fabe
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0x1b1d7
testb %al, %al
jne 0x1fa81
movq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x1fb74
movq %r15, %rdi
movq %r12, %rsi
callq 0x21964
movb $0x1, %bl
jmp 0x1fa81
xorl %ebx, %ebx
jmp 0x1fb62
testb $0x1, %bl
jne 0x1fb62
leaq 0x55ab2(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x1fb62
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x8(%rax), %rdi
leaq 0x31695(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x31f13(%rip), %rsi     # 0x51a12
movq %rax, %rdi
callq 0xb520
leaq 0x31f39(%rip), %rsi     # 0x51a47
movq %rax, %rdi
callq 0xb520
leaq 0x34f86(%rip), %rsi     # 0x54aa3
movq %rax, %rdi
callq 0xb520
leaq 0x33bc5(%rip), %rsi     # 0x536f1
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r14, %rsi
callq 0xb520
leaq 0x3334a(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::ls_entries(scdc_dataprov_store_mem_handler::store_data_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_store_mem_handler::ls_entries(store_t store, std::string &result)
{
  SCDC_TRACE_F("store: '" << store << "'");

  bool ret = false;

  result = zxx::to_string(store->entries.size()) + "|";

  for (entries_t::const_iterator i = store->entries.begin(); i != store->entries.end(); ++i)
  {
    result += (*i)->name + ":" + zxx::to_string((*i)->buf.current) + "|";
  }

  ret = true;

  SCDC_TRACE_F("return: " << ret << ", result: " << result);

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq 0x30(%rsi), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2188b
leaq 0x32905(%rip), %rdx     # 0x524d2
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb18
addq $0x20, %r14
leaq 0x28(%rsp), %r15
movq %r12, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0xb690
movq %r15, %rdi
callq 0xb230
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xb230
leaq 0x68(%rsp), %rbp
leaq 0x48(%rsp), %r13
movq %r14, %rbx
movq (%r14), %r14
cmpq %rbx, %r14
je 0x1fc8d
movq 0x10(%r14), %rsi
movq %rbp, %rdi
leaq 0x3171a(%rip), %rdx     # 0x51344
callq 0x1d867
movq 0x10(%r14), %rax
movq 0x30(%rax), %rsi
movq %r13, %rdi
callq 0x21972
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x218f1
movq %r15, %rdi
movq %r12, %rsi
leaq 0x32878(%rip), %rdx     # 0x524d2
callq 0x1cb18
movq (%rsp), %rdi
movq %r15, %rsi
callq 0xba90
movq %r15, %rdi
callq 0xb230
movq %r12, %rdi
callq 0xb230
movq %r13, %rdi
callq 0xb230
movq %rbp, %rdi
callq 0xb230
jmp 0x1fc14
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x1fce0
movq %rax, %rbx
jmp 0x1fcdb
movq %rax, %rbx
jmp 0x1fcd1
movq %rax, %rbx
jmp 0x1fcc7
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb230
leaq 0x8(%rsp), %rdi
callq 0xb230
leaq 0x48(%rsp), %rdi
callq 0xb230
leaq 0x68(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::find_entry(scdc_dataprov_store_mem_handler::store_data_t*, char const*)
scdc_dataprov_store_mem_handler::entry_t scdc_dataprov_store_mem_handler::find_entry(store_t store, const char *path)
{
  SCDC_TRACE_F("store: '" << store << "', path: '" << path << "'");

  entry_t ret = entry_null;

  if (!path || path[0] == '\0') goto do_return;

  for (entries_t::const_iterator i = store->entries.begin(); ret == entry_null && i != store->entries.end(); ++i)
  {
    if ((*i)->name == path) ret = *i;
  }

do_return:
  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
testq %rdx, %rdx
je 0x1ffce
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpb $0x0, (%rdx)
je 0x1ffc6
movq %rsi, %r14
addq $0x20, %r14
movq %r14, %r15
xorl %eax, %eax
testq %rax, %rax
jne 0x1ffc8
movq (%r15), %r15
cmpq %r14, %r15
je 0x1ffc6
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x19be0
movl %eax, %ecx
movl $0x0, %eax
testb %cl, %cl
je 0x1ff9c
movq 0x10(%r15), %rax
jmp 0x1ff9c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::rm_entry(scdc_dataprov_store_mem_handler::store_data_t*, char const*)
bool scdc_dataprov_store_mem_handler::rm_entry(store_t store, const char *path)
{
  SCDC_TRACE_F("store: '" << store << "', path: '" << path << "'");

  bool ret = false;

  if (!path || path[0] == '\0') goto do_return;

  for (entries_t::iterator i = store->entries.begin(); i != store->entries.end(); ++i)
  {
    if ((*i)->name != path) continue;

    del_entry(store, *i);

    store->entries.erase(i);

    ret = true;
  }

  if (!ret)
  {
    SCDC_FAIL_F("removing entry '" << path << "' failed");
  }

do_return:
  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x20026
movq %rdx, %r14
cmpb $0x0, (%rdx)
je 0x20026
movq %rsi, %r15
addq $0x20, %r15
xorl %ebx, %ebx
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x2002d
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0x1b1d7
testb %al, %al
jne 0x1fff3
movq 0x10(%r12), %rdx
callq 0x200e2
movq %r15, %rdi
movq %r12, %rsi
callq 0x219d2
movb $0x1, %bl
jmp 0x1fff3
xorl %ebx, %ebx
jmp 0x200d1
testb $0x1, %bl
jne 0x200d1
leaq 0x55543(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x200d1
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x8(%rax), %rdi
leaq 0x31126(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x319a4(%rip), %rsi     # 0x51a12
movq %rax, %rdi
callq 0xb520
leaq 0x319e8(%rip), %rsi     # 0x51a65
movq %rax, %rdi
callq 0xb520
leaq 0x34a17(%rip), %rsi     # 0x54aa3
movq %rax, %rdi
callq 0xb520
leaq 0x33682(%rip), %rsi     # 0x5371d
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r14, %rsi
callq 0xb520
leaq 0x32ddb(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::entry_open(scdc_dataprov_store_mem_handler::store_data_t*, char const*, bool, bool, bool)
scdc_dataprov_store_mem_handler::entry_t scdc_dataprov_store_mem_handler::entry_open(store_t store, const char *path, bool read, bool write, bool create)
{
  SCDC_TRACE_F("path: '" << path << "', read: " << read << ", write: " << write << ", create: " << create);

  entry_t entry = entry_null;

  if (!path || path[0] == '\0') goto do_return;

  entry = find_entry(store, path);

  if (entry == entry_null)
  {
    if (!create)
    {
      SCDC_FAIL_F("opening entry '" << path << "' failed");
      goto do_return;
    }

    entry = add_entry(store, path);

    store->entries.push_back(entry);
  }

do_return:
  SCDC_TRACE_F("return: " << entry);

  return entry;
}

// Assembly:
testq %rdx, %rdx
je 0x20160
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
cmpb $0x0, (%rdx)
je 0x201fe
movl %r9d, %ebp
movq %rsi, %r14
movq %rbx, %rdx
callq 0x1ff7e
testq %rax, %rax
jne 0x20200
testb %bpl, %bpl
je 0x20163
movq %rbx, %rdx
callq 0x2020a
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x219e0
movq (%rbx), %rax
jmp 0x20200
xorl %eax, %eax
retq
leaq 0x55416(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x201fe
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x30ff9(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x31877(%rip), %rsi     # 0x51a12
movq %rax, %rdi
callq 0xb520
leaq 0x318c4(%rip), %rsi     # 0x51a6e
movq %rax, %rdi
callq 0xb520
leaq 0x348ea(%rip), %rsi     # 0x54aa3
movq %rax, %rdi
callq 0xb520
leaq 0x318b1(%rip), %rsi     # 0x51a79
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb520
leaq 0x32cae(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::add_entry(scdc_dataprov_store_mem_handler::store_data_t*, char const*)
scdc_dataprov_store_mem_handler::entry_t scdc_dataprov_store_mem_handler::add_entry(store_t store, const char *path)
{
  SCDC_TRACE_F("store: '" << store << "', path: '" << path << "'");

  entry_t entry = new entry_data_t;
  entry->name = path;
  entry->buf.ptr = 0;
  entry->buf.size = entry->buf.current = 0;

  SCDC_TRACE_F("return: entry: " << entry);

  return entry;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
pushq $0x38
popq %rdi
callq 0xb540
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xba40
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
andq $0x0, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::entry_read_at(scdc_dataprov_store_mem_handler::store_data_t*, scdc_dataprov_store_mem_handler::entry_data_t*, void*, long long, long long)
scdcint_t scdc_dataprov_store_mem_handler::entry_read_at(store_t store, entry_t entry, void *ptr, scdcint_t size, scdcint_t pos)
{
  SCDC_TRACE_F("store: '" << store << "', entry: '" << entry << "', ptr: " << ptr << ", size: " << size << ", pos: " << pos);

  scdcint_t n = -1;

  if (!entry->buf.ptr) goto do_return;

  if (pos < 0) pos = 0;

  if (pos > entry->buf.size) goto do_return;

  if (size < 0 || size > entry->buf.size - pos) size = entry->buf.size - pos;

  memcpy(ptr, static_cast<char *>(entry->buf.ptr) + pos, size);
  n = size;

do_return:
  SCDC_TRACE_F("return: " << n);

  return n;
}

// Assembly:
pushq %rbx
movq 0x20(%rdx), %rsi
pushq $-0x1
popq %rbx
testq %rsi, %rsi
je 0x2032e
xorl %eax, %eax
testq %r9, %r9
cmovgq %r9, %rax
movq 0x28(%rdx), %rdx
subq %rax, %rdx
jl 0x2032e
cmpq %r8, %rdx
movq %r8, %rbx
cmovlq %rdx, %rbx
testq %r8, %r8
cmovsq %rdx, %rbx
addq %rax, %rsi
movq %rcx, %rdi
movq %rbx, %rdx
callq 0xb420
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::entry_write_at(scdc_dataprov_store_mem_handler::store_data_t*, scdc_dataprov_store_mem_handler::entry_data_t*, void const*, long long, long long)
scdcint_t scdc_dataprov_store_mem_handler::entry_write_at(store_t store, entry_t entry, const void *ptr, scdcint_t size, scdcint_t pos)
{
  SCDC_TRACE_F("store: '" << store << "', entry: '" << entry << "', ptr: " << ptr << ", size: " << size << ", pos: " << pos);

  scdcint_t n = -1;

  if (size < 0) goto do_return;

  if (pos < 0) pos = entry->buf.current;

  if (pos + size > entry->buf.size)
  {
    scdcint_t new_size = pos + size;
    void *new_ptr = realloc(entry->buf.ptr, new_size);

    if (!new_ptr) goto do_return;

    entry->buf.ptr = new_ptr;
    entry->buf.size = new_size;
  }

  memcpy(static_cast<char *>(entry->buf.ptr) + pos, ptr, size);
  entry->buf.current = pos + size;
  n = size;

do_return:
  SCDC_TRACE_F("return: " << n);

  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %r13
testq %r8, %r8
js 0x20398
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
testq %r9, %r9
jns 0x2035d
movq 0x30(%r14), %r12
leaq (%r12,%rbx), %rbp
movq 0x20(%r14), %rdi
cmpq 0x28(%r14), %rbp
jle 0x20383
movq %rbp, %rsi
callq 0xb970
testq %rax, %rax
je 0x20398
movq %rax, %rdi
movq %rax, 0x20(%r14)
movq %rbp, 0x28(%r14)
addq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xb420
movq %rbp, 0x30(%r14)
movq %rbx, %r13
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::clear_entries(scdc_dataprov_store_mem_handler::store_data_t*)
void scdc_dataprov_store_mem_handler::clear_entries(store_t store)
{
  SCDC_TRACE_F("store: '" << store << "'");

  for (entries_t::iterator i = store->entries.begin(); i != store->entries.end(); ++i) del_entry(store, *i);

  store->entries.clear();

  SCDC_TRACE_F("return:");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq $0x20, %rbx
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x203cb
movq 0x10(%r14), %rdx
callq 0x200e2
jmp 0x203b8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a1a
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/../include/common.hh
// Function: string_pop_front(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char)
static inline std::string string_pop_front(std::string &s, char c = ' ')
{
  size_t n = s.find(c);
  std::string r = s.substr(0, n);
  if (n != std::string::npos) s.erase(0, n + 1);
  else s.clear();
  return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
xorl %edx, %edx
callq 0xb710
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb560
cmpq $-0x1, %r15
je 0x2041c
incq %r15
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0xb0e0
jmp 0x20427
andq $0x0, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xb230
movq %r14, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset.cc
// Function: scdc_dataset::do_cmd_info(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataset::do_cmd_info(const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
{
  SCDC_TRACE("do_cmd_info: params: '" << params << "'");

  SCDC_INFO("dataprov: '" << dataprov << "'");
  SCDC_INFO("config: '" << config << "'");
  SCDC_INFO("pwd: '" << pwd << "'");

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x51167(%rip), %r12     # 0x75580
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x245f9
addq $0x20, %rdi
callq 0xb800
movq (%r12), %rax
movq 0x8(%rax), %rdi
leaq 0x2daa8(%rip), %rsi     # 0x51ee8
callq 0xb520
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x24620
movq %r14, %rdi
movq %r15, %rsi
callq 0xb490
leaq 0x2da8d(%rip), %rsi     # 0x51ef4
movq %rax, %rdi
callq 0xb520
leaq 0x2da88(%rip), %rsi     # 0x51efe
movq %rax, %rdi
callq 0xb520
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0xb3f0
leaq 0x2eed2(%rip), %rsi     # 0x53363
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
leaq 0x8(%rsp), %rdi
callq 0xb230
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3e0
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x245f9
addq $0x20, %rdi
callq 0xb800
movq (%r12), %rax
movq 0x8(%rax), %rdi
leaq 0x2da09(%rip), %rsi     # 0x51ee8
callq 0xb520
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x24620
movq %r14, %rdi
movq %r15, %rsi
callq 0xb490
leaq 0x2d9ee(%rip), %rsi     # 0x51ef4
movq %rax, %rdi
callq 0xb520
leaq 0x2d9f5(%rip), %rsi     # 0x51f0a
movq %rax, %rdi
callq 0xb520
movzbl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0xb980
leaq 0x2ee33(%rip), %rsi     # 0x53363
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
leaq 0x8(%rsp), %rdi
callq 0xb230
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3e0
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x245f9
addq $0x20, %rdi
callq 0xb800
movq (%r12), %rax
movq 0x8(%rax), %rdi
leaq 0x2d96a(%rip), %rsi     # 0x51ee8
callq 0xb520
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x24620
movq %r14, %rdi
movq %r15, %rsi
callq 0xb490
leaq 0x2d94f(%rip), %rsi     # 0x51ef4
movq %rax, %rdi
callq 0xb520
leaq 0x2d960(%rip), %rsi     # 0x51f14
movq %rax, %rdi
callq 0xb520
addq $0x18, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb490
leaq 0x2ed91(%rip), %rsi     # 0x53363
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
leaq 0x8(%rsp), %rdi
callq 0xb230
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3e0
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2460b
jmp 0x2460b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0