LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x344ca
movq -0x30(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
callq 0x34e40
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x98, %rdi
callq 0x349b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x34ab0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x34554
leaq -0x20(%rbp), %rdi
callq 0x349e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x311b0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x34536
jmp 0x34554
movq -0x30(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
callq 0x34f60
cmpq $0x1, %rax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x34560
jmp 0x34607
jmp 0x34562
leaq 0xa013f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x345ff
leaq 0xa0126(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0xa0117(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x71c0d(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x722df(%rip), %rsi     # 0xa6891
callq 0xc670
movq %rax, %rdi
leaq 0x72288(%rip), %rsi     # 0xa6849
callq 0xc670
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc5b0
movq %rax, %rdi
leaq 0x73930(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x9f9d5(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0xa00b1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x34601
movb $0x0, -0x1(%rbp)
jmp 0x3460b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x34641
movq -0x18(%rbp), %rdi
leaq 0x71f58(%rip), %rsi     # 0xa65a4
callq 0xc920
movq -0x70(%rbp), %rdi
addq $0x98, %rdi
callq 0x34950
movq %rax, -0x20(%rbp)
movq -0x70(%rbp), %rdi
addq $0x98, %rdi
callq 0x349b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x34980
testb $0x1, %al
jne 0x3468f
jmp 0x34784
movq -0x10(%rbp), %rdi
leaq 0x71f0a(%rip), %rsi     # 0xa65a4
callq 0x2b120
testb $0x1, %al
jne 0x346a5
jmp 0x34721
movq -0x70(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x80(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x349e0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x31580
movq -0x70(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x68, %rdi
callq 0x315b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x31600
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0x34714
leaq -0x30(%rbp), %rdi
callq 0x31630
movq %rax, %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x34a00
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x3471d
jmp 0x3471f
jmp 0x3475f
jmp 0x34721
leaq -0x20(%rbp), %rdi
callq 0x349e0
movq %rax, %rsi
leaq 0x72135(%rip), %rdx     # 0xa6869
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x31740
movq -0x88(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0xc8a0
jmp 0x34756
leaq -0x58(%rbp), %rdi
callq 0xc3e0
leaq -0x20(%rbp), %rdi
callq 0x34a80
jmp 0x34665
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xc3e0
jmp 0x347c7
movq -0x18(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jbe 0x347ba
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc460
movq -0x90(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xc940
movb $0x1, %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xcba0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x347ea
movq -0x30(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
callq 0x34e40
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x98, %rdi
callq 0x349b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x34ab0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x3484d
leaq -0x20(%rbp), %rdi
callq 0x349e0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x30c90
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x34859
jmp 0x34900
jmp 0x3485b
leaq 0x9fe46(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x348f8
leaq 0x9fe2d(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x9fe1e(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x71914(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x71fe6(%rip), %rsi     # 0xa6891
callq 0xc670
movq %rax, %rdi
leaq 0x720d1(%rip), %rsi     # 0xa698b
callq 0xc670
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc5b0
movq %rax, %rdi
leaq 0x73637(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x9f6dc(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x9fdb8(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x348fa
movb $0x0, -0x1(%rbp)
jmp 0x34904
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x3510d
movq -0x78(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xcbc0
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0xc7a0
jmp 0x3515c
leaq -0x58(%rbp), %rdi
callq 0xc260
movq -0x98(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
xorl %eax, %eax
callq 0x23d80
movq %rax, -0xa0(%rbp)
jmp 0x35187
leaq -0x58(%rbp), %rdi
callq 0xc3e0
leaq -0x59(%rbp), %rdi
callq 0xc730
movq -0xa0(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x351a6
cmpq $0x1, -0x38(%rbp)
sete %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x351dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xc3e0
leaq -0x59(%rbp), %rdi
callq 0xc730
movq -0x68(%rbp), %rdi
callq 0xcba0
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::open_config_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_args*, bool&)
bool scdc_dataprov_store_mem_handler::open_config_conf(const std::string &conf, scdc_args *args, bool &done)
{
  SCDC_TRACE_F("conf: '" << conf << "'");

  bool ret = false;
  done = false;

  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x36446
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x36453
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::open_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, scdc_args*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_store_mem_handler::open_conf(std::string &conf, scdc_args *args, scdc_result &result)
{
  SCDC_TRACE_F("conf: '" << conf << "'");

  bool ret = true;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x36476
movb $0x1, -0x21(%rbp)
jmp 0x3647c
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_store_mem_handler::open(scdc_result &result)
{
  SCDC_TRACE_F("conf: '" << conf << "'");

  bool ret = true;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x3649e
movb $0x1, -0x11(%rbp)
jmp 0x364a4
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_store_mem_handler::close(scdc_result &result)
{
  SCDC_TRACE_F();

  bool ret = true;

  clear_stores();

  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x364ca
movq -0x20(%rbp), %rdi
movb $0x1, -0x11(%rbp)
callq 0x364f0
jmp 0x364d9
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x36506
movq -0x20(%rbp), %rdi
callq 0x3af40
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3afc0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3b1d0
testb $0x1, %al
jne 0x36533
jmp 0x36553
leaq -0x10(%rbp), %rdi
callq 0x3b200
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0x36f30
leaq -0x10(%rbp), %rdi
callq 0x3b270
jmp 0x36513
movq -0x20(%rbp), %rdi
callq 0x3b620
jmp 0x3655e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
jmp 0x36590
movq -0xb0(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x3af10
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x3ae30
movq -0xb8(%rbp), %rsi
leaq 0x70f3e(%rip), %rdx     # 0xa74ff
leaq -0x38(%rbp), %rdi
callq 0x2eef0
jmp 0x365cc
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc850
leaq -0x38(%rbp), %rdi
callq 0xc3e0
leaq -0x58(%rbp), %rdi
callq 0xc3e0
movq -0xb0(%rbp), %rdi
callq 0x3af40
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3af70
movq -0xb0(%rbp), %rdi
callq 0x3afc0
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x3af70
leaq -0x70(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x3af90
testb $0x1, %al
jne 0x36641
jmp 0x366c4
leaq -0x70(%rbp), %rdi
callq 0x3aff0
movq (%rax), %rsi
leaq 0x70eab(%rip), %rdx     # 0xa74ff
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x31740
movq -0xc0(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0xc8a0
jmp 0x36679
leaq -0xa8(%rbp), %rdi
callq 0xc3e0
leaq -0x70(%rbp), %rdi
callq 0x3b020
jmp 0x36608
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xc3e0
jmp 0x366d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xc3e0
jmp 0x366d8
movb $0x1, -0x11(%rbp)
jmp 0x366ca
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x36b1a
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x36b35
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x36b3a
jmp 0x36bcd
movq -0x40(%rbp), %rdi
callq 0x3af40
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3af70
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x41(%rbp)
jne 0x36b8a
movq -0x40(%rbp), %rdi
callq 0x3afc0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3af70
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3af90
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x36b93
jmp 0x36bcb
leaq -0x20(%rbp), %rdi
callq 0x3aff0
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x25b80
testb $0x1, %al
jne 0x36bae
jmp 0x36bbe
leaq -0x20(%rbp), %rdi
callq 0x3aff0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x36bc0
leaq -0x20(%rbp), %rdi
callq 0x3b020
jmp 0x36b54
jmp 0x36bcd
jmp 0x36bcf
jmp 0x36bd1
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x36bfa
movb $0x0, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x36c19
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x36c1e
jmp 0x36d24
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36b00
cmpq $0x0, %rax
je 0x36c36
jmp 0x36d24
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36d40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x36d13
jmp 0x36c54
leaq 0x9da4d(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x36d0f
leaq 0x9da34(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x9da25(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x6f51b(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x6fdce(%rip), %rsi     # 0xa6a72
callq 0xc670
movq %rax, %rdi
leaq 0x6fdf4(%rip), %rsi     # 0xa6aa7
callq 0xc670
movq %rax, %rdi
leaq 0x72e29(%rip), %rsi     # 0xa9aeb
callq 0xc670
movq %rax, %rdi
leaq 0x6fddf(%rip), %rsi     # 0xa6ab0
callq 0xc670
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xc670
movq %rax, %rdi
leaq 0x71220(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x9d2c5(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x9d9a1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x36d11
jmp 0x36d24
movq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3b190
movb $0x1, -0x11(%rbp)
jmp 0x36d26
jmp 0x36d28
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x36d52
movl $0x38, %edi
callq 0xc690
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
callq 0x3b5c0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0xc920
jmp 0x36d7f
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x36daa
movb $0x0, -0x11(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x36dc1
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x36dc6
jmp 0x36f1f
movq -0x40(%rbp), %rdi
callq 0x3af40
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
callq 0x3afc0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b1d0
testb $0x1, %al
jne 0x36df3
jmp 0x36e52
leaq -0x20(%rbp), %rdi
callq 0x3b200
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b120
testb $0x1, %al
jne 0x36e0e
jmp 0x36e10
jmp 0x36e47
leaq -0x20(%rbp), %rdi
callq 0x3b200
movq -0x40(%rbp), %rdi
movq (%rax), %rsi
callq 0x36f30
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3af70
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3b220
movq %rax, -0x38(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3b270
jmp 0x36dd3
testb $0x1, -0x11(%rbp)
jne 0x36f1d
jmp 0x36e5e
leaq 0x9d843(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x36f19
leaq 0x9d82a(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x9d81b(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x6f311(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x6fbc4(%rip), %rsi     # 0xa6a72
callq 0xc670
movq %rax, %rdi
leaq 0x6fc02(%rip), %rsi     # 0xa6abf
callq 0xc670
movq %rax, %rdi
leaq 0x72c1f(%rip), %rsi     # 0xa9aeb
callq 0xc670
movq %rax, %rdi
leaq 0x71886(%rip), %rsi     # 0xa8761
callq 0xc670
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xc670
movq %rax, %rdi
leaq 0x71016(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x9d0bb(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x9d797(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x36f1b
jmp 0x36f1d
jmp 0x36f1f
jmp 0x36f21
jmp 0x36f23
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::del_store(scdc_dataprov_store_mem_handler::store_data_t*)
void scdc_dataprov_store_mem_handler::del_store(store_t store)
{
  SCDC_TRACE_F("store: '" << store << "'");

  clear_entries(store);

  delete store;

  SCDC_TRACE_F("return:");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x36f4a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x37ef0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x36f7c
movq -0x20(%rbp), %rdi
callq 0x3b5f0
movq -0x20(%rbp), %rdi
movl $0x38, %esi
callq 0xc6a0
jmp 0x36f7e
jmp 0x36f80
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::store_open(char const*)
scdc_dataprov_store_mem_handler::store_t scdc_dataprov_store_mem_handler::store_open(const char *path)
{
  SCDC_TRACE_F("path: '" << path << "'");

  store_t store = find_store(path);

  SCDC_TRACE_F("return: " << store);

  return store;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x36faa
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x36b00
movq %rax, -0x18(%rbp)
jmp 0x36fbd
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x37646
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x37661
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x37666
jmp 0x37701
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b290
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3b2c0
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x41(%rbp)
jne 0x376be
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b310
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3b2c0
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3b2e0
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x376c7
jmp 0x376ff
leaq -0x28(%rbp), %rdi
callq 0x3b340
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x25b80
testb $0x1, %al
jne 0x376e2
jmp 0x376f2
leaq -0x28(%rbp), %rdi
callq 0x3b340
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x376f4
leaq -0x28(%rbp), %rdi
callq 0x3b4a0
jmp 0x37684
jmp 0x37701
jmp 0x37703
jmp 0x37705
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x3772e
movb $0x0, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x37745
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3774a
jmp 0x378c6
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b290
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b310
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3b4c0
testb $0x1, %al
jne 0x3777f
jmp 0x377f9
leaq -0x28(%rbp), %rdi
callq 0x3b4f0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2b120
testb $0x1, %al
jne 0x3779a
jmp 0x3779c
jmp 0x377eb
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3b4f0
movq -0x48(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rax), %rdx
callq 0x378e0
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b2c0
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3b510
movq %rax, -0x40(%rbp)
movb $0x1, -0x19(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3b560
jmp 0x3775b
testb $0x1, -0x19(%rbp)
jne 0x378c4
jmp 0x37805
leaq 0x9ce9c(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x378c0
leaq 0x9ce83(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x9ce74(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x6e96a(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x6f21d(%rip), %rsi     # 0xa6a72
callq 0xc670
movq %rax, %rdi
leaq 0x6f279(%rip), %rsi     # 0xa6add
callq 0xc670
movq %rax, %rdi
leaq 0x72278(%rip), %rsi     # 0xa9aeb
callq 0xc670
movq %rax, %rdi
leaq 0x70f0b(%rip), %rsi     # 0xa878d
callq 0xc670
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc670
movq %rax, %rdi
leaq 0x7066f(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x9c714(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x9cdf0(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x378c2
jmp 0x378c4
jmp 0x378c6
jmp 0x378c8
jmp 0x378ca
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::del_entry(scdc_dataprov_store_mem_handler::store_data_t*, scdc_dataprov_store_mem_handler::entry_data_t*)
void scdc_dataprov_store_mem_handler::del_entry(store_t store, entry_t entry)
{
  SCDC_TRACE_F("store: '" << store << "', entry: '" << entry << "'");

  if (entry->buf.ptr) free(entry->buf.ptr);

  delete entry;

  SCDC_TRACE_F("return:");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x378f6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3790e
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xc830
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x37933
movq -0x20(%rbp), %rdi
callq 0x3b670
movq -0x20(%rbp), %rdi
movl $0x38, %esi
callq 0xc6a0
jmp 0x37935
jmp 0x37937
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %r8d, -0x48(%rbp)
movl %ecx, %eax
movl -0x48(%rbp), %ecx
movl %eax, -0x44(%rbp)
movq %rdx, %rax
movl -0x44(%rbp), %edx
movq %rax, -0x40(%rbp)
movq %rsi, %rax
movq -0x40(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq %rdi, %r8
movq -0x38(%rbp), %rdi
movb %r9b, %al
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
andb $0x1, %cl
movb %cl, -0x1a(%rbp)
andb $0x1, %al
movb %al, -0x1b(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x3799a
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x379b5
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x379ba
jmp 0x37acd
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37630
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x37acb
testb $0x1, -0x1b(%rbp)
jne 0x37aa5
jmp 0x379e6
leaq 0x9ccbb(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x37aa1
leaq 0x9cca2(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x9cc93(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x6e789(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x6f03c(%rip), %rsi     # 0xa6a72
callq 0xc670
movq %rax, %rdi
leaq 0x6f0a1(%rip), %rsi     # 0xa6ae6
callq 0xc670
movq %rax, %rdi
leaq 0x72097(%rip), %rsi     # 0xa9aeb
callq 0xc670
movq %rax, %rdi
leaq 0x6f08e(%rip), %rsi     # 0xa6af1
callq 0xc670
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc670
movq %rax, %rdi
leaq 0x7048e(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x9c533(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x9cc0f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x37aa3
jmp 0x37acd
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37ae0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x3b580
jmp 0x37acd
jmp 0x37acf
jmp 0x37ad1
movq -0x28(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x37af6
movl $0x38, %edi
callq 0xc690
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x3b650
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc920
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0x37b47
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::entry_reopen(scdc_dataprov_store_mem_handler::store_data_t*, char const*, bool, bool, bool, scdc_dataprov_store_mem_handler::entry_data_t*)
scdc_dataprov_store_mem_handler::entry_t scdc_dataprov_store_mem_handler::entry_reopen(store_t store, const char *path, bool read, bool write, bool create, entry_t entry)
{
  SCDC_TRACE_F("path: '" << path << "', read: " << read << ", write: " << write << ", create: " << create << ", entry: " << entry);

  if (entry->name == path) goto do_return;

  entry_close(store, entry);

  entry = entry_open(store, path, read, write, create);

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

  return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %r8d, -0x40(%rbp)
movl %ecx, %eax
movl -0x40(%rbp), %ecx
movl %eax, -0x3c(%rbp)
movq %rdx, %rax
movl -0x3c(%rbp), %edx
movq %rax, -0x38(%rbp)
movq %rsi, %rax
movq -0x38(%rbp), %rsi
movq %rax, -0x30(%rbp)
movq %rdi, %r8
movq -0x30(%rbp), %rdi
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
andb $0x1, %cl
movb %cl, -0x1a(%rbp)
andb $0x1, %al
movb %al, -0x1b(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x37bbe
movq 0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x25b80
testb $0x1, %al
jne 0x37bd1
jmp 0x37bd3
jmp 0x37c17
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x37c30
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %cl
movb -0x1a(%rbp), %r8b
movb -0x1b(%rbp), %al
andb $0x1, %cl
andb $0x1, %r8b
andb $0x1, %al
movzbl %cl, %ecx
movzbl %r8b, %r8d
movzbl %al, %r9d
callq 0x37940
movq %rax, 0x10(%rbp)
jmp 0x37c19
jmp 0x37c1b
movq 0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::entry_match(scdc_dataprov_store_mem_handler::store_data_t*, scdc_dataprov_store_mem_handler::entry_data_t*, char const*)
bool scdc_dataprov_store_mem_handler::entry_match(store_t store, entry_t entry, const char *path)
{
  SCDC_TRACE_F("entry: '" << entry << "', path: '" << path << "'");

  bool ret = (entry->name == path);

  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x37c6a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x25b80
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x37c7e
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::entry_read_access_at(scdc_dataprov_store_mem_handler::store_data_t*, scdc_dataprov_store_mem_handler::entry_data_t*, long long, long long, _scdc_buf_t&)
bool scdc_dataprov_store_mem_handler::entry_read_access_at(store_t store, entry_t entry, scdcint_t size, scdcint_t pos, scdc_buf_t &buf)
{
  SCDC_TRACE_F("store: '" << store << "', entry: '" << entry << "', size: " << size << ", pos: " << pos);

  bool ret = false;

  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;

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

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x37cae
movb $0x0, -0x31(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x37cbf
jmp 0x37d3d
cmpq $0x0, -0x28(%rbp)
jge 0x37cce
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jle 0x37cde
jmp 0x37d3d
cmpq $0x0, -0x20(%rbp)
jl 0x37cfa
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq -0x28(%rbp), %rcx
cmpq %rcx, %rax
jle 0x37d0a
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
addq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
subq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x37d3f
jmp 0x37d41
movb -0x31(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x37d72
movq $-0x1, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x37d87
jmp 0x37df3
cmpq $0x0, -0x30(%rbp)
jge 0x37d96
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jle 0x37da6
jmp 0x37df3
cmpq $0x0, -0x28(%rbp)
jl 0x37dc2
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq -0x30(%rbp), %rcx
cmpq %rcx, %rax
jle 0x37dd2
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
addq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc530
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x37df5
jmp 0x37df7
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x37e32
movq $-0x1, -0x38(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x37e46
jmp 0x37ede
cmpq $0x0, -0x30(%rbp)
jge 0x37e59
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jle 0x37ead
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0xcb50
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x37e95
jmp 0x37ede
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
addq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc530
movq -0x30(%rbp), %rcx
addq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x37ee0
jmp 0x37ee2
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x37f0a
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b290
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b310
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3b4c0
testb $0x1, %al
jne 0x37f3f
jmp 0x37f6b
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3b4f0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq (%rax), %rdx
callq 0x378e0
leaq -0x18(%rbp), %rdi
callq 0x3b560
jmp 0x37f1b
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x3b690
jmp 0x37f7a
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movsbl -0x11(%rbp), %esi
callq 0xc8e0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0xc6b0
cmpq $-0x1, -0x20(%rbp)
je 0x38004
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
incq %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0xc110
jmp 0x37feb
jmp 0x3800d
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xc3e0
jmp 0x3802a
movq -0x10(%rbp), %rdi
callq 0xc8f0
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x38020
movq -0x40(%rbp), %rdi
callq 0xc3e0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_stub_handler.cc
// Function: scdc_dataprov_store_stub_handler::open_config_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_args*, bool&)
bool scdc_dataprov_store_stub_handler::open_config_conf(const std::string &conf, scdc_args *args, bool &done)
{
  SCDC_TRACE_F("conf: '" << conf << "'");

  bool ret = true;
  done = true;

  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x419b6
movb $0x1, -0x21(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
jmp 0x419c3
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_stub_handler.cc
// Function: scdc_dataprov_store_stub_handler::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_store_stub_handler::open(scdc_result &result)
{
  SCDC_TRACE_F("conf: '" << conf << "'");

  bool ret = true;

  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x41a0e
movb $0x1, -0x11(%rbp)
jmp 0x41a14
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_stub_handler.cc
// Function: scdc_dataprov_store_stub_handler::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_store_stub_handler::close(scdc_result &result)
{
  SCDC_TRACE_F("");

  bool ret = true;

  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x41a2e
movb $0x1, -0x11(%rbp)
jmp 0x41a34
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_stub_handler.cc
// Function: scdc_dataprov_store_stub_handler::store_open(char const*)
scdc_dataprov_store_stub_handler::store_t scdc_dataprov_store_stub_handler::store_open(const char *path)
{
  SCDC_TRACE_F("path: '" << path << "'");

  store_t store = store_valid;

  SCDC_TRACE_F("return: " << store);

  return store;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x41bde
movl $0x1, %eax
movq %rax, -0x18(%rbp)
jmp 0x41be9
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_stub_handler.cc
// Function: scdc_dataprov_store_stub_handler::rm_entry(void*, char const*)
bool scdc_dataprov_store_stub_handler::rm_entry(store_t store, const char *path)
{
  SCDC_TRACE_F("store: '" << store << "', path: '" << path << "'");

  bool ret = true;

  SCDC_TRACE_F("return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x41d72
movb $0x1, -0x19(%rbp)
jmp 0x41d78
movb -0x19(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop