LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq 0x38(%rdi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x1bee6
movq (%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1aba8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2275d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
cmpq $0x1, %rbx
sete %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2278b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %rdi, %r14
je 0x22cf3
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x2383a
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x22cdf
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26994
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x22d74
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x22d6d
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x22d72
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x22d74
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x22d37
addl $-0x3, %esi
jmp 0x22d74
addl $-0x2, %esi
jmp 0x22d74
decl %esi
movl %esi, %esi
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0xb610
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x26e08
leaq 0x4877c(%rip), %rsi     # 0x6b522
movq %r12, %rdi
callq 0xba60
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x22dd5
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x22ddd
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb670
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x22e19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x22e30
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%r14), %rbp
cmpq %r14, %rbp
je 0x22e9c
leaq 0x8(%rsp), %r15
leaq 0x486de(%rip), %r12     # 0x6b522
movq 0x10(%rbp), %rax
movq %r13, 0x8(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1d19a
movq %r15, %rdi
movq %r12, %rsi
callq 0xba60
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xb150
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x22e93
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%rbp), %rbp
cmpq %r14, %rbp
jne 0x22e44
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x22edd
movq 0x38(%rsp), %rsi
jmp 0x22ed5
jmp 0x22ec3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x22edd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2360d
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, (%rsi)
setne %al
movq (%rdi), %r15
cmpq %rdi, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x23610
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0xb110
testl %eax, %eax
je 0x235fa
xorl %eax, %eax
jmp 0x235fe
movq 0x10(%r15), %rax
testq %rax, %rax
jne 0x23612
movq (%r15), %r15
cmpq %r14, %r15
jne 0x235e6
jmp 0x23612
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2363d
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x23639
movq %rdi, %rbx
movq %r14, %rsi
callq 0x235c0
testq %rax, %rax
je 0x23640
xorl %eax, %eax
jmp 0x2366a
xorl %eax, %eax
retq
movq %r14, %rsi
callq 0x23672
movq %rax, %r14
movl $0x18, %edi
callq 0xb500
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb090
incq 0x10(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x38, %edi
callq 0xb500
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x20(%r14), %rcx
movq %rcx, 0x28(%r14)
movq %rcx, 0x20(%r14)
movq %rax, 0x30(%r14)
movq %rbx, %rdi
callq 0xb200
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %rax, %r8
callq 0xb870
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2372f
movq %rsi, %r14
cmpb $0x0, (%rsi)
je 0x2372f
movq %rdi, %r15
movq (%rdi), %r12
xorl %ebx, %ebx
cmpq %r15, %r12
je 0x23736
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0xb110
testl %eax, %eax
jne 0x23729
movq 0x10(%r12), %rsi
movq %r15, %rdi
callq 0x2383a
decq 0x10(%r15)
movq %r12, %rdi
callq 0xb940
movl $0x18, %esi
movq %r12, %rdi
callq 0xb510
movb $0x1, %bl
movq (%r12), %r12
jmp 0x236eb
xorl %ebx, %ebx
jmp 0x23828
testb $0x1, %bl
jne 0x23828
leaq 0x68e2a(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x23828
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r15
leaq 0x46a1b(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x472dc(%rip), %rsi     # 0x6aa5d
movl $0x1c, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x472fd(%rip), %rsi     # 0x6aa92
movl $0x8, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x4a2fa(%rip), %rsi     # 0x6daa3
movl $0x2, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x48f2c(%rip), %rsi     # 0x6c6e9
movl $0x10, %edx
movq %r15, %rdi
callq 0xb5f0
movq %r14, %rdi
callq 0xb200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb5f0
leaq 0x486a1(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %r15, %rdi
callq 0xb5f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
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_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x24942
testq %rbx, %rbx
je 0x23897
leaq 0x20(%rbx), %r14
movq 0x20(%rbx), %rdi
cmpq %r14, %rdi
je 0x2386e
movq (%rdi), %r15
movl $0x18, %esi
callq 0xb510
movq %r15, %rdi
cmpq %r14, %r15
jne 0x23859
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x23885
movq (%rax), %rsi
incq %rsi
callq 0xb510
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb510
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2447d
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
cmpb $0x0, (%rdx)
je 0x24475
movq %rsi, %r14
movq 0x20(%rsi), %r15
addq $0x20, %r14
cmpq %r14, %r15
je 0x24475
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0xb110
testl %eax, %eax
je 0x24462
xorl %eax, %eax
jmp 0x24466
movq 0x10(%r15), %rax
testq %rax, %rax
jne 0x24477
movq (%r15), %r15
cmpq %r14, %r15
jne 0x2444e
jmp 0x24477
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x244e4
movq %rdx, %r14
cmpb $0x0, (%rdx)
je 0x244e4
movq %rsi, %r15
leaq 0x20(%rsi), %r13
movq 0x20(%rsi), %r12
xorl %ebx, %ebx
cmpq %r13, %r12
je 0x244eb
movq 0x10(%r12), %rdi
movq %r14, %rsi
callq 0xb110
testl %eax, %eax
jne 0x244de
movq 0x10(%r12), %rdx
callq 0x245ec
decq 0x30(%r15)
movq %r12, %rdi
callq 0xb940
movl $0x18, %esi
movq %r12, %rdi
callq 0xb510
movb $0x1, %bl
movq (%r12), %r12
jmp 0x244a3
xorl %ebx, %ebx
jmp 0x245dd
testb $0x1, %bl
jne 0x245dd
leaq 0x68075(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x245dd
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r15
leaq 0x45c66(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x46527(%rip), %rsi     # 0x6aa5d
movl $0x1c, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x46566(%rip), %rsi     # 0x6aab0
movl $0x8, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x49545(%rip), %rsi     # 0x6daa3
movl $0x2, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x481a3(%rip), %rsi     # 0x6c715
movl $0x10, %edx
movq %r15, %rdi
callq 0xb5f0
movq %r14, %rdi
callq 0xb200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb5f0
leaq 0x478ec(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %r15, %rdi
callq 0xb5f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdx, %rbx
movq 0x20(%rdx), %rdi
testq %rdi, %rdi
je 0x245fe
callq 0xb650
testq %rbx, %rbx
je 0x24628
movq (%rbx), %rdi
leaq 0x10(%rbx), %rax
cmpq %rax, %rdi
je 0x2461a
movq (%rax), %rsi
incq %rsi
callq 0xb510
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xb510
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x24688
movq %rdx, %r14
cmpb $0x0, (%rdx)
je 0x24688
movl %r9d, %ebp
movq %rsi, %r15
movq %r14, %rdx
callq 0x2442c
movq %rax, %rbx
testq %rax, %rax
jne 0x2468a
testb %bpl, %bpl
je 0x24696
movq %r14, %rdx
callq 0x24780
movq %rax, %rbx
leaq 0x20(%r15), %r14
movl $0x18, %edi
callq 0xb500
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0xb090
incq 0x30(%r15)
jmp 0x2468a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x67ed3(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2468a
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r15
leaq 0x45ac8(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x46389(%rip), %rsi     # 0x6aa5d
movl $0x1c, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x463d1(%rip), %rsi     # 0x6aab9
movl $0xa, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x493a7(%rip), %rsi     # 0x6daa3
movl $0x2, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x463b4(%rip), %rsi     # 0x6aac4
movl $0xf, %edx
movq %r15, %rdi
callq 0xb5f0
movq %r14, %rdi
callq 0xb200
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb5f0
leaq 0x4774e(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %r15, %rdi
callq 0xb5f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
jmp 0x2468a
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl $0x38, %edi
callq 0xb500
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
xorl %r15d, %r15d
movq %r15, 0x8(%r14)
movb $0x0, 0x10(%r14)
movq %rbx, %rdi
callq 0xb200
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
movq %rax, %r8
callq 0xb870
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movq %r15, 0x30(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x30(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0xb110
testl %eax, %eax
je 0x2481f
movzbl %bpl, %r9d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2462a
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $-0x1, %rbx
testq %rsi, %rsi
je 0x248c2
xorl %eax, %eax
testq %r9, %r9
cmovgq %r9, %rax
movq 0x28(%rdx), %rdx
subq %rax, %rdx
jl 0x248c2
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 0xb3f0
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $-0x1, %r13
testq %r8, %r8
js 0x24930
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
testq %r9, %r9
jns 0x248f4
movq 0x30(%r14), %r12
leaq (%r12,%rbx), %rbp
cmpq 0x28(%r14), %rbp
jle 0x24917
movq 0x20(%r14), %rdi
movq %rbp, %rsi
callq 0xb960
testq %rax, %rax
je 0x24930
movq %rax, 0x20(%r14)
movq %rbp, 0x28(%r14)
addq 0x20(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xb3f0
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_O1/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
movq 0x20(%rsi), %r14
addq $0x20, %rbx
cmpq %rbx, %r14
je 0x24964
movq 0x10(%r14), %rdx
callq 0x245ec
movq (%r14), %r14
jmp 0x24951
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x269d0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_printf
void scdc_dataset_output_printf(int append, scdc_dataset_output_t *output, const char *fmt, ...)
{
  if (!output || !SCDC_DATASET_INOUT_BUF_PTR(output)) return;

  strncpy(output->format, "text", SCDC_FORMAT_MAX_SIZE);

  if (!append)
  {
    SCDC_DATASET_INOUT_BUF_CURRENT(output) = 0;
    output->total_size = 0;
  }

  char *buf = static_cast<char *>(SCDC_DATASET_INOUT_BUF_PTR(output));
  buf += SCDC_DATASET_INOUT_BUF_CURRENT(output);

  scdcint_t buf_size = SCDC_DATASET_INOUT_BUF_SIZE(output) - SCDC_DATASET_INOUT_BUF_CURRENT(output);

  va_list argptr;
  va_start(argptr, fmt);
  scdcint_t n = vsnprintf(buf, buf_size, fmt, argptr);
  va_end(argptr);

  n = min(buf_size, n);

  SCDC_DATASET_INOUT_BUF_CURRENT(output) += n;
  output->total_size += n;

  output->total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_EXACT;

  output->next = 0;
  output->data = 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2aac9
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rsi, %rsi
je 0x2ab45
movl %edi, %esi
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2ab45
movups 0x40568(%rip), %xmm0    # 0x6b048
movups %xmm0, (%rbx)
testl %esi, %esi
jne 0x2aaee
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rax
addq %rax, %rdi
subq %rax, %r14
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
movq %r14, %rsi
callq 0xb300
cltq
cmpq %rax, %r14
cmovgeq %rax, %r14
addq %r14, 0x20(%rbx)
addq %r14, 0x28(%rbx)
movb $0x78, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: inout_FX_data_t<int>::get_size_left()
scdcint_t inout_FX_data_t<int>::get_size_left()
{
  scdcint_t pos = lseek(fx, 0, SEEK_CUR);

  if (pos < 0) return -1;

  scdcint_t size = lseek(fx, 0, SEEK_END);

  if (size < 0) return -1;

  size -= pos;

  lseek(fx, pos, SEEK_SET);

  return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0xba50
movq $-0x1, %r15
testq %rax, %rax
js 0x2b166
movq %rax, %r14
movl (%rbx), %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0xba50
testq %rax, %rax
js 0x2b166
movq %rax, %r12
subq %r14, %r12
movl (%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xba50
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: inout_FX_data_t<_IO_FILE*>::get_size_left()
scdcint_t inout_FX_data_t<FILE *>::get_size_left()
{
  scdcint_t pos = ftello(fx);

  if (pos < 0 || fseeko(fx, 0, SEEK_END) < 0) return -1;

  scdcint_t size = ftello(fx);

  if (size < 0) return -1;

  size -= pos;

  fseeko(fx, pos, SEEK_SET);

  return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xb680
movq $-0x1, %r14
testq %rax, %rax
js 0x2b248
movq %rax, %r15
movq (%rbx), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xb2e0
testl %eax, %eax
js 0x2b248
movq (%rbx), %rdi
callq 0xb680
testq %rax, %rax
js 0x2b248
movq %rax, %r12
subq %r15, %r12
movq (%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xb2e0
movq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_buffer_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_input_t *scdc_dataset_input_buffer_create(scdc_dataset_input_t *input, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  scdc_args_buf_t buffer;
  xargs.get<scdc_args_buf_t>(SCDC_ARGS_TYPE_BUF, &buffer);

  if (!scdc_dataset_inout_alloc(input, 0, 0)) return 0;

  input->intern->type = SCDC_DATASET_INOUT_TYPE_BUFFER;
  input->intern->destroy = scdc_dataset_input_buffer_destroy;

  SCDC_DATASET_INOUT_BUF_PTR(input) = buffer.buf;
  SCDC_DATASET_INOUT_BUF_SIZE(input) = buffer.buf_size;

  strcpy(input->format, "data");

  SCDC_DATASET_INOUT_BUF_CURRENT(input) = SCDC_DATASET_INOUT_BUF_SIZE(input);
  input->total_size = SCDC_DATASET_INOUT_BUF_SIZE(input);
  input->total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_EXACT;

  return input;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2b759
movq 0x10(%rsp), %rdi
movq %rsp, %rdx
movl $0x8, %esi
callq *%rax
testq %rbx, %rbx
je 0x2b7c4
cmpq $0x0, 0x48(%rbx)
jne 0x2b784
movl $0x28, %edi
movl $0x1, %esi
callq 0xb320
testq %rax, %rax
je 0x2b7c4
movq %rax, 0x48(%rbx)
movq $0x28, (%rax)
movq 0x48(%rbx), %rax
movq $0x3, 0x8(%rax)
leaq 0x2f14(%rip), %rcx      # 0x2e6ab
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rbx)
movl $0x61746164, (%rbx)     # imm = 0x61746164
movb $0x0, 0x4(%rbx)
movq %rax, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movb $0x78, 0x30(%rbx)
jmp 0x2b7c6
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_fd_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_inout_t *scdc_dataset_input_fd_create(scdc_dataset_input_t *input, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  int fd;
  xargs.get<int>(SCDC_ARGS_TYPE_INT, &fd);

  if (!input) return 0;

  input = scdc_dataset_input_FX_create<int>(input, conf, args, fd);

  if (!input) return 0;

  input->intern->type = SCDC_DATASET_INOUT_TYPE_FD;
  input->intern->destroy = scdc_dataset_input_fd_destroy;

#if INPUT_CREATE_NEXT
  input->next(input, 0);
#endif

  return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2b83d
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
callq *%rax
testq %r15, %r15
je 0x2b87d
movl 0xc(%rsp), %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2e6ce
movq %rax, %rbx
testq %rax, %rax
je 0x2b87d
movq 0x48(%rbx), %rax
movq $0x4, 0x8(%rax)
leaq 0x36e6(%rip), %rcx      # 0x2ef55
movq %rcx, 0x20(%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq *0x38(%rbx)
jmp 0x2b87f
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_fddup_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_inout_t *scdc_dataset_input_fddup_create(scdc_dataset_input_t *input, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  int fd;
  xargs.get<int>(SCDC_ARGS_TYPE_INT, &fd);

  if (!input) return 0;

  int fddup = dup(fd);

  input = scdc_dataset_input_FX_create<int>(input, conf, args, fddup);

  if (!input) return 0;

  input->intern->type = SCDC_DATASET_INOUT_TYPE_FDDUP;
  input->intern->destroy = scdc_dataset_input_fddup_destroy;

#if INPUT_CREATE_NEXT
  input->next(input, 0);
#endif

  return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2b8fa
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
callq *%rax
testq %r15, %r15
je 0x2b941
movl 0xc(%rsp), %edi
callq 0xb830
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x2e6ce
movq %rax, %rbx
testq %rax, %rax
je 0x2b941
movq 0x48(%rbx), %rax
movq $0x5, 0x8(%rax)
leaq 0x36d1(%rip), %rcx      # 0x2f004
movq %rcx, 0x20(%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq *0x38(%rbx)
jmp 0x2b943
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2b95c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_stream_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_inout_t *scdc_dataset_input_stream_create(scdc_dataset_input_t *input, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  FILE *stream = 0;
  xargs.get<FILE *>(SCDC_ARGS_TYPE_IN_STREAM, &stream);

  if (!stream) stream = stdin;

  if (!input) return 0;

  input = scdc_dataset_input_FX_create<FILE *>(input, conf, args, stream);

  if (!input) return 0;

  input->intern->type = SCDC_DATASET_INOUT_TYPE_STREAM;
  input->intern->destroy = scdc_dataset_input_stream_destroy;

#if INPUT_CREATE_NEXT
  input->next(input, 0);
#endif

  return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq %rcx, 0x8(%rsp)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2b9c3
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x6, %esi
callq *%rax
cmpq $0x0, 0x8(%rsp)
jne 0x2b9da
movq 0x605fe(%rip), %rax     # 0x8bfd0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x2ba1b
movq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f03b
movq %rax, %rbx
testq %rax, %rax
je 0x2ba1b
movq 0x48(%rbx), %rax
movq $0x6, 0x8(%rax)
leaq 0x3eb4(%rip), %rcx      # 0x2f8c1
movq %rcx, 0x20(%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq *0x38(%rbx)
jmp 0x2ba1d
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_streamdup_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_inout_t *scdc_dataset_input_streamdup_create(scdc_dataset_input_t *input, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  FILE *stream = 0;
  xargs.get<FILE *>(SCDC_ARGS_TYPE_IN_STREAM, &stream);

  if (!stream) stream = stdin;

  if (!input) return 0;

  scdcint_t pos = ftello(stream);

  /* we use a duplicated fd, because using only a newly opened stream (with fdopen) leads to empty reads if the original stream is closed */
  int fddup = dup(fileno(stream));
  stream = fdopen(fddup, "r");

  if (!stream) return 0;

  if (pos >= 0) fseeko(stream, pos, SEEK_SET);

  input = scdc_dataset_input_FX_create<FILE *>(input, conf, args, stream);

  if (!input) return 0;

  input->intern->type = SCDC_DATASET_INOUT_TYPE_STREAMDUP;
  input->intern->destroy = scdc_dataset_input_streamdup_destroy;

#if INPUT_CREATE_NEXT
  input->next(input, 0);
#endif

  return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq %rcx, 0x8(%rsp)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2ba9d
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x6, %esi
callq *%rax
cmpq $0x0, 0x8(%rsp)
jne 0x2bab4
movq 0x60524(%rip), %rax     # 0x8bfd0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x2bb41
movq 0x8(%rsp), %rdi
callq 0xb680
movq %rax, %r12
movq 0x8(%rsp), %rdi
callq 0xb560
movl %eax, %edi
callq 0xb830
leaq 0x3dd25(%rip), %rsi     # 0x69807
movl %eax, %edi
callq 0xb570
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x2bb41
testq %r12, %r12
js 0x2bb05
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xb2e0
movq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2f03b
movq %rax, %rbx
testq %rax, %rax
je 0x2bb41
movq 0x48(%rbx), %rax
movq $0x7, 0x8(%rax)
leaq 0x3e3b(%rip), %rcx      # 0x2f96e
movq %rcx, 0x20(%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq *0x38(%rbx)
jmp 0x2bb43
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2bb5e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_create
scdc_dataset_input_t *scdc_dataset_input_create(scdc_dataset_input_t *input, const char *conf, ...)
{
  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  input = scdc_dataset_input_create_intern(input, conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

  return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2c8df
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %r12
movq %rsi, 0x10(%r12)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%r12)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r12)
movl $0x10, %edi
callq 0xb500
movq %rax, %r15
movq $0x0, (%rax)
movq %r12, 0x8(%rax)
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x3666(%rip), %rax      # 0x2ff8f
movq %rax, 0x8(%rdx)
leaq 0x378c(%rip), %rax      # 0x300c0
movq %rax, 0x10(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b257
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0xb510
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_destroy
void scdc_dataset_input_destroy(scdc_dataset_input_t *input)
{
  SCDC_TRACE_DATASET_INPUT(input, "scdc_dataset_input_destroy: input: ");

  if (!input)
  {
    SCDC_FAIL("scdc_dataset_input_destroy: no input given");
    return;
  }

  if (!input->intern) return;

  INOUT_INTERN_RESTORE(input);

  if (input->intern->destroy) input->intern->destroy(input);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2c9a1
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x2ca3c
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq 0x18(%rax), %rcx
movq %rcx, 0x40(%rdi)
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2ca3c
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x5fbc8(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2ca3c
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0x3d7bb(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x3e6c4(%rip), %rsi     # 0x6b0a5
movl $0xf, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x3e6d5(%rip), %rsi     # 0x6b0ca
movl $0x2a, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb3b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_buffer_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_output_t *scdc_dataset_output_buffer_create(scdc_dataset_output_t *output, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  scdc_args_buf_t v;
  xargs.get<scdc_args_buf_t>(SCDC_ARGS_TYPE_BUF, &v);

  if (!scdc_dataset_inout_alloc(output, 0, 0)) return 0;

  output->intern->type = SCDC_DATASET_INOUT_TYPE_BUFFER;
  output->intern->destroy = scdc_dataset_output_buffer_destroy;

  SCDC_DATASET_INOUT_BUF_PTR(output) = v.buf;
  SCDC_DATASET_INOUT_BUF_SIZE(output) = v.buf_size;

  strcpy(output->format, "data");

  return output;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2d028
movq 0x10(%rsp), %rdi
movq %rsp, %rdx
movl $0x8, %esi
callq *%rax
testq %rbx, %rbx
je 0x2d087
cmpq $0x0, 0x48(%rbx)
jne 0x2d053
movl $0x28, %edi
movl $0x1, %esi
callq 0xb320
testq %rax, %rax
je 0x2d087
movq %rax, 0x48(%rbx)
movq $0x28, (%rax)
movq 0x48(%rbx), %rax
movq $0x3, 0x8(%rax)
leaq 0x3080(%rip), %rcx      # 0x300e6
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rbx)
movl $0x61746164, (%rbx)     # imm = 0x61746164
movb $0x0, 0x4(%rbx)
jmp 0x2d089
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_fd_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_output_t *scdc_dataset_output_fd_create(scdc_dataset_output_t *output, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  int fd;
  xargs.get<int>(SCDC_ARGS_TYPE_INT, &fd);

  if (!output) return 0;

  output = scdc_dataset_output_FX_create<int>(output, conf, args, fd);

  if (!output) return 0;

  output->intern->type = SCDC_DATASET_INOUT_TYPE_STREAM;
  output->intern->destroy = scdc_dataset_output_fd_destroy;

  return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2d100
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
callq *%rax
testq %r15, %r15
je 0x2d138
movl 0xc(%rsp), %ecx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30109
movq %rax, %rbx
testq %rax, %rax
je 0x2d138
movq 0x48(%rbx), %rax
movq $0x6, 0x8(%rax)
leaq 0x390d(%rip), %rcx      # 0x30a3f
movq %rcx, 0x20(%rax)
jmp 0x2d13a
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_fddup_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_output_t *scdc_dataset_output_fddup_create(scdc_dataset_output_t *output, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  int fd;
  xargs.get<int>(SCDC_ARGS_TYPE_INT, &fd);

  if (!output) return 0;

  int fddup = dup(fd);

  output = scdc_dataset_output_FX_create<int>(output, conf, args, fddup);

  if (!output) return 0;

  output->intern->type = SCDC_DATASET_INOUT_TYPE_STREAM;
  output->intern->destroy = scdc_dataset_output_fddup_destroy;

  return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2d1b5
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movl $0x1, %esi
callq *%rax
testq %r15, %r15
je 0x2d1f4
movl 0xc(%rsp), %edi
callq 0xb830
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %eax, %ecx
callq 0x30109
movq %rax, %rbx
testq %rax, %rax
je 0x2d1f4
movq 0x48(%rbx), %rax
movq $0x6, 0x8(%rax)
leaq 0x38d8(%rip), %rcx      # 0x30ac6
movq %rcx, 0x20(%rax)
jmp 0x2d1f6
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2d20f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_stream_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_output_t *scdc_dataset_output_stream_create(scdc_dataset_output_t *output, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  FILE *stream = 0;
  xargs.get<FILE *>(SCDC_ARGS_TYPE_OUT_STREAM, &stream);

  if (!stream) stream = stdout;

  if (!output) return 0;

  output = scdc_dataset_output_FX_create<FILE *>(output, conf, args, stream);

  if (!output) return 0;

  output->intern->type = SCDC_DATASET_INOUT_TYPE_STREAM;
  output->intern->destroy = scdc_dataset_output_stream_destroy;

  return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq %rcx, 0x8(%rsp)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2d276
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x7, %esi
callq *%rax
cmpq $0x0, 0x8(%rsp)
jne 0x2d28d
movq 0x5ed1b(%rip), %rax     # 0x8bfa0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x2d2c6
movq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30afd
movq %rax, %rbx
testq %rax, %rax
je 0x2d2c6
movq 0x48(%rbx), %rax
movq $0x6, 0x8(%rax)
leaq 0x417a(%rip), %rcx      # 0x3143a
movq %rcx, 0x20(%rax)
jmp 0x2d2c8
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0