LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::file_read_at(void*, void*, void*, long long, long long)
scdcint_t scdc_dataprov_access_stub_handler::file_read_at(dir_t dir, file_t file, void *ptr, scdcint_t size, scdcint_t pos)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "', file: '" << file << "', ptr: " << ptr << ", size: " << size << ", pos: " << pos);

  scdcint_t ret = 0;

  SCDC_TRACE(__func__ << ": 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 0x63bfe
movq $0x0, -0x38(%rbp)
jmp 0x63c08
movq -0x38(%rbp), %rax
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::file_write_at(void*, void*, void const*, long long, long long)
scdcint_t scdc_dataprov_access_stub_handler::file_write_at(dir_t dir, file_t file, const void *ptr, scdcint_t size, scdcint_t pos)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "', file: '" << file << "', ptr: " << ptr << ", size: " << size << ", pos: " << pos);

  scdcint_t ret = max(scdcint_const(0), size);

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

  return ret;
}

// 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 0x63c32
movq $0x0, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x41f50
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x63c50
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_bench.cc
// Function: scdc_dataprov_bench::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_bench::close(scdc_result &result)
{
  SCDC_TRACE("close:");

  bool ret = scdc_dataprov::close(result);

  SCDC_TRACE("close: 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 0x6424a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5e090
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x6425e
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_bench.cc
// Function: scdc_dataprov_bench::dataset_open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
scdc_dataset *scdc_dataprov_bench::dataset_open(std::string &path, scdc_result &result)
{
  SCDC_TRACE("dataset_open: path: '" << path << "'");

  scdc_dataset_bench *dataset_bench = new scdc_dataset_bench(this);

  SCDC_TRACE("dataset_open: return: '" << dataset_bench << "'");

  return dataset_bench;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x6428e
movl $0x98, %edi
callq 0xc690
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x64cf0
jmp 0x642ad
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x642b7
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x98, %esi
callq 0xc6a0
movq -0x28(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataprov_fs2::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_fs2::close(scdc_result &result)
{
  SCDC_TRACE("close:");

  bool ret = scdc_dataprov::close(result);

  SCDC_TRACE("close: 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 0x7109a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5e090
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x710ae
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataprov_fs2::make_pwd_path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_fs2::make_pwd_path(const std::string &pwd, const std::string &sub, std::string &pwd_path)
{
  std::string p;

  if (!sub.empty())
  {
    if (sub[0] != '/') p = pwd + "/";
    p += sub;

  } else p = pwd;

  normalize_path(p.c_str(), pwd_path);

  if (!pwd_path.empty() && pwd_path[0] == '/') pwd_path = pwd_path.erase(0, 1);

  return (pwd_path.compare("..") != 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc960
movq -0x18(%rbp), %rdi
callq 0xcb60
testb $0x1, %al
jne 0x7155f
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc760
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x7154e
movq -0x10(%rbp), %rsi
leaq 0x34e5c(%rip), %rdx     # 0xa636d
leaq -0x60(%rbp), %rdi
callq 0x31740
jmp 0x7151c
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xc850
leaq -0x60(%rbp), %rdi
callq 0xc3e0
jmp 0x7154e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc3e0
jmp 0x71612
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xc8a0
jmp 0x7155d
jmp 0x71570
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xc070
jmp 0x7156e
jmp 0x71570
leaq -0x40(%rbp), %rdi
callq 0xc260
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x2ac20
jmp 0x71587
movq -0x20(%rbp), %rdi
callq 0xcb60
testb $0x1, %al
jne 0x715dc
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcd00
movq %rax, -0x78(%rbp)
jmp 0x715a7
movq -0x78(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x715dc
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0xc110
movq %rax, -0x80(%rbp)
jmp 0x715cb
movq -0x80(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc070
jmp 0x715da
jmp 0x715dc
movq -0x20(%rbp), %rdi
leaq 0x34d88(%rip), %rsi     # 0xa636f
callq 0xc170
cmpl $0x0, %eax
setne %al
movb %al, -0x81(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc3e0
movb -0x81(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xcba0
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataprov_fs2::undo_full_path(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_fs2::undo_full_path(const char *full_path, std::string &path)
{
  string norm_full_path;

  normalize_path(full_path, norm_full_path);

  norm_full_path += "/";

  if (strncmp(norm_full_path.c_str(), root.c_str(), root.size()) != 0) return false;

  path = norm_full_path.c_str() + root.size();

  /* remove trailing '/' */
  while (path.size() > 1 && *(path.end() - 1) == '/') path.erase(path.size() - 1, 1);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xc960
movq -0x68(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x2ac20
jmp 0x717db
leaq 0x34b8b(%rip), %rsi     # 0xa636d
leaq -0x40(%rbp), %rdi
callq 0xc630
jmp 0x717ed
leaq -0x40(%rbp), %rdi
callq 0xc260
movq -0x70(%rbp), %rdi
movq %rax, -0x80(%rbp)
addq $0x68, %rdi
callq 0xc260
movq -0x70(%rbp), %rdi
movq %rax, -0x78(%rbp)
addq $0x68, %rdi
callq 0xc460
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq %rax, %rdx
callq 0xc2d0
cmpl $0x0, %eax
je 0x71857
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x71921
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc3e0
jmp 0x71938
leaq -0x40(%rbp), %rdi
callq 0xc260
movq -0x70(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0x68, %rdi
callq 0xc460
movq -0x88(%rbp), %rsi
addq %rax, %rsi
movq -0x20(%rbp), %rdi
callq 0xc920
jmp 0x71889
jmp 0x7188b
movq -0x20(%rbp), %rdi
callq 0xc460
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, -0x89(%rbp)
jbe 0x718dc
movq -0x20(%rbp), %rdi
callq 0xc3a0
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
movl $0x1, %esi
callq 0x72a60
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x72aa0
movsbl (%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x718e8
jmp 0x71916
movq -0x20(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xc460
movq -0x98(%rbp), %rdi
movq %rax, %rsi
decq %rsi
movl $0x1, %edx
callq 0xc110
jmp 0x71911
jmp 0x7188b
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc3e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: dir_count_stores(__dirstream*)
static scdcint_t dir_count_stores(DIR *dir)
{
  struct dirent *ent;
  scdcint_t c = 0;

  while ((ent = readdir(dir)) != NULL)
  {
    if (ent->d_type == DT_DIR && has_prefix(ent->d_name, DIR_STORE_PREFIX)) ++c;
  }

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xca60
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x7280c
movq -0x10(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x4, %eax
jne 0x7280a
movq -0x10(%rbp), %rdi
addq $0x13, %rdi
leaq 0x35e1c(%rip), %rsi     # 0xa860f
callq 0x29fe0
testb $0x1, %al
jne 0x727fe
jmp 0x7280a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x727c4
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: dir_count_entries(__dirstream*)
static scdcint_t dir_count_entries(DIR *dir)
{
  struct dirent *ent;
  scdcint_t c = 0;

  while ((ent = readdir(dir)) != NULL)
  {
    if (ent->d_type == DT_REG && has_prefix_suffix(ent->d_name, DIR_ENTRY_PREFIX, DIR_ENTRY_SUFFIX)) ++c;
  }

  return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xca60
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x72883
movq -0x10(%rbp), %rax
movzbl 0x12(%rax), %eax
cmpl $0x8, %eax
jne 0x72881
movq -0x10(%rbp), %rdi
addq $0x13, %rdi
leaq 0x35dba(%rip), %rsi     # 0xa861d
leaq 0x33d3a(%rip), %rdx     # 0xa65a4
callq 0x29f10
testb $0x1, %al
jne 0x72875
jmp 0x72881
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x72834
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/../include/common.hh
// Function: trim_prefix_suffix[abi:cxx11](char const*, char const*, char const*)
static inline std::string trim_prefix_suffix(const char *s, const char *prefix, const char *suffix)
{
  std::string str(s);
  size_t prefix_len = (prefix)?strlen(prefix):0;
  size_t suffix_len = (suffix)?strlen(suffix):0;
  return str.substr(prefix_len, str.size() - prefix_len - suffix_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xcbc0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x27820
jmp 0x728e1
leaq -0x41(%rbp), %rdi
callq 0xc730
cmpq $0x0, -0x18(%rbp)
je 0x72903
movq -0x18(%rbp), %rdi
callq 0xc280
movq %rax, -0x90(%rbp)
jmp 0x7290e
xorl %eax, %eax
movq %rax, -0x90(%rbp)
jmp 0x7290e
movq -0x90(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x72932
movq -0x20(%rbp), %rdi
callq 0xc280
movq %rax, -0x98(%rbp)
jmp 0x7293d
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0x7293d
movq -0x98(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xc460
movq -0x88(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq %rax, %rcx
movq -0x60(%rbp), %rax
subq %rax, %rcx
movq -0x68(%rbp), %rax
subq %rax, %rcx
callq 0xc6b0
jmp 0x72990
leaq -0x40(%rbp), %rdi
callq 0xc3e0
movq -0x80(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0xc730
jmp 0x729d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc3e0
movq -0x50(%rbp), %rdi
callq 0xcba0
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataset* scdc_dataprov_fs2::dataset_open<scdc_dataset_fs2_access>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
scdc_dataset *scdc_dataprov_fs2::dataset_open(std::string &path, scdc_result &result)
{
  SCDC_TRACE("dataset_open: path: '" << path << "'");

  DATASET_FS *dataset_fs2 = new DATASET_FS(this);

  SCDC_TRACE("dataset_open: return: '" << dataset_fs2 << "'");

  return dataset_fs2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x74eae
movl $0x70, %edi
callq 0xc690
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x77790
jmp 0x74ecd
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x74ed7
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x70, %esi
callq 0xc6a0
movq -0x28(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataset_fs2::close_pwd_file()
void close_pwd_file()
    {
      if (pwd_FILE) fclose(pwd_FILE);

      pwd_FILE = 0;
      pwd_FILE_path.clear();
      pwd_FILE_mode = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x40(%rax)
je 0x77748
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0xc680
movq -0x10(%rbp), %rdi
movq $0x0, 0x40(%rdi)
addq $0x48, %rdi
callq 0xc8f0
movq -0x10(%rbp), %rax
movl $0x0, 0x68(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataset_fs2::do_cmd_cd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool do_cmd_cd(const string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      SCDC_TRACE("do_cmd_cd: params: '" << params << "'");

#if SCDC_DATASET_FS_LEAVE_PWD_OPEN
      close_pwd_file();
#endif

      bool ret = scdc_dataset::do_cmd_cd(params, input, output, result);

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

      return ret;
    }

// 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 -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x77e66
movq -0x38(%rbp), %rdi
callq 0x77720
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x42870
andb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x77e8f
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_hook.cc
// Function: scdc_dataprov_hook::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_hook::close(scdc_result &result)
{
  SCDC_TRACE("close:");

  bool ret = true;

  if (hook_arg.hook.close)
  {
    if (hook_arg.hook.close(dataprov) != SCDC_SUCCESS)
    {
      SCDC_FAIL("close: closing data provider with hook");
      ret = false;
    }
  }

  open_args_release();

  ret = scdc_dataprov::close(result);

  SCDC_TRACE("close: 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 0x78a1a
movq -0x20(%rbp), %rax
movb $0x1, -0x11(%rbp)
cmpq $0x0, 0x70(%rax)
je 0x78ad0
movq -0x20(%rbp), %rcx
movq 0x70(%rcx), %rax
movq 0xb8(%rcx), %rdi
callq *%rax
cmpq $0x1, %rax
je 0x78ace
jmp 0x78a4a
leaq 0x5bc57(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x78ac8
leaq 0x5bc42(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x5bc33(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x2d729(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x2fdfc(%rip), %rsi     # 0xa8892
callq 0xc670
movq %rax, %rdi
leaq 0x2fe49(%rip), %rsi     # 0xa88ee
callq 0xc670
movq %rax, %rdi
movq 0x5b50c(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x5bbe8(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x78aca
movb $0x0, -0x11(%rbp)
jmp 0x78ad0
movq -0x20(%rbp), %rdi
callq 0x3abc0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5e090
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x78aed
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_hook.cc
// Function: scdc_dataprov_hook::dataset_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_hook::dataset_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE("dataset_close: dataset: " << dataset);

  bool ret = false;

  scdc_dataset_hook *dataset_hook = static_cast<scdc_dataset_hook *>(dataset);

  if (hook_arg.hook.dataset_close)
  {
    scdc_result_t res = SCDC_RESULT_INIT_EMPTY;
    scdcint_t r = hook_arg.hook.dataset_close(dataprov, dataset_hook->dataset, &res);
    result = SCDC_RESULT_STR(&res);

    if (r != SCDC_SUCCESS)
    {
      SCDC_FAIL(__func__ << ": closing dataset with hook failed: " << result);
      goto do_return;
    }
  }

  delete dataset_hook;
  ret = true;

do_return:
  SCDC_TRACE("dataset_close: return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
jmp 0x78d24
movq -0x240(%rbp), %rax
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
cmpq $0x0, 0x88(%rax)
je 0x78e57
leaq -0x230(%rbp), %rdi
xorl %esi, %esi
movl $0x208, %edx            # imm = 0x208
callq 0xc350
movq -0x240(%rbp), %rcx
movq $0x200, -0x230(%rbp) # imm = 0x200
movq 0x88(%rcx), %rax
movq 0xb8(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq 0x38(%rcx), %rsi
leaq -0x230(%rbp), %rdx
callq *%rax
movq %rax, -0x238(%rbp)
leaq -0x230(%rbp), %rsi
addq $0x8, %rsi
movq -0x18(%rbp), %rdi
callq 0xc920
cmpq $0x1, -0x238(%rbp)
je 0x78e55
jmp 0x78db4
leaq 0x5b8ed(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x78e51
leaq 0x5b8d4(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x5b8c5(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x2d3bb(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x2fa8e(%rip), %rsi     # 0xa8892
callq 0xc670
movq %rax, %rdi
leaq 0x2d3d1(%rip), %rsi     # 0xa61e4
callq 0xc670
movq %rax, %rdi
leaq 0x2fb18(%rip), %rsi     # 0xa893a
callq 0xc670
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc5b0
movq %rax, %rdi
movq 0x5b183(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x5b85f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x78e53
jmp 0x78e79
jmp 0x78e57
movq -0x28(%rbp), %rax
movq %rax, -0x248(%rbp)
cmpq $0x0, %rax
je 0x78e75
movq -0x248(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, -0x19(%rbp)
jmp 0x78e7b
jmp 0x78e7d
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_hook.cc
// Function: scdc_dataprov_hook::dataset_cmds_do_cmd(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_hook::dataset_cmds_do_cmd(scdc_dataset *dataset, const std::string &cmd, const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
{
  SCDC_TRACE("dataset_cmds_do_cmd: cmd: '" << cmd << "', params: '" << params << "'");

  scdc_dataset_hook *dataset_hook = static_cast<scdc_dataset_hook *>(dataset);

  bool ret = dataset_hook->do_cmd(cmd, params, input, output, result);

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
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 0x79a56
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq 0x10(%rbp), %r9
callq 0x79bd0
andb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x79a82
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_hook.cc
// Function: scdc_dataset_hook::do_cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool do_cmd(const string &cmd, const string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      SCDC_TRACE("dataset_hook: do_cmd: cmd: '" << cmd << "'");

      scdc_dataprov_hook *dataprov_hook = static_cast<scdc_dataprov_hook *>(dataprov);

      scdc_result_t res = SCDC_RESULT_INIT_EMPTY;
      scdcint_t ret = dataprov_hook->hook_arg.hook.dataset_cmd(dataprov_hook->dataprov, dataset, cmd.c_str(), params.c_str(), input, output, &res);
      result = SCDC_RESULT_STR(&res);

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

      return (ret == SCDC_SUCCESS);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
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, -0x250(%rbp)
jmp 0x79c00
movq -0x250(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x240(%rbp), %rdi
xorl %esi, %esi
movl $0x208, %edx            # imm = 0x208
callq 0xc350
movq -0x250(%rbp), %rax
movq $0x200, -0x240(%rbp) # imm = 0x200
movq -0x38(%rbp), %rcx
movq 0xa0(%rcx), %rcx
movq %rcx, -0x258(%rbp)
movq -0x38(%rbp), %rcx
movq 0xb8(%rcx), %rcx
movq %rcx, -0x270(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x268(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc260
movq %rax, -0x260(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc260
movq -0x270(%rbp), %rdi
movq -0x268(%rbp), %rsi
movq -0x260(%rbp), %rdx
movq %rax, %rcx
movq -0x258(%rbp), %rax
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
leaq -0x240(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
movq %rax, -0x248(%rbp)
leaq -0x240(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdi
callq 0xc920
jmp 0x79ccd
cmpq $0x1, -0x248(%rbp)
sete %al
andb $0x1, %al
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::add_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_dataprov_jobrun_node_t&)
bool scdc_dataprov_jobrun::add_node(const std::string &nodeid, scdc_dataprov_jobrun_node_t &node)
{
  SCDC_TRACE(__func__ << ": nodeid: '" << nodeid << "', cores: " << node.cores << ", max_parallel_jobs: " << node.max_parallel_jobs << ", performance: " << node.performance);

  pair<nodes_t::iterator, bool> r = nodes.insert(nodes_t::value_type(nodeid, node));

  if (!r.second)
  {
    SCDC_FAIL("add_node: adding node failed");
    return false;
  }

  total_cores += node.cores;
  max_parallel_jobs += node.max_parallel_jobs;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x7a114
movq -0x90(%rbp), %rax
addq $0x88, %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x83820
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x837e0
movb %dl, -0x99(%rbp)
movq %rax, -0x98(%rbp)
jmp 0x7a162
movb -0x99(%rbp), %al
movq -0x98(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movb %al, -0x80(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x30(%rbp)
movb -0x80(%rbp), %al
movb %al, -0x28(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x83870
testb $0x1, -0x28(%rbp)
jne 0x7a242
jmp 0x7a19f
leaq 0x5a502(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x7a23a
leaq 0x5a4e9(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x5a4da(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x2bfd0(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x2e875(%rip), %rsi     # 0xa8a64
callq 0xc670
movq %rax, %rdi
leaq 0x2ea37(%rip), %rsi     # 0xa8c35
callq 0xc670
movq %rax, %rdi
movq 0x59db3(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x5a48f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x7a23a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x83870
jmp 0x7a286
jmp 0x7a23c
movb $0x0, -0x1(%rbp)
jmp 0x7a278
movq -0x90(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
addq 0xb8(%rax), %rcx
movq %rcx, 0xb8(%rax)
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq 0xc0(%rax), %rcx
movq %rcx, 0xc0(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xcba0
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::del_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_jobrun::del_node(const std::string &nodeid)
{
  SCDC_TRACE(__func__ << ": nodeid: '" << nodeid << "'");

  nodes_t::iterator i = nodes.find(nodeid);

  scdc_dataprov_jobrun_node_t node;

  if (i != nodes.end()) node = i->second;
  else node.cores = node.max_parallel_jobs = 0;

  scdcint_t r = nodes.erase(nodeid);

  if (r <= 0)
  {
    SCDC_FAIL("del_node: deleting node failed");
    return false;
  }

  total_cores -= node.cores;
  max_parallel_jobs -= node.max_parallel_jobs;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x7a49a
movq -0x50(%rbp), %rdi
addq $0x88, %rdi
movq -0x18(%rbp), %rsi
callq 0x83890
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x838c0
movq -0x50(%rbp), %rdi
addq $0x88, %rdi
callq 0x83900
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x838d0
testb $0x1, %al
jne 0x7a4e2
jmp 0x7a505
leaq -0x20(%rbp), %rdi
callq 0x83930
movq 0x20(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x28(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x7a515
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x50(%rbp), %rdi
addq $0x88, %rdi
movq -0x18(%rbp), %rsi
callq 0x83950
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jg 0x7a5c0
jmp 0x7a53a
leaq 0x5a167(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x7a5b8
leaq 0x5a152(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x5a143(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x2bc39(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x2e4de(%rip), %rsi     # 0xa8a64
callq 0xc670
movq %rax, %rdi
leaq 0x2e6bd(%rip), %rsi     # 0xa8c52
callq 0xc670
movq %rax, %rdi
movq 0x59a1c(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x5a0f8(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x7a5ba
movb $0x0, -0x1(%rbp)
jmp 0x7a5f2
movq -0x50(%rbp), %rax
movq -0x38(%rbp), %rdx
movq 0xb8(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xb8(%rax)
movq -0x30(%rbp), %rdx
movq 0xc0(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0xc0(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::sched_init()
void scdc_dataprov_jobrun::sched_init()
{
  SCDC_TRACE(__func__ << ":");

  sched = new scdc_dataprov_jobrun_sched();
  sched->dataprov_jobrun = this;

  sched_run = true;

  pthread_mutex_init(&sched_lock, NULL);
  pthread_cond_init(&sched_cond, NULL);
  pthread_cond_init(&sched_cond_finished, NULL);

  pthread_create(&sched_run_thread, NULL, sched_run_routine, this);

  SCDC_TRACE(__func__ << ": return");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x7ac06
movl $0x40, %edi
callq 0xc690
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x84350
jmp 0x7ac21
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, 0x180(%rdi)
movq 0x180(%rdi), %rax
movq %rdi, 0x30(%rax)
movb $0x1, 0x188(%rdi)
addq $0x190, %rdi            # imm = 0x190
xorl %eax, %eax
movl %eax, %esi
callq 0xca00
movq -0x20(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
xorl %eax, %eax
movl %eax, %esi
callq 0xc840
movq -0x20(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
xorl %eax, %eax
movl %eax, %esi
callq 0xc840
movq -0x20(%rbp), %rcx
movq %rcx, %rdi
addq $0x220, %rdi            # imm = 0x220
xorl %eax, %eax
movl %eax, %esi
leaq 0x377d(%rip), %rdx      # 0x7e410
callq 0xcc20
jmp 0x7ac9a
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x40, %esi
callq 0xc6a0
movq -0x10(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_jobrun::close(scdc_result &result)
{
  SCDC_TRACE(__func__ << ":");

  bool ret = true;

  sched_release();

#if SCDC_LOCK
  pthread_mutex_destroy(&libscdc_lock);
#endif

  ret = scdc_dataprov::close(result);

  SCDC_TRACE(__func__ << ": 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 0x7acea
movq -0x20(%rbp), %rdi
movb $0x1, -0x11(%rbp)
callq 0x7ad20
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5e090
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x7ad0b
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_jobrun.cc
// Function: scdc_dataprov_jobrun::sched_release()
void scdc_dataprov_jobrun::sched_release()
{
  SCDC_TRACE(__func__ << ":");

  pthread_mutex_lock(&sched_lock);
  sched_run = false;
  pthread_mutex_unlock(&sched_lock);

#if SCHED_RUN_THREAD_CANCEL
  pthread_cancel(sched_thread);
#else
  pthread_cond_signal(&sched_cond);
#endif
  pthread_join(sched_run_thread, NULL);

  pthread_mutex_lock(&sched_lock);
  while (sched_jobs_run.size() > 0)
  {
    pthread_t thread = sched_jobs_run.begin()->second;
    pthread_mutex_unlock(&sched_lock);
    pthread_join(thread, NULL);
    pthread_mutex_lock(&sched_lock);
  }
  pthread_mutex_unlock(&sched_lock);

  pthread_cond_broadcast(&sched_cond_finished);

  pthread_cond_destroy(&sched_cond);
  pthread_cond_destroy(&sched_cond_finished);
  pthread_mutex_destroy(&sched_lock);

  delete sched;

  SCDC_TRACE(__func__ << ": return");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x7ad36
movq -0x20(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0xc9f0
movq -0x20(%rbp), %rdi
movb $0x0, 0x188(%rdi)
addq $0x190, %rdi            # imm = 0x190
callq 0xc4c0
movq -0x20(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
callq 0xc030
movq -0x20(%rbp), %rax
movq 0x220(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc5c0
movq -0x20(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0xc9f0
movq -0x20(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x837c0
cmpq $0x0, %rax
jbe 0x7adfb
movq -0x20(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x84380
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x84330
movq -0x20(%rbp), %rdi
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x190, %rdi            # imm = 0x190
callq 0xc4c0
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc5c0
movq -0x20(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0xc9f0
jmp 0x7ad91
movq -0x20(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0xc4c0
movq -0x20(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0xc1e0
movq -0x20(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
callq 0xcc90
movq -0x20(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0xcc90
movq -0x20(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0xc7f0
movq -0x20(%rbp), %rax
movq 0x180(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x7ae77
movq -0x28(%rbp), %rdi
callq 0x843b0
movq -0x28(%rbp), %rdi
movl $0x40, %esi
callq 0xc6a0
jmp 0x7ae79
jmp 0x7ae7b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::dataset_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_jobrun::dataset_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE(__func__ << ": dataset: " << dataset);

  bool ret = true;

  delete dataset;

  SCDC_TRACE(__func__ << ": 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)
jmp 0x7aea6
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x7aec2
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x7aec4
jmp 0x7aec6
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::get_job_state(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)
bool scdc_dataprov_jobrun::get_job_state(const std::string &jobid, std::string &state, bool sched_locked)
{
  if (!is_job(jobid)) state = "unknown";
  else
  {
    /* waiting | running | done */

    if (!sched_locked) pthread_mutex_lock(&sched_lock);

    if (find(sched_jobs_wait.begin(), sched_jobs_wait.end(), jobid) != sched_jobs_wait.end()) state = "waiting";
    else if (sched_jobs_run.find(jobid) != sched_jobs_run.end()) state = "running";
    else state = "done";

    if (!sched_locked) pthread_mutex_unlock(&sched_lock);
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x7d680
testb $0x1, %al
jne 0x7cc55
movq -0x18(%rbp), %rdi
leaq 0x28df6(%rip), %rsi     # 0xa5a41
callq 0xc920
jmp 0x7cd5c
testb $0x1, -0x19(%rbp)
jne 0x7cc6b
movq -0x58(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0xc9f0
movq -0x58(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0x84190
movq -0x58(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x228, %rdi            # imm = 0x228
callq 0x841c0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x84140
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x228, %rdi            # imm = 0x228
callq 0x841c0
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x84110
testb $0x1, %al
jne 0x7cccf
jmp 0x7cce1
movq -0x18(%rbp), %rdi
leaq 0x2c00d(%rip), %rsi     # 0xa8ce7
callq 0xc920
jmp 0x7cd44
movq -0x58(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq -0x10(%rbp), %rsi
callq 0x84220
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x240, %rdi            # imm = 0x240
callq 0x84250
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x841f0
testb $0x1, %al
jne 0x7cd20
jmp 0x7cd32
movq -0x18(%rbp), %rdi
leaq 0x2cdae(%rip), %rsi     # 0xa9ad9
callq 0xc920
jmp 0x7cd42
movq -0x18(%rbp), %rdi
leaq 0x2bfb2(%rip), %rsi     # 0xa8cef
callq 0xc920
jmp 0x7cd44
testb $0x1, -0x19(%rbp)
jne 0x7cd5a
movq -0x58(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0xc4c0
jmp 0x7cd5c
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::do_cmd_info(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_jobrun::do_cmd_info(const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
{
  stringstream ss;

  pthread_mutex_lock(&sched_lock);
  ss << jobs.size() << ":" << sched_jobs_wait.size() << ":" << sched_jobs_run.size();
  pthread_mutex_unlock(&sched_lock);

  result = ss.str();

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0xc470
movq -0x1f8(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0xc9f0
movq -0x1f8(%rbp), %rdi
leaq -0x1a0(%rbp), %rax
movq %rax, -0x1f0(%rbp)
addq $0x128, %rdi            # imm = 0x128
callq 0x83770
movq -0x1f0(%rbp), %rdi
movq %rax, %rsi
callq 0xc120
movq %rax, -0x1e8(%rbp)
jmp 0x7cdf2
movq -0x1e8(%rbp), %rdi
leaq 0x29564(%rip), %rsi     # 0xa6364
callq 0xc670
movq %rax, -0x200(%rbp)
jmp 0x7ce0e
movq -0x1f8(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0x83790
movq -0x200(%rbp), %rdi
movq %rax, %rsi
callq 0xc120
movq %rax, -0x208(%rbp)
jmp 0x7ce39
movq -0x208(%rbp), %rdi
leaq 0x2951d(%rip), %rsi     # 0xa6364
callq 0xc670
movq %rax, -0x210(%rbp)
jmp 0x7ce55
movq -0x1f8(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x837c0
movq -0x210(%rbp), %rdi
movq %rax, %rsi
callq 0xc120
jmp 0x7ce79
movq -0x1f8(%rbp), %rdi
addq $0x190, %rdi            # imm = 0x190
callq 0xc4c0
leaq -0x1e0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xc650
jmp 0x7cea1
movq -0x28(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xc850
leaq -0x1e0(%rbp), %rdi
callq 0xc3e0
leaq -0x1b0(%rbp), %rdi
callq 0xc4b0
movb $0x1, %al
andb $0x1, %al
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0xc4b0
movq -0x1b8(%rbp), %rdi
callq 0xcba0
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::get_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_dataprov_jobrun_node_t&)
bool scdc_dataprov_jobrun::get_node(const std::string &nodeid, scdc_dataprov_jobrun_node_t &node)
{
  SCDC_TRACE(__func__ << ": nodeid: '" << nodeid << "'");

  nodes_t::iterator i = nodes.find(nodeid);

  if (i == nodes.end())
  {
    SCDC_FAIL("get_node: getting node failed");
    return false;
  }

  node = i->second;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x7cf7e
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
movq -0x18(%rbp), %rsi
callq 0x83890
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x88, %rdi
callq 0x83900
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x83980
testb $0x1, %al
jne 0x7cfc0
jmp 0x7d048
jmp 0x7cfc2
leaq 0x576df(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x7d040
leaq 0x576ca(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x576bb(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x291b1(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x2ba56(%rip), %rsi     # 0xa8a64
callq 0xc670
movq %rax, %rdi
leaq 0x2bc54(%rip), %rsi     # 0xa8c71
callq 0xc670
movq %rax, %rdi
movq 0x56f94(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x57670(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x7d042
movb $0x0, -0x1(%rbp)
jmp 0x7d073
leaq -0x28(%rbp), %rdi
callq 0x83930
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq 0x20(%rcx), %rdx
movq %rdx, (%rax)
movq 0x28(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x30(%rcx), %rcx
movq %rcx, 0x10(%rax)
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_jobrun.cc
// Function: scdc_dataprov_jobrun::set_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long long, long long, double)
bool scdc_dataprov_jobrun::set_node(const std::string &nodeid, scdcint_t cores, scdcint_t max_parallel_jobs, double performance)
{
  SCDC_TRACE(__func__ << ": nodeid: '" << nodeid << "', cores: '" << cores << "', max_parallel_jobs: '" << max_parallel_jobs << "', performance: '" << performance << "'");

  nodes_t::iterator i = nodes.find(nodeid);

  if (i == nodes.end())
  {
    SCDC_FAIL("set_node: setting node failed");
    return false;
  }

  if (cores >= 0) i->second.cores = cores;

  if (max_parallel_jobs >= 0) i->second.max_parallel_jobs = max_parallel_jobs;

  if (performance >= 0) i->second.performance = performance;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x7d0a7
movq -0x48(%rbp), %rdi
addq $0x88, %rdi
movq -0x18(%rbp), %rsi
callq 0x83890
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x88, %rdi
callq 0x83900
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x83980
testb $0x1, %al
jne 0x7d0e9
jmp 0x7d171
jmp 0x7d0eb
leaq 0x575b6(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x7d169
leaq 0x575a1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x57592(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x29088(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x2b92d(%rip), %rsi     # 0xa8a64
callq 0xc670
movq %rax, %rdi
leaq 0x2bb49(%rip), %rsi     # 0xa8c8f
callq 0xc670
movq %rax, %rdi
movq 0x56e6b(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x57547(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x7d16b
movb $0x0, -0x1(%rbp)
jmp 0x7d1e0
cmpq $0x0, -0x20(%rbp)
jl 0x7d191
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x83930
movq -0x50(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x28(%rbp)
jl 0x7d1b1
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x83930
movq -0x58(%rbp), %rcx
movq %rcx, 0x28(%rax)
movsd -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x7d1dc
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x83930
movsd -0x60(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::set_job(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_dataprov_jobrun_job_t&)
bool scdc_dataprov_jobrun::set_job(const std::string &jobid, scdc_dataprov_jobrun_job_t &job)
{
  jobs_t::iterator i = jobs.find(jobid);

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

  i->second = job;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x128, %rdi            # imm = 0x128
movq -0x18(%rbp), %rsi
callq 0x84000
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x128, %rdi            # imm = 0x128
callq 0x836f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x84030
testb $0x1, %al
jne 0x7d737
jmp 0x7d73d
movb $0x0, -0x1(%rbp)
jmp 0x7d762
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x83720
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0x84060
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::set_job_params(scdc_dataprov_jobrun_job_t&, scdc_dataprov_jobrun_job_params_proc_t&)
bool scdc_dataprov_jobrun::set_job_params(scdc_dataprov_jobrun_job_t &job, scdc_dataprov_jobrun_job_params_t &job_params)
{
  job.params = job_params;

  if (job.params.nt_max <= 0) job.params.nt_max = 1;
  if (job.params.nt_min <= 0) job.params.nt_min = job.params.nt_max;

  if (job.params.np_max <= 0) job.params.np_max = 1;
  if (job.params.np_min <= 0) job.params.np_min = job.params.np_max;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x840b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jg 0x7d7a8
movq -0x10(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jg 0x7d7c1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jg 0x7d7d8
movq -0x10(%rbp), %rax
movq $0x1, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jg 0x7d7f3
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)